okgeometry-api 0.4.2 → 0.4.4

package/dist/wasm-base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,0iryBAA0iryB,CAAC"}
+{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,8tq5BAA8tq5B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Geometry engine API for AEC applications — NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",

package/wasm/okgeometrycore.d.ts

@@ -93,6 +93,12 @@ export function fillet_polycurve(coords: Float64Array, radius: number, nx: numbe
  */
 export function line_length(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
 
+/**
+ * Offset a line segment perpendicular to line direction relative to reference normal.
+ * Returns [startX,startY,startZ,endX,endY,endZ]
+ */
+export function line_offset(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, distance: number, nx: number, ny: number, nz: number): Float64Array;
+
 /**
  * Evaluate a point on a line segment at parameter t ∈ [0,1].
  * Returns [x, y, z].
@@ -189,6 +195,13 @@ export function mesh_boolean_union(vertex_count_a: number, buffer_a: Float64Arra
  */
 export function mesh_boundary_polylines(vertex_count: number, buffer: Float64Array): Float64Array;
 
+/**
+ * Coplanar connected face groups.
+ * Output format:
+ * [groupCount, triCount, tri..., centroidX,centroidY,centroidZ, normalX,normalY,normalZ, ...]
+ */
+export function mesh_build_coplanar_connected_face_groups(vertex_count: number, buffer: Float64Array): Float64Array;
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -202,6 +215,16 @@ export function mesh_boundary_polylines(vertex_count: number, buffer: Float64Arr
  */
 export function mesh_chamfer_all_edges(mesh_type: string, params: Float64Array, offset: number): Float64Array;
 
+/**
+ * Compute planar curve normal from ordered points.
+ */
+export function mesh_compute_planar_curve_normal(coords: Float64Array, closed: boolean): Float64Array;
+
+/**
+ * Odd/even mesh containment test.
+ */
+export function mesh_contains_point(vertex_count: number, buffer: Float64Array, px: number, py: number, pz: number): boolean;
+
 /**
  * Create a box mesh and return buffers
  * Returns [vertices..., indices...]
@@ -243,6 +266,71 @@ export function mesh_evaluate(vertex_count: number, buffer: Float64Array, u: num
  */
 export function mesh_export_obj(vertex_count: number, buffer: Float64Array): string;
 
+/**
+ * Push/pull a planar face set by moving its coplanar connected region.
+ */
+export function mesh_extrude_face(vertex_count: number, buffer: Float64Array, face_index: number, distance: number): Float64Array;
+
+/**
+ * Extrude planar curve profile by normal * height.
+ */
+export function mesh_extrude_planar_curve(coords: Float64Array, nx: number, ny: number, nz: number, height: number, closed: boolean): 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;
+
+/**
+ * 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;
+
+/**
+ * Axis-aligned bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
+ */
+export function mesh_get_bounds(vertex_count: number, buffer: Float64Array): Float64Array;
+
+/**
+ * Coplanar connected face-group centroid containing a given triangle face index.
+ * Output format: [x, y, z] or [] when unavailable.
+ */
+export function mesh_get_coplanar_face_group_centroid(vertex_count: number, buffer: Float64Array, 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;
+
+/**
+ * Coplanar connected face region projected to a plane basis.
+ * Output format:
+ * [faceCount, faceIndex0, faceIndex1, ..., uMin, uMax, vMin, vMax]
+ */
+export function mesh_get_coplanar_face_region(vertex_count: number, buffer: Float64Array, face_index: number, ox: number, oy: number, oz: number, ux: number, uy: number, uz: number, vx: number, vy: number, vz: number, margin_scale: number, min_margin: number): Float64Array;
+
+/**
+ * Unique undirected triangle edges as [edgeCount, v0a, v0b, v1a, v1b, ...].
+ */
+export function mesh_get_edge_vertex_pairs(vertex_count: number, buffer: Float64Array): Float64Array;
+
+/**
+ * Face area.
+ */
+export function mesh_get_face_area(vertex_count: number, buffer: Float64Array, face_index: number): number;
+
+/**
+ * Face centroid as [x, y, z].
+ */
+export function mesh_get_face_centroid(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
+
+/**
+ * Face normal as [x, y, z].
+ */
+export function mesh_get_face_normal(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -254,6 +342,17 @@ export function mesh_get_stats(vertex_count: number, buffer: Float64Array): Floa
  */
 export function mesh_import_obj(obj_data: string): Float64Array;
 
+/**
+ * Check if triangulated mesh is a closed volume (no welded boundary edges).
+ */
+export function mesh_is_closed_volume(vertex_count: number, buffer: Float64Array): boolean;
+
+/**
+ * Merge multiple mesh buffers while preserving per-mesh vertex order and index remapping.
+ * Input format: [mesh_count, len1, mesh1..., len2, mesh2..., ...]
+ */
+export function mesh_merge(mesh_data: Float64Array): Float64Array;
+
 /**
  * Intersect two meshes, returning intersection polyline points.
  * Returns: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -275,6 +374,31 @@ export function mesh_patch_from_points(coords: Float64Array): Float64Array;
  */
 export function mesh_plane_intersect(vertex_count: number, buffer: Float64Array, nx: number, ny: number, nz: number, d: number): Float64Array;
 
+/**
+ * Shift closed boolean cutter curve and adjust height.
+ * Returns [height, epsilon, pointCount, x,y,z,...]
+ */
+export function mesh_prepare_boolean_cutter_curve(coords: Float64Array, closed: boolean, nx: number, ny: number, nz: number, height: number): Float64Array;
+
+/**
+ * Raycast against mesh and return closest hit.
+ * Output: [] when no hit, otherwise [pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance]
+ */
+export function mesh_raycast(vertex_count: number, buffer: Float64Array, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
+
+/**
+ * Raycast against mesh and return all hits sorted by distance.
+ * Output: [hitCount, (point, normal, faceIndex, distance)*]
+ */
+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;
+
+/**
+ * Raycast against many meshes packed as:
+ * [meshCount, meshLen0, meshRaw0..., meshLen1, meshRaw1..., ...]
+ * Output: [hitCount, meshIndex, pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance, ...]
+ */
+export function mesh_raycast_many(mesh_data: Float64Array, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
+
 /**
  * Rotate a mesh around an arbitrary axis and return new buffers
  * Axis is defined by (ax, ay, az), angle in radians

package/wasm/okgeometrycore.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./okgeometrycore_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    arc_length, arc_point_at, chamfer_polycurve, circle_length, circle_point_at, create_arc, create_circle, create_line, create_polyline, curve_to_points, evaluate_nurbs_curve_at, extrude_circle, extrude_line, extrude_polyline, fillet_polycurve, line_length, line_point_at, line_tangent, loft_circles, loft_nurbs_surface, loft_polylines, make_nurbs_curves_compatible, mesh_apply_matrix, mesh_boolean_intersection, mesh_boolean_operation, mesh_boolean_subtraction, mesh_boolean_union, mesh_boundary_polylines, mesh_chamfer_all_edges, mesh_create_box, mesh_create_cone, mesh_create_cylinder, mesh_create_prism, mesh_create_sphere, mesh_evaluate, mesh_export_obj, mesh_get_stats, mesh_import_obj, mesh_mesh_intersect, mesh_patch_from_points, mesh_plane_intersect, mesh_rotate, mesh_scale, mesh_translate, nurbs_curve_curve_intersect, nurbs_curve_plane_intersect, nurbs_surface_evaluate, nurbs_surface_plane_intersect, nurbs_surface_surface_intersect, offset_polyline_curve, polycurve_to_nurbs, polyline_length, polyline_point_at, ray_closest_point, ray_closest_point_parameter, ray_distance_to_point, ray_point_at, sample_nurbs_curve, sweep_curves, sweep_polylines, tessellate_nurbs_surface, test_wasm, version
+    arc_length, arc_point_at, chamfer_polycurve, circle_length, circle_point_at, create_arc, create_circle, create_line, create_polyline, curve_to_points, evaluate_nurbs_curve_at, extrude_circle, extrude_line, extrude_polyline, fillet_polycurve, line_length, line_offset, line_point_at, line_tangent, loft_circles, loft_nurbs_surface, loft_polylines, make_nurbs_curves_compatible, mesh_apply_matrix, mesh_boolean_intersection, mesh_boolean_operation, mesh_boolean_subtraction, mesh_boolean_union, mesh_boundary_polylines, mesh_build_coplanar_connected_face_groups, mesh_chamfer_all_edges, mesh_compute_planar_curve_normal, mesh_contains_point, mesh_create_box, mesh_create_cone, mesh_create_cylinder, mesh_create_prism, mesh_create_sphere, mesh_evaluate, mesh_export_obj, mesh_extrude_face, mesh_extrude_planar_curve, mesh_find_face_group_by_normal, mesh_find_face_group_by_triangle_index, mesh_get_bounds, mesh_get_coplanar_face_group_centroid, mesh_get_coplanar_face_indices, mesh_get_coplanar_face_region, mesh_get_edge_vertex_pairs, mesh_get_face_area, mesh_get_face_centroid, mesh_get_face_normal, mesh_get_stats, mesh_import_obj, mesh_is_closed_volume, mesh_merge, mesh_mesh_intersect, mesh_patch_from_points, mesh_plane_intersect, mesh_prepare_boolean_cutter_curve, mesh_raycast, mesh_raycast_all, mesh_raycast_many, mesh_rotate, mesh_scale, mesh_translate, nurbs_curve_curve_intersect, nurbs_curve_plane_intersect, nurbs_surface_evaluate, nurbs_surface_plane_intersect, nurbs_surface_surface_intersect, offset_polyline_curve, polycurve_to_nurbs, polyline_length, polyline_point_at, ray_closest_point, ray_closest_point_parameter, ray_distance_to_point, ray_point_at, sample_nurbs_curve, sweep_curves, sweep_polylines, tessellate_nurbs_surface, test_wasm, version
 } from "./okgeometrycore_bg.js";

package/wasm/okgeometrycore_bg.js

@@ -289,6 +289,28 @@ export function line_length(x1, y1, z1, x2, y2, z2) {
     return ret;
 }
 
+/**
+ * Offset a line segment perpendicular to line direction relative to reference normal.
+ * Returns [startX,startY,startZ,endX,endY,endZ]
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @param {number} distance
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @returns {Float64Array}
+ */
+export function line_offset(x1, y1, z1, x2, y2, z2, distance, nx, ny, nz) {
+    const ret = wasm.line_offset(x1, y1, z1, x2, y2, z2, distance, nx, ny, nz);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Evaluate a point on a line segment at parameter t ∈ [0,1].
  * Returns [x, y, z].
@@ -532,6 +554,23 @@ export function mesh_boundary_polylines(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Coplanar connected face groups.
+ * Output format:
+ * [groupCount, triCount, tri..., centroidX,centroidY,centroidZ, normalX,normalY,normalZ, ...]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_build_coplanar_connected_face_groups(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_build_coplanar_connected_face_groups(vertex_count, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -558,6 +597,37 @@ export function mesh_chamfer_all_edges(mesh_type, params, offset) {
     return v3;
 }
 
+/**
+ * Compute planar curve normal from ordered points.
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_compute_planar_curve_normal(coords, closed) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_compute_planar_curve_normal(ptr0, len0, closed);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Odd/even mesh containment test.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {boolean}
+ */
+export function mesh_contains_point(vertex_count, buffer, px, py, pz) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_contains_point(vertex_count, ptr0, len0, px, py, pz);
+    return ret !== 0;
+}
+
 /**
  * Create a box mesh and return buffers
  * Returns [vertices..., indices...]
@@ -672,6 +742,220 @@ export function mesh_export_obj(vertex_count, buffer) {
     }
 }
 
+/**
+ * Push/pull a planar face set by moving its coplanar connected region.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @param {number} distance
+ * @returns {Float64Array}
+ */
+export function mesh_extrude_face(vertex_count, buffer, face_index, distance) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_extrude_face(vertex_count, ptr0, len0, face_index, distance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Extrude planar curve profile by normal * height.
+ * @param {Float64Array} coords
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} height
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_extrude_planar_curve(coords, nx, ny, nz, height, closed) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_extrude_planar_curve(ptr0, len0, nx, ny, nz, height, closed);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Find the best matching coplanar connected face group by normal and optional near-point.
+ * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @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(vertex_count, buffer, nx, ny, nz, near_x, near_y, near_z, use_near_point) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_find_face_group_by_normal(vertex_count, ptr0, len0, nx, ny, nz, near_x, near_y, near_z, use_near_point);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Find the coplanar connected face group containing triangle_index.
+ * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} triangle_index
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_triangle_index(vertex_count, buffer, triangle_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_find_face_group_by_triangle_index(vertex_count, ptr0, len0, triangle_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Axis-aligned bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_get_bounds(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_bounds(vertex_count, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Coplanar connected face-group centroid containing a given triangle face index.
+ * Output format: [x, y, z] or [] when unavailable.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_group_centroid(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_coplanar_face_group_centroid(vertex_count, ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Edge-connected coplanar triangle indices as [count, i0, i1, ...].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_indices(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_coplanar_face_indices(vertex_count, ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Coplanar connected face region projected to a plane basis.
+ * Output format:
+ * [faceCount, faceIndex0, faceIndex1, ..., uMin, uMax, vMin, vMax]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} ux
+ * @param {number} uy
+ * @param {number} uz
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} margin_scale
+ * @param {number} min_margin
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_region(vertex_count, buffer, face_index, ox, oy, oz, ux, uy, uz, vx, vy, vz, margin_scale, min_margin) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_coplanar_face_region(vertex_count, ptr0, len0, face_index, ox, oy, oz, ux, uy, uz, vx, vy, vz, margin_scale, min_margin);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Unique undirected triangle edges as [edgeCount, v0a, v0b, v1a, v1b, ...].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_get_edge_vertex_pairs(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_edge_vertex_pairs(vertex_count, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Face area.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {number}
+ */
+export function mesh_get_face_area(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_face_area(vertex_count, ptr0, len0, face_index);
+    return ret;
+}
+
+/**
+ * Face centroid as [x, y, z].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_centroid(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_face_centroid(vertex_count, ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Face normal as [x, y, z].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_normal(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_face_normal(vertex_count, ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -702,6 +986,34 @@ export function mesh_import_obj(obj_data) {
     return v2;
 }
 
+/**
+ * Check if triangulated mesh is a closed volume (no welded boundary edges).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {boolean}
+ */
+export function mesh_is_closed_volume(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_is_closed_volume(vertex_count, ptr0, len0);
+    return ret !== 0;
+}
+
+/**
+ * Merge multiple mesh buffers while preserving per-mesh vertex order and index remapping.
+ * Input format: [mesh_count, len1, mesh1..., len2, mesh2..., ...]
+ * @param {Float64Array} mesh_data
+ * @returns {Float64Array}
+ */
+export function mesh_merge(mesh_data) {
+    const ptr0 = passArrayF64ToWasm0(mesh_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_merge(ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Intersect two meshes, returning intersection polyline points.
  * Returns: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -760,6 +1072,95 @@ export function mesh_plane_intersect(vertex_count, buffer, nx, ny, nz, d) {
     return v2;
 }
 
+/**
+ * Shift closed boolean cutter curve and adjust height.
+ * Returns [height, epsilon, pointCount, x,y,z,...]
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} height
+ * @returns {Float64Array}
+ */
+export function mesh_prepare_boolean_cutter_curve(coords, closed, nx, ny, nz, height) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_prepare_boolean_cutter_curve(ptr0, len0, closed, nx, ny, nz, height);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Raycast against mesh and return closest hit.
+ * Output: [] when no hit, otherwise [pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @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(vertex_count, buffer, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_raycast(vertex_count, ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Raycast against mesh and return all hits sorted by distance.
+ * Output: [hitCount, (point, normal, faceIndex, distance)*]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @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(vertex_count, buffer, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_raycast_all(vertex_count, ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Raycast against many meshes packed as:
+ * [meshCount, meshLen0, meshRaw0..., meshLen1, meshRaw1..., ...]
+ * Output: [hitCount, meshIndex, pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance, ...]
+ * @param {Float64Array} mesh_data
+ * @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_many(mesh_data, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ptr0 = passArrayF64ToWasm0(mesh_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_raycast_many(ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Rotate a mesh around an arbitrary axis and return new buffers
  * Axis is defined by (ax, ay, az), angle in radians

package/wasm/okgeometrycore_bg.wasm.d.ts

@@ -17,6 +17,7 @@ export const extrude_line: (a: number, b: number, c: number, d: number, e: numbe
 export const extrude_polyline: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
 export const fillet_polycurve: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const line_length: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const line_offset: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
 export const line_point_at: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
 export const line_tangent: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const loft_circles: (a: number, b: number, c: number, d: number) => [number, number];
@@ -29,7 +30,10 @@ export const mesh_boolean_operation: (a: number, b: number, c: number, d: 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_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];
+export const mesh_compute_planar_curve_normal: (a: number, b: number, c: number) => [number, number];
+export const mesh_contains_point: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const mesh_create_box: (a: number, b: number, c: number) => [number, number];
 export const mesh_create_cone: (a: number, b: number, c: number) => [number, number];
 export const mesh_create_cylinder: (a: number, b: number, c: number) => [number, number];
@@ -37,11 +41,29 @@ export const mesh_create_prism: (a: number, b: number, c: number) => [number, nu
 export const mesh_create_sphere: (a: number, b: number, c: number) => [number, number];
 export const mesh_evaluate: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const mesh_export_obj: (a: number, b: number, c: number) => [number, number];
+export const mesh_extrude_face: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const mesh_extrude_planar_curve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+export const 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];
+export const mesh_find_face_group_by_triangle_index: (a: number, b: number, c: number, d: number) => [number, number];
+export const mesh_get_bounds: (a: number, b: number, c: number) => [number, number];
+export const mesh_get_coplanar_face_group_centroid: (a: number, b: number, c: number, d: number) => [number, number];
+export const mesh_get_coplanar_face_indices: (a: number, b: number, c: number, d: number) => [number, number];
+export const 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];
+export const mesh_get_edge_vertex_pairs: (a: number, b: number, c: number) => [number, number];
+export const mesh_get_face_area: (a: number, b: number, c: number, d: number) => number;
+export const mesh_get_face_centroid: (a: number, b: number, c: number, d: number) => [number, number];
+export const mesh_get_face_normal: (a: number, b: number, c: number, d: number) => [number, number];
 export const mesh_get_stats: (a: number, b: number, c: number) => [number, number];
 export const mesh_import_obj: (a: number, b: number) => [number, number];
+export const mesh_is_closed_volume: (a: number, b: number, c: number) => number;
+export const mesh_merge: (a: number, b: number) => [number, number];
 export const mesh_mesh_intersect: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const mesh_patch_from_points: (a: number, b: number) => [number, number];
 export const mesh_plane_intersect: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+export const mesh_prepare_boolean_cutter_curve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+export const mesh_raycast: (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_raycast_all: (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_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_translate: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];