okgeometry-api 1.1.18 → 1.1.20

package/src/wasm-bindings.js

@@ -470,6 +470,35 @@ export function mesh_boolean_intersection(vertex_count_a, buffer_a, vertex_count
     return v3;
 }
 
+/**
+ * Debug helper: run the live kernel-mesh boolean entrypoint and surface the
+ * exact error instead of collapsing it into an empty output buffer.
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_kernel_mesh_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;
+        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 ret = wasm.mesh_boolean_kernel_mesh_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(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * @returns {number}
  */
@@ -484,24 +513,320 @@ export function mesh_boolean_last_debug_marker() {
  * @param {number} vertex_count_b
  * @param {Float64Array} buffer_b
  * @param {string} operation
- * @returns {Float64Array}
+ * @param {string} cleanup_stage
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_cleanup_triangle_dump(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation, cleanup_stage) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        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(cleanup_stage, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.mesh_boolean_manifold_port_cleanup_triangle_dump(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2, ptr3, len3);
+        deferred5_0 = ret[0];
+        deferred5_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} face_index
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_face2tri_face_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation, face_index) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        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 ret = wasm.mesh_boolean_manifold_port_face2tri_face_debug(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2, face_index);
+        deferred4_0 = ret[0];
+        deferred4_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} face_index
+ * @param {number} rotate_offset
+ * @param {boolean} reverse
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_face2tri_face_transform_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation, face_index, rotate_offset, reverse) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        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 ret = wasm.mesh_boolean_manifold_port_face2tri_face_transform_debug(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2, face_index, rotate_offset, reverse);
+        deferred4_0 = ret[0];
+        deferred4_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_final_triangle_dump(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;
+        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 ret = wasm.mesh_boolean_manifold_port_final_triangle_dump(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(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_flag_edge_attempts_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;
+        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 ret = wasm.mesh_boolean_manifold_port_flag_edge_attempts_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(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_intersections_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;
+        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 ret = wasm.mesh_boolean_manifold_port_intersections_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(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} face_p
+ * @param {number} face_q
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_new_edge_bucket_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation, face_p, face_q) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        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 ret = wasm.mesh_boolean_manifold_port_new_edge_bucket_debug(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2, face_p, face_q);
+        deferred4_0 = ret[0];
+        deferred4_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {string} cleanup_stage
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_overlap_boxes_cleanup_triangle_dump(cleanup_stage) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(cleanup_stage, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mesh_boolean_manifold_port_overlap_boxes_cleanup_triangle_dump(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} face_index
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_overlap_boxes_face2tri_face_debug(face_index) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.mesh_boolean_manifold_port_overlap_boxes_face2tri_face_debug(face_index);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} face_index
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_raw_face_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation, face_index) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        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 ret = wasm.mesh_boolean_manifold_port_raw_face_debug(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2, face_index);
+        deferred4_0 = ret[0];
+        deferred4_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_short_edge_attempts_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;
+        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 ret = wasm.mesh_boolean_manifold_port_short_edge_attempts_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(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} edge
+ * @returns {string}
  */
-export function mesh_boolean_operation(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 ret = wasm.mesh_boolean_operation(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 v4;
+export function mesh_boolean_manifold_port_single_swap_triangle_dump(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation, edge) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        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 ret = wasm.mesh_boolean_manifold_port_single_swap_triangle_dump(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2, edge);
+        deferred4_0 = ret[0];
+        deferred4_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
 }
 
 /**
- * Debug helper: perform boolean operation and return a textual status,
- * including kernel error reason on failure.
+ * Debug helper: run the isolated direct-port pipeline and surface stage counts
+ * so we can see where geometry diverges without involving legacy routing.
  * @param {number} vertex_count_a
  * @param {Float64Array} buffer_a
  * @param {number} vertex_count_b
@@ -509,7 +834,7 @@ export function mesh_boolean_operation(vertex_count_a, buffer_a, vertex_count_b,
  * @param {string} operation
  * @returns {string}
  */
-export function mesh_boolean_operation_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
+export function mesh_boolean_manifold_port_stage_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
     let deferred4_0;
     let deferred4_1;
     try {
@@ -519,7 +844,7 @@ 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 ret = wasm.mesh_boolean_operation_debug(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2);
+        const ret = wasm.mesh_boolean_manifold_port_stage_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]);
@@ -529,157 +854,107 @@ export function mesh_boolean_operation_debug(vertex_count_a, buffer_a, vertex_co
 }
 
 /**
- * Perform boolean operation and return stage-level profiling data followed by
- * the result mesh buffer.
- *
- * Output format:
- * [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, 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,
- *  arrangement_adj_attempts, arrangement_adj_fast_hits, arrangement_adj_disabled_split_limit,
- *  arrangement_adj_fallback_no_half_edges, arrangement_adj_fallback_collect_failed,
- *  arrangement_adj_fallback_non_manifold, arrangement_adj_fallback_loop_mismatch,
- *  arrangement_adj_fallback_twin_mismatch, arrangement_adj_fallback_invalid_face_index,
- *  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
  * @param {number} vertex_count_b
  * @param {Float64Array} buffer_b
  * @param {string} operation
- * @returns {Float64Array}
+ * @returns {string}
  */
-export function mesh_boolean_operation_profiled(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 ret = wasm.mesh_boolean_operation_profiled(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 v4;
+export function mesh_boolean_manifold_port_swappable_edges_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;
+        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 ret = wasm.mesh_boolean_manifold_port_swappable_edges_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(deferred4_0, deferred4_1, 1);
+    }
 }
 
 /**
- * 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
- * @returns {Float64Array}
+ * @param {string} operation
+ * @returns {string}
  */
-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 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 v3;
+export function mesh_boolean_manifold_port_triangulated_triangle_dump(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;
+        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 ret = wasm.mesh_boolean_manifold_port_triangulated_triangle_dump(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(deferred4_0, deferred4_1, 1);
+    }
 }
 
 /**
- * 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_operation(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_operation(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;
 }
 
 /**
+ * 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
- * @returns {Float64Array}
+ * @returns {string}
  */
-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 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 v4;
+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;
+        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 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(deferred4_0, deferred4_1, 1);
+    }
 }
 
 /**
@@ -688,40 +963,71 @@ export function mesh_boolean_whole_partial_candidate(vertex_count_a, buffer_a, v
  * @param {number} vertex_count_b
  * @param {Float64Array} buffer_b
  * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_port_triangle_dump(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;
+        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 ret = wasm.mesh_boolean_port_triangle_dump(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(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * 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
  * @returns {Float64Array}
  */
-export function mesh_boolean_whole_partial_candidate_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
+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 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();
+    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 v4;
+    return v3;
 }
 
 /**
+ * Perform boolean operation and return stage-level profiling data followed by
+ * the result mesh buffer.
+ *
+ * Output format:
+ * [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,
+ * 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_whole_partial_candidate_debug_full(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
+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 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();
+    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 v4;
+    return v3;
 }
 
 /**
@@ -1185,6 +1491,72 @@ export function mesh_is_closed_volume(vertex_count, buffer) {
     return ret !== 0;
 }
 
+/**
+ * Debug helper: run only the isolated direct-port `MeshGL -> Impl -> MeshGL`
+ * normalization owner and return a JSON dump. This is for source-stage
+ * comparison against official manifold-3d import/export, not legacy routing.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {boolean} trusted_input
+ * @returns {string}
+ */
+export function mesh_manifold_port_import_roundtrip_debug(vertex_count, buffer, trusted_input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mesh_manifold_port_import_roundtrip_debug(vertex_count, ptr0, len0, trusted_input);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {boolean} trusted_input
+ * @returns {string}
+ */
+export function mesh_manifold_port_import_stage_hashes_debug(vertex_count, buffer, trusted_input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mesh_manifold_port_import_stage_hashes_debug(vertex_count, ptr0, len0, trusted_input);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {Float64Array} data
+ * @param {number} epsilon
+ * @param {boolean} allow_convex
+ * @returns {string}
+ */
+export function mesh_manifold_port_triangulate_projected_polygon_debug(data, epsilon, allow_convex) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mesh_manifold_port_triangulate_projected_polygon_debug(ptr0, len0, epsilon, allow_convex);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Merge multiple mesh buffers while preserving per-mesh vertex order and index remapping.
  * Input format: [mesh_count, len1, mesh1..., len2, mesh2..., ...]
@@ -1401,6 +1773,26 @@ export function mesh_topology_metrics(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Return raw index-topology metrics for a triangulated mesh buffer:
+ * `[boundary_edges, non_manifold_edges]`.
+ *
+ * Unlike `mesh_topology_metrics`, this preserves duplicate same-position seam
+ * vertices. That makes it a closer fit for trusted MeshGL-style boolean meshes,
+ * where manifoldness comes from explicit topology rather than position welding.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_topology_metrics_raw(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_topology_metrics_raw(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
@@ -1777,10 +2169,6 @@ export function version() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___okgeometry_boolean_should_cancel_c9088108881414a9: function() {
-            const ret = globalThis.__okgeometry_boolean_should_cancel();
-            return ret;
-        },
         __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },