okgeometry-api 1.26.1 → 1.27.0

package/src/wasm-bindings.d.ts

@@ -658,6 +658,11 @@ export function mesh_boolean_union_all(packed: Float64Array, flags: string): Flo
  */
 export function mesh_boundary_edge_segments(vertex_count: number, buffer: Float64Array): Float64Array;
 
+/**
+ * Handle variant of `mesh_boundary_edge_segments`.
+ */
+export function mesh_boundary_edge_segments_h(id: number): Float64Array;
+
 /**
  * Extract boundary (perimeter) edges from a mesh as polylines.
  * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -684,6 +689,11 @@ export function mesh_build_coplanar_connected_face_groups(vertex_count: number,
  */
 export function mesh_build_render_buffers(vertex_count: number, buffer: Float64Array, crease_angle_deg: number): Float32Array;
 
+/**
+ * Handle variant of `mesh_build_render_buffers`.
+ */
+export function mesh_build_render_buffers_h(id: number, crease_angle_deg: number): Float32Array;
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -816,18 +826,33 @@ export function mesh_extrude_planar_curve(coords: Float64Array, nx: number, ny:
  */
 export function mesh_feature_edge_chains(vertex_count: number, buffer: Float64Array): Float64Array;
 
+/**
+ * Handle variant of `mesh_feature_edge_chains`.
+ */
+export function mesh_feature_edge_chains_h(id: number): Float64Array;
+
 /**
  * Find the best matching coplanar connected face group by normal and optional near-point.
  * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
  */
 export function mesh_find_face_group_by_normal(vertex_count: number, buffer: Float64Array, nx: number, ny: number, nz: number, near_x: number, near_y: number, near_z: number, use_near_point: boolean): Float64Array;
 
+/**
+ * Handle variant of `mesh_find_face_group_by_normal`.
+ */
+export function mesh_find_face_group_by_normal_h(id: number, nx: number, ny: number, nz: number, near_x: number, near_y: number, near_z: number, use_near_point: boolean): Float64Array;
+
 /**
  * Find the coplanar connected face group containing triangle_index.
  * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
  */
 export function mesh_find_face_group_by_triangle_index(vertex_count: number, buffer: Float64Array, triangle_index: number): Float64Array;
 
+/**
+ * Handle variant of `mesh_find_face_group_by_triangle_index`.
+ */
+export function mesh_find_face_group_by_triangle_index_h(id: number, triangle_index: number): Float64Array;
+
 /**
  * Axis-aligned bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
  */
@@ -839,11 +864,21 @@ export function mesh_get_bounds(vertex_count: number, buffer: Float64Array): Flo
  */
 export function mesh_get_coplanar_face_group_centroid(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
 
+/**
+ * Handle variant of `mesh_get_coplanar_face_group_centroid`.
+ */
+export function mesh_get_coplanar_face_group_centroid_h(id: number, face_index: number): Float64Array;
+
 /**
  * Edge-connected coplanar triangle indices as [count, i0, i1, ...].
  */
 export function mesh_get_coplanar_face_indices(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
 
+/**
+ * Handle variant of `mesh_get_coplanar_face_indices`.
+ */
+export function mesh_get_coplanar_face_indices_h(id: number, face_index: number): Float64Array;
+
 /**
  * Coplanar connected face region projected to a plane basis.
  * Output format:
@@ -856,6 +891,11 @@ export function mesh_get_coplanar_face_region(vertex_count: number, buffer: Floa
  */
 export function mesh_get_edge_vertex_pairs(vertex_count: number, buffer: Float64Array): Float64Array;
 
+/**
+ * Handle variant of `mesh_get_edge_vertex_pairs`.
+ */
+export function mesh_get_edge_vertex_pairs_h(id: number): Float64Array;
+
 /**
  * Face area.
  */
@@ -874,6 +914,11 @@ export function mesh_get_face_area(vertex_count: number, buffer: Float64Array, f
  */
 export function mesh_get_face_boundary_loops(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
 
+/**
+ * Handle variant of `mesh_get_face_boundary_loops`.
+ */
+export function mesh_get_face_boundary_loops_h(id: number, face_index: number): Float64Array;
+
 /**
  * Face centroid as [x, y, z].
  */
@@ -893,6 +938,11 @@ export function mesh_get_face_normal(vertex_count: number, buffer: Float64Array,
  */
 export function mesh_get_smooth_face_group(vertex_count: number, buffer: Float64Array, face_index: number, max_angle_deg: number): Float64Array;
 
+/**
+ * Handle variant of `mesh_get_smooth_face_group`.
+ */
+export function mesh_get_smooth_face_group_h(id: number, face_index: number, max_angle_deg: number): Float64Array;
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -1017,6 +1067,16 @@ export function mesh_raycast(vertex_count: number, buffer: Float64Array, ox: num
  */
 export function mesh_raycast_all(vertex_count: number, buffer: Float64Array, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
 
+/**
+ * Handle variant of `mesh_raycast_all` — reuses the stored mesh's cached BVH.
+ */
+export function mesh_raycast_all_h(id: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
+
+/**
+ * Handle variant of `mesh_raycast` — reuses the stored mesh's cached BVH.
+ */
+export function mesh_raycast_h(id: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
+
 /**
  * Raycast against many meshes packed as:
  * [meshCount, meshLen0, meshRaw0..., meshLen1, meshRaw1..., ...]
@@ -1043,6 +1103,11 @@ export function mesh_repair(vertex_count: number, buffer: Float64Array, flags: n
  */
 export function mesh_repair_diagnostics(vertex_count: number, buffer: Float64Array): Float64Array;
 
+/**
+ * Handle variant of `mesh_repair_diagnostics`.
+ */
+export function mesh_repair_diagnostics_h(id: number): Float64Array;
+
 /**
  * Rotate a mesh around an arbitrary axis and return new buffers
  * Axis is defined by (ax, ay, az), angle in radians
@@ -1099,6 +1164,28 @@ export function mesh_split_by_surface_to_brep(vertex_count: number, buffer: Floa
  */
 export function mesh_split_polyline(vertex_count: number, buffer: Float64Array, points: Float64Array, closed: boolean): Float64Array;
 
+/**
+ * Store a mesh buffer `[vertexCount, x,y,z..., i0,i1,i2...]` WASM-side.
+ * Returns a non-zero id, or 0 on invalid input.
+ */
+export function mesh_store(vertex_count: number, buffer: Float64Array): number;
+
+/**
+ * Approximate bytes held by stored mesh raw buffers (diagnostics/tests).
+ * Excludes lazy raycast caches.
+ */
+export function mesh_store_bytes(): number;
+
+/**
+ * Number of stored meshes (diagnostics/tests).
+ */
+export function mesh_store_count(): number;
+
+/**
+ * Release a stored mesh and free its memory (idempotent).
+ */
+export function mesh_store_free(id: number): void;
+
 /**
  * Trim an OPEN host surface by all closed cutter meshes in one WASM call.
  *
@@ -1701,9 +1788,11 @@ export interface InitOutput {
     readonly mesh_boolean_union: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_boolean_union_all: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_boundary_edge_segments: (a: number, b: number, c: number) => [number, number];
+    readonly mesh_boundary_edge_segments_h: (a: 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_build_render_buffers: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly mesh_build_render_buffers_h: (a: number, b: number) => [number, number];
     readonly mesh_chamfer_all_edges: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_chamfer_edges: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_clip_polyline: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
@@ -1722,18 +1811,26 @@ export interface InitOutput {
     readonly mesh_extrude_face: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_extrude_planar_curve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly mesh_feature_edge_chains: (a: number, b: number, c: number) => [number, number];
+    readonly mesh_feature_edge_chains_h: (a: number) => [number, number];
     readonly mesh_find_face_group_by_normal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly mesh_find_face_group_by_normal_h: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_find_face_group_by_triangle_index: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly mesh_find_face_group_by_triangle_index_h: (a: number, b: number) => [number, number];
     readonly mesh_get_bounds: (a: number, b: number, c: number) => [number, number];
     readonly mesh_get_coplanar_face_group_centroid: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly mesh_get_coplanar_face_group_centroid_h: (a: number, b: number) => [number, number];
     readonly mesh_get_coplanar_face_indices: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly mesh_get_coplanar_face_indices_h: (a: number, b: number) => [number, number];
     readonly mesh_get_coplanar_face_region: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number) => [number, number];
     readonly mesh_get_edge_vertex_pairs: (a: number, b: number, c: number) => [number, number];
+    readonly mesh_get_edge_vertex_pairs_h: (a: number) => [number, number];
     readonly mesh_get_face_area: (a: number, b: number, c: number, d: number) => number;
     readonly mesh_get_face_boundary_loops: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly mesh_get_face_boundary_loops_h: (a: number, b: number) => [number, number];
     readonly mesh_get_face_centroid: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_get_face_normal: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_get_smooth_face_group: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly mesh_get_smooth_face_group_h: (a: number, b: number, c: number) => [number, number];
     readonly mesh_get_stats: (a: number, b: number, c: number) => [number, number];
     readonly mesh_import_obj: (a: number, b: number) => [number, number];
     readonly mesh_import_stl: (a: number, b: number, c: number) => [number, number];
@@ -1752,9 +1849,12 @@ export interface InitOutput {
     readonly mesh_prepare_hosted_boolean_cutter: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
     readonly mesh_raycast: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
     readonly mesh_raycast_all: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly mesh_raycast_all_h: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+    readonly mesh_raycast_h: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     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_repair: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_repair_diagnostics: (a: number, b: number, c: number) => [number, number];
+    readonly mesh_repair_diagnostics_h: (a: 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_sheet_union: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
@@ -1762,6 +1862,9 @@ export interface InitOutput {
     readonly mesh_solid_split_plane: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
     readonly mesh_split_by_surface_to_brep: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_split_polyline: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly mesh_store: (a: number, b: number, c: number) => number;
+    readonly mesh_store_bytes: () => number;
+    readonly mesh_store_free: (a: number) => void;
     readonly mesh_surface_difference_all: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_surface_split: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_surface_split_plane: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
@@ -1830,6 +1933,7 @@ export interface InitOutput {
     readonly test_wasm: () => [number, number];
     readonly thicken_polycurve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly version: () => [number, number];
+    readonly mesh_store_count: () => 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/src/wasm-bindings.js

@@ -2086,6 +2086,18 @@ export function mesh_boundary_edge_segments(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_boundary_edge_segments`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_boundary_edge_segments_h(id) {
+    const ret = wasm.mesh_boundary_edge_segments_h(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Extract boundary (perimeter) edges from a mesh as polylines.
  * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -2143,6 +2155,19 @@ export function mesh_build_render_buffers(vertex_count, buffer, crease_angle_deg
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_build_render_buffers`.
+ * @param {number} id
+ * @param {number} crease_angle_deg
+ * @returns {Float32Array}
+ */
+export function mesh_build_render_buffers_h(id, crease_angle_deg) {
+    const ret = wasm.mesh_build_render_buffers_h(id, crease_angle_deg);
+    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -2489,6 +2514,18 @@ export function mesh_feature_edge_chains(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_feature_edge_chains`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_feature_edge_chains_h(id) {
+    const ret = wasm.mesh_feature_edge_chains_h(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Find the best matching coplanar connected face group by normal and optional near-point.
  * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
@@ -2512,6 +2549,25 @@ export function mesh_find_face_group_by_normal(vertex_count, buffer, nx, ny, nz,
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_find_face_group_by_normal`.
+ * @param {number} id
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} near_x
+ * @param {number} near_y
+ * @param {number} near_z
+ * @param {boolean} use_near_point
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_normal_h(id, nx, ny, nz, near_x, near_y, near_z, use_near_point) {
+    const ret = wasm.mesh_find_face_group_by_normal_h(id, nx, ny, nz, near_x, near_y, near_z, use_near_point);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Find the coplanar connected face group containing triangle_index.
  * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
@@ -2529,6 +2585,19 @@ export function mesh_find_face_group_by_triangle_index(vertex_count, buffer, tri
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_find_face_group_by_triangle_index`.
+ * @param {number} id
+ * @param {number} triangle_index
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_triangle_index_h(id, triangle_index) {
+    const ret = wasm.mesh_find_face_group_by_triangle_index_h(id, triangle_index);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Axis-aligned bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
  * @param {number} vertex_count
@@ -2561,6 +2630,19 @@ export function mesh_get_coplanar_face_group_centroid(vertex_count, buffer, face
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_coplanar_face_group_centroid`.
+ * @param {number} id
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_group_centroid_h(id, face_index) {
+    const ret = wasm.mesh_get_coplanar_face_group_centroid_h(id, face_index);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Edge-connected coplanar triangle indices as [count, i0, i1, ...].
  * @param {number} vertex_count
@@ -2577,6 +2659,19 @@ export function mesh_get_coplanar_face_indices(vertex_count, buffer, face_index)
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_coplanar_face_indices`.
+ * @param {number} id
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_indices_h(id, face_index) {
+    const ret = wasm.mesh_get_coplanar_face_indices_h(id, face_index);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Coplanar connected face region projected to a plane basis.
  * Output format:
@@ -2621,6 +2716,18 @@ export function mesh_get_edge_vertex_pairs(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_edge_vertex_pairs`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_get_edge_vertex_pairs_h(id) {
+    const ret = wasm.mesh_get_edge_vertex_pairs_h(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Face area.
  * @param {number} vertex_count
@@ -2659,6 +2766,19 @@ export function mesh_get_face_boundary_loops(vertex_count, buffer, face_index) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_face_boundary_loops`.
+ * @param {number} id
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_boundary_loops_h(id, face_index) {
+    const ret = wasm.mesh_get_face_boundary_loops_h(id, face_index);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Face centroid as [x, y, z].
  * @param {number} vertex_count
@@ -2712,6 +2832,20 @@ export function mesh_get_smooth_face_group(vertex_count, buffer, face_index, max
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_smooth_face_group`.
+ * @param {number} id
+ * @param {number} face_index
+ * @param {number} max_angle_deg
+ * @returns {Float64Array}
+ */
+export function mesh_get_smooth_face_group_h(id, face_index, max_angle_deg) {
+    const ret = wasm.mesh_get_smooth_face_group_h(id, face_index, max_angle_deg);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -3079,6 +3213,44 @@ export function mesh_raycast_all(vertex_count, buffer, ox, oy, oz, dx, dy, dz, m
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_raycast_all` — reuses the stored mesh's cached BVH.
+ * @param {number} id
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_all_h(id, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ret = wasm.mesh_raycast_all_h(id, ox, oy, oz, dx, dy, dz, max_distance);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Handle variant of `mesh_raycast` — reuses the stored mesh's cached BVH.
+ * @param {number} id
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_h(id, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ret = wasm.mesh_raycast_h(id, ox, oy, oz, dx, dy, dz, max_distance);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Raycast against many meshes packed as:
  * [meshCount, meshLen0, meshRaw0..., meshLen1, meshRaw1..., ...]
@@ -3144,6 +3316,18 @@ export function mesh_repair_diagnostics(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_repair_diagnostics`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_repair_diagnostics_h(id) {
+    const ret = wasm.mesh_repair_diagnostics_h(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Rotate a mesh around an arbitrary axis and return new buffers
  * Axis is defined by (ax, ay, az), angle in radians
@@ -3316,6 +3500,47 @@ export function mesh_split_polyline(vertex_count, buffer, points, closed) {
     return v3;
 }
 
+/**
+ * Store a mesh buffer `[vertexCount, x,y,z..., i0,i1,i2...]` WASM-side.
+ * Returns a non-zero id, or 0 on invalid input.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {number}
+ */
+export function mesh_store(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_store(vertex_count, ptr0, len0);
+    return ret >>> 0;
+}
+
+/**
+ * Approximate bytes held by stored mesh raw buffers (diagnostics/tests).
+ * Excludes lazy raycast caches.
+ * @returns {number}
+ */
+export function mesh_store_bytes() {
+    const ret = wasm.mesh_store_bytes();
+    return ret;
+}
+
+/**
+ * Number of stored meshes (diagnostics/tests).
+ * @returns {number}
+ */
+export function mesh_store_count() {
+    const ret = wasm.mesh_store_count();
+    return ret >>> 0;
+}
+
+/**
+ * Release a stored mesh and free its memory (idempotent).
+ * @param {number} id
+ */
+export function mesh_store_free(id) {
+    wasm.mesh_store_free(id);
+}
+
 /**
  * Trim an OPEN host surface by all closed cutter meshes in one WASM call.
  *

package/src/workerHelpers-threaded.js

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2022 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Note: we use `wasm_bindgen_worker_`-prefixed message types to make sure
+// we can handle bundling into other files, which might happen to have their
+// own `postMessage`/`onmessage` communication channels.
+//
+// If we didn't take that into the account, we could send much simpler signals
+// like just `0` or whatever, but the code would be less resilient.
+
+function waitForMsgType(target, type) {
+  return new Promise(resolve => {
+    target.addEventListener('message', function onMsg({ data }) {
+      if (data?.type !== type) return;
+      target.removeEventListener('message', onMsg);
+      resolve(data);
+    });
+  });
+}
+
+waitForMsgType(self, 'wasm_bindgen_worker_init').then(async ({ init, receiver }) => {
+  // # Note 1
+  // Our JS should have been generated in
+  // `[out-dir]/snippets/wasm-bindgen-rayon-[hash]/workerHelpers.js`,
+  // resolve the main module via `../../..`.
+  //
+  // This might need updating if the generated structure changes on wasm-bindgen
+  // side ever in the future, but works well with bundlers today. The whole
+  // point of this crate, after all, is to abstract away unstable features
+  // and temporary bugs so that you don't need to deal with them in your code.
+  //
+  // # Note 2
+  // This could be a regular import, but then some bundlers complain about
+  // circular deps.
+  //
+  // Dynamic import could be cheap if this file was inlined into the parent,
+  // which would require us just using `../../..` in `new Worker` below,
+  // but that doesn't work because wasm-pack unconditionally adds
+  // "sideEffects":false (see below).
+  //
+  // OTOH, even though it can't be inlined, it should be still reasonably
+  // cheap since the requested file is already in cache (it was loaded by
+  // the main thread).
+  const pkg = await import('./wasm-bindings-threaded.js');
+  await pkg.default(init);
+  postMessage({ type: 'wasm_bindgen_worker_ready' });
+  pkg.wbg_rayon_start_worker(receiver);
+});
+
+// Note: this is never used, but necessary to prevent a bug in Firefox
+// (https://bugzilla.mozilla.org/show_bug.cgi?id=1702191) where it collects
+// Web Workers that have a shared WebAssembly memory with the main thread,
+// but are not explicitly rooted via a `Worker` instance.
+//
+// By storing them in a variable, we can keep `Worker` objects around and
+// prevent them from getting GC-d.
+let _workers;
+
+export async function startWorkers(module, memory, builder) {
+  if (builder.numThreads() === 0) {
+    throw new Error(`num_threads must be > 0.`);
+  }
+
+  const workerInit = {
+    type: 'wasm_bindgen_worker_init',
+    init: { module_or_path: module, memory },
+    receiver: builder.receiver()
+  };
+
+  _workers = await Promise.all(
+    Array.from({ length: builder.numThreads() }, async () => {
+      // Self-spawn into a new Worker.
+      //
+      // TODO: while `new URL('...', import.meta.url) becomes a semi-standard
+      // way to get asset URLs relative to the module across various bundlers
+      // and browser, ideally we should switch to `import.meta.resolve`
+      // once it becomes a standard.
+      //
+      // Note: we could use `../../..` as the URL here to inline workerHelpers.js
+      // into the parent entry instead of creating another split point -
+      // this would be preferable from optimization perspective -
+      // however, Webpack then eliminates all message handler code
+      // because wasm-pack produces "sideEffects":false in package.json
+      // unconditionally.
+      //
+      // The only way to work around that is to have side effect code
+      // in an entry point such as Worker file itself.
+      const worker = new Worker(new URL('./workerHelpers-threaded.js', import.meta.url), {
+        type: 'module'
+      });
+      worker.postMessage(workerInit);
+      await waitForMsgType(worker, 'wasm_bindgen_worker_ready');
+      return worker;
+    })
+  );
+  builder.build();
+}