okgeometry-api 1.11.0 → 1.14.0

package/src/wasm-bindings.d.ts

@@ -20,23 +20,65 @@ export function arc_point_at(cx: number, cy: number, cz: number, nx: number, ny:
  */
 export function brep_boolean_op(a_json: string, b_json: string, op: string, tolerance: number): string;
 
+/**
+ * Closest BREP face to a 3D point. Returns [faceIndex, u, v, distance,
+ * isNurbs] ((u, v) in the surface's KNOT domain) or empty on failure.
+ */
+export function brep_closest_face(json: string, x: number, y: number, z: number): Float64Array;
+
 /**
  * All BREP edges as polylines: [num_polylines, n1, x,y,z..., n2, ...].
  */
 export function brep_edges(json: string, tolerance: number): Float64Array;
 
+/**
+ * Extract one face as a standalone single-face TRIMMED sheet BREP (trim
+ * loops, pcurves, edges and vertices preserved). Returns JSON, empty on
+ * failure.
+ */
+export function brep_extract_face(json: string, face_index: number): string;
+
+/**
+ * ALL faces as standalone single-face trimmed sheet BREPs, in one crossing
+ * (the source JSON is parsed once). Returns a JSON ARRAY aligned with face
+ * indices; faces that fail to extract are `null`.
+ */
+export function brep_extract_faces(json: string): string;
+
 /**
  * Extrude a profile curve into a BREP (closed profile → capped solid,
  * open profile → sheet). Returns JSON.
  */
 export function brep_extrude_curve(curve_data: Float64Array, dx: number, dy: number, dz: number, height: number): string;
 
+/**
+ * Exact (u, v) of a point on a specific BREP face (closest-point Newton for
+ * NURBS, frame projection for planes). Returns [u, v, distance, isNurbs].
+ */
+export function brep_face_closest_uv(json: string, face_index: number, x: number, y: number, z: number): Float64Array;
+
 /**
  * Iso-parametric curve of a NURBS face's backing surface (untrimmed).
  * Returns curve data, or empty for planar faces.
  */
 export function brep_face_iso_curve(json: string, face_index: number, t: number, u_dir: boolean): Float64Array;
 
+/**
+ * Exact isocurve(s) of a BREP face at KNOT-domain parameter `t`, CLIPPED to
+ * the face's trimmed region. `u_dir = true` runs along u at fixed v = t.
+ * Line pieces (planar faces) are encoded as degree-1 NURBS.
+ * Packing: [curveCount, (bufLen, curveData…)·curveCount] where curveData is
+ * the standard NURBS curve encoding.
+ */
+export function brep_face_iso_curves_trimmed(json: string, face_index: number, t: number, u_dir: boolean): Float64Array;
+
+/**
+ * Like `brep_face_iso_curves_trimmed`, but `t` is NORMALIZED [0, 1] across
+ * the face's trim extent in the fixed direction — callers don't need the
+ * surface knot domain. Same packing.
+ */
+export function brep_face_iso_curves_trimmed_normalized(json: string, face_index: number, t: number, u_dir: boolean): Float64Array;
+
 /**
  * Geometric backing of a face.
  * Returns [0, ox,oy,oz, ux,uy,uz, vx,vy,vz] for planes,
@@ -44,11 +86,38 @@ export function brep_face_iso_curve(json: string, face_index: number, t: number,
  */
 export function brep_face_surface(json: string, face_index: number): Float64Array;
 
+/**
+ * Underlying surface of a face CROPPED to its trim extent, ALWAYS as a NURBS
+ * surface (planar faces become exact degree-1 patches). Returns surface
+ * data, empty on failure.
+ */
+export function brep_face_surface_cropped(json: string, face_index: number): Float64Array;
+
+/**
+ * Batch variant of `brep_face_surface_cropped` for all faces in one
+ * crossing. Packing: [faceCount, (bufLen, surfaceData…)·faceCount], aligned
+ * with face indices — a face that fails to crop gets bufLen 0.
+ */
+export function brep_face_surfaces_cropped(json: string): Float64Array;
+
 /**
  * Tessellate a single BREP face. Returns the standard mesh buffer.
  */
 export function brep_face_tessellate(json: string, face_index: number, tolerance: number): Float64Array;
 
+/**
+ * UV bounding box of a face's trim loops in surface parameter space:
+ * [u_min, u_max, v_min, v_max]. Empty on failure.
+ */
+export function brep_face_trim_bounds(json: string, face_index: number): Float64Array;
+
+/**
+ * Convert a closed manifold triangle mesh into a planar-face BREP.
+ * `normal_angle_tol_deg` ≤ 0 selects the default (≈0.057°); `max_faces` 0 =
+ * default guard (4096). Returns BREP JSON or {"error": ...}.
+ */
+export function brep_from_mesh_buffer(vertex_count: number, buffer: Float64Array, normal_angle_tol_deg: number, max_faces: number): string;
+
 /**
  * BREP structure summary: [face_count, edge_count, vertex_count, is_closed].
  */
@@ -81,12 +150,30 @@ export function brep_revolve_curve(curve_data: Float64Array, ox: number, oy: num
  */
 export function brep_sheet_from_surface(surface_data: Float64Array): string;
 
+/**
+ * Split a closed solid BREP by a sheet BREP into BOTH capped halves.
+ * Returns {"negative": <brep|null>, "positive": <brep|null>} or {"error":...}.
+ * Sides follow the sheet normal (negative = behind it), matching
+ * `mesh_solid_split_by_surface`.
+ */
+export function brep_split_solid_by_sheet_op(solid_json: string, sheet_json: string, tolerance: number): string;
+
 /**
  * Tessellate a BREP into the standard mesh buffer
  * [vertexCount, positions..., indices...]. Crack-free across shared edges.
  */
 export function brep_tessellate(json: string, tolerance: number): Float64Array;
 
+/**
+ * Tessellate a BREP with per-face triangle ranges for face-level picking.
+ * `tolerance <= 0` selects the deterministic auto display tolerance (from the
+ * BREP's own extent), so triangle indices from a previously produced
+ * auto-tolerance display mesh stay valid across calls.
+ * Packing: [vertexCount, indexCount, rangeCount,
+ *           positions(3·vc), indices(ic), (face, firstTri, triCount)·rc].
+ */
+export function brep_tessellate_with_face_ranges(json: string, tolerance: number): Float64Array;
+
 /**
  * Apply a row-major 4x4 matrix to a BREP. Returns transformed JSON.
  */
@@ -544,6 +631,19 @@ export function mesh_get_edge_vertex_pairs(vertex_count: number, buffer: Float64
  */
 export function mesh_get_face_area(vertex_count: number, buffer: Float64Array, face_index: number): number;
 
+/**
+ * Boundary loops of the coplanar connected face group containing `face_index`.
+ *
+ * Boundary edges are the directed triangle edges whose reversed twin is not
+ * present within the group; chaining them preserves the group's winding.
+ * Consecutive collinear points (T-junction subdivisions) are collapsed so
+ * consumers receive clean polygon corners.
+ *
+ * Output format: [loopCount, (pointCount, x, y, z, ...) per loop].
+ * Loops are implicitly closed (last point connects back to the first).
+ */
+export function mesh_get_face_boundary_loops(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
+
 /**
  * Face centroid as [x, y, z].
  */
@@ -681,6 +781,14 @@ export function mesh_solid_split_by_surface(vertex_count_a: number, buffer_a: Fl
 
 export function mesh_solid_split_plane(vertex_count: number, buffer: Float64Array, nx: number, ny: number, nz: number, d: number, operation: string): Float64Array;
 
+/**
+ * One-shot production path: closed manifold triangle mesh ÷ NURBS surface →
+ * both halves as exact capped BREPs, in a single WASM crossing (mesh→BREP
+ * conversion, sheet construction and the parametric split all run kernel-side).
+ * Returns {"negative": <brep|null>, "positive": <brep|null>} or {"error":...}.
+ */
+export function mesh_split_by_surface_to_brep(vertex_count: number, buffer: Float64Array, surface_data: Float64Array, tolerance: number, normal_angle_tol_deg: number, max_faces: number): string;
+
 /**
  * Trim an OPEN host surface by all closed cutter meshes in one WASM call.
  *
@@ -970,17 +1078,29 @@ export interface InitOutput {
     readonly arc_length: (a: number, b: number, c: number) => number;
     readonly arc_point_at: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
     readonly brep_boolean_op: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly brep_closest_face: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly brep_edges: (a: number, b: number, c: number) => [number, number];
+    readonly brep_extract_face: (a: number, b: number, c: number) => [number, number];
+    readonly brep_extract_faces: (a: number, b: number) => [number, number];
     readonly brep_extrude_curve: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly brep_face_closest_uv: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly brep_face_iso_curve: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly brep_face_iso_curves_trimmed: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly brep_face_iso_curves_trimmed_normalized: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly brep_face_surface: (a: number, b: number, c: number) => [number, number];
+    readonly brep_face_surface_cropped: (a: number, b: number, c: number) => [number, number];
+    readonly brep_face_surfaces_cropped: (a: number, b: number) => [number, number];
     readonly brep_face_tessellate: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly brep_face_trim_bounds: (a: number, b: number, c: number) => [number, number];
+    readonly brep_from_mesh_buffer: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly brep_info: (a: number, b: number) => [number, number];
     readonly brep_loft_curves: (a: number, b: number) => [number, number];
     readonly brep_primitive: (a: number, b: number, c: number, d: number) => [number, number];
     readonly brep_revolve_curve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
     readonly brep_sheet_from_surface: (a: number, b: number) => [number, number];
+    readonly brep_split_solid_by_sheet_op: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly brep_tessellate: (a: number, b: number, c: number) => [number, number];
+    readonly brep_tessellate_with_face_ranges: (a: number, b: number, c: number) => [number, number];
     readonly brep_transform: (a: number, b: number, c: number, d: number) => [number, number];
     readonly brep_validate: (a: number, b: number, c: number) => [number, number];
     readonly brep_volume_area: (a: number, b: number, c: number) => [number, number];
@@ -1060,6 +1180,7 @@ export interface InitOutput {
     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_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_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];
@@ -1083,6 +1204,7 @@ export interface InitOutput {
     readonly mesh_scale: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_solid_split_by_surface: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     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_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];

package/src/wasm-bindings.js

@@ -64,6 +64,24 @@ export function brep_boolean_op(a_json, b_json, op, tolerance) {
     }
 }
 
+/**
+ * Closest BREP face to a 3D point. Returns [faceIndex, u, v, distance,
+ * isNurbs] ((u, v) in the surface's KNOT domain) or empty on failure.
+ * @param {string} json
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {Float64Array}
+ */
+export function brep_closest_face(json, x, y, z) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_closest_face(ptr0, len0, x, y, z);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * All BREP edges as polylines: [num_polylines, n1, x,y,z..., n2, ...].
  * @param {string} json
@@ -79,6 +97,51 @@ export function brep_edges(json, tolerance) {
     return v2;
 }
 
+/**
+ * Extract one face as a standalone single-face TRIMMED sheet BREP (trim
+ * loops, pcurves, edges and vertices preserved). Returns JSON, empty on
+ * failure.
+ * @param {string} json
+ * @param {number} face_index
+ * @returns {string}
+ */
+export function brep_extract_face(json, face_index) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_extract_face(ptr0, len0, face_index);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * ALL faces as standalone single-face trimmed sheet BREPs, in one crossing
+ * (the source JSON is parsed once). Returns a JSON ARRAY aligned with face
+ * indices; faces that fail to extract are `null`.
+ * @param {string} json
+ * @returns {string}
+ */
+export function brep_extract_faces(json) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_extract_faces(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);
+    }
+}
+
 /**
  * Extrude a profile curve into a BREP (closed profile → capped solid,
  * open profile → sheet). Returns JSON.
@@ -104,6 +167,25 @@ export function brep_extrude_curve(curve_data, dx, dy, dz, height) {
     }
 }
 
+/**
+ * Exact (u, v) of a point on a specific BREP face (closest-point Newton for
+ * NURBS, frame projection for planes). Returns [u, v, distance, isNurbs].
+ * @param {string} json
+ * @param {number} face_index
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {Float64Array}
+ */
+export function brep_face_closest_uv(json, face_index, x, y, z) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_face_closest_uv(ptr0, len0, face_index, x, y, z);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Iso-parametric curve of a NURBS face's backing surface (untrimmed).
  * Returns curve data, or empty for planar faces.
@@ -122,6 +204,46 @@ export function brep_face_iso_curve(json, face_index, t, u_dir) {
     return v2;
 }
 
+/**
+ * Exact isocurve(s) of a BREP face at KNOT-domain parameter `t`, CLIPPED to
+ * the face's trimmed region. `u_dir = true` runs along u at fixed v = t.
+ * Line pieces (planar faces) are encoded as degree-1 NURBS.
+ * Packing: [curveCount, (bufLen, curveData…)·curveCount] where curveData is
+ * the standard NURBS curve encoding.
+ * @param {string} json
+ * @param {number} face_index
+ * @param {number} t
+ * @param {boolean} u_dir
+ * @returns {Float64Array}
+ */
+export function brep_face_iso_curves_trimmed(json, face_index, t, u_dir) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_face_iso_curves_trimmed(ptr0, len0, face_index, t, u_dir);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Like `brep_face_iso_curves_trimmed`, but `t` is NORMALIZED [0, 1] across
+ * the face's trim extent in the fixed direction — callers don't need the
+ * surface knot domain. Same packing.
+ * @param {string} json
+ * @param {number} face_index
+ * @param {number} t
+ * @param {boolean} u_dir
+ * @returns {Float64Array}
+ */
+export function brep_face_iso_curves_trimmed_normalized(json, face_index, t, u_dir) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_face_iso_curves_trimmed_normalized(ptr0, len0, face_index, t, u_dir);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Geometric backing of a face.
  * Returns [0, ox,oy,oz, ux,uy,uz, vx,vy,vz] for planes,
@@ -139,6 +261,39 @@ export function brep_face_surface(json, face_index) {
     return v2;
 }
 
+/**
+ * Underlying surface of a face CROPPED to its trim extent, ALWAYS as a NURBS
+ * surface (planar faces become exact degree-1 patches). Returns surface
+ * data, empty on failure.
+ * @param {string} json
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function brep_face_surface_cropped(json, face_index) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_face_surface_cropped(ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Batch variant of `brep_face_surface_cropped` for all faces in one
+ * crossing. Packing: [faceCount, (bufLen, surfaceData…)·faceCount], aligned
+ * with face indices — a face that fails to crop gets bufLen 0.
+ * @param {string} json
+ * @returns {Float64Array}
+ */
+export function brep_face_surfaces_cropped(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_face_surfaces_cropped(ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Tessellate a single BREP face. Returns the standard mesh buffer.
  * @param {string} json
@@ -155,6 +310,47 @@ export function brep_face_tessellate(json, face_index, tolerance) {
     return v2;
 }
 
+/**
+ * UV bounding box of a face's trim loops in surface parameter space:
+ * [u_min, u_max, v_min, v_max]. Empty on failure.
+ * @param {string} json
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function brep_face_trim_bounds(json, face_index) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_face_trim_bounds(ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Convert a closed manifold triangle mesh into a planar-face BREP.
+ * `normal_angle_tol_deg` ≤ 0 selects the default (≈0.057°); `max_faces` 0 =
+ * default guard (4096). Returns BREP JSON or {"error": ...}.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} normal_angle_tol_deg
+ * @param {number} max_faces
+ * @returns {string}
+ */
+export function brep_from_mesh_buffer(vertex_count, buffer, normal_angle_tol_deg, max_faces) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_from_mesh_buffer(vertex_count, ptr0, len0, normal_angle_tol_deg, max_faces);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * BREP structure summary: [face_count, edge_count, vertex_count, is_closed].
  * @param {string} json
@@ -266,6 +462,33 @@ export function brep_sheet_from_surface(surface_data) {
     }
 }
 
+/**
+ * Split a closed solid BREP by a sheet BREP into BOTH capped halves.
+ * Returns {"negative": <brep|null>, "positive": <brep|null>} or {"error":...}.
+ * Sides follow the sheet normal (negative = behind it), matching
+ * `mesh_solid_split_by_surface`.
+ * @param {string} solid_json
+ * @param {string} sheet_json
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function brep_split_solid_by_sheet_op(solid_json, sheet_json, tolerance) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(solid_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(sheet_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_split_solid_by_sheet_op(ptr0, len0, ptr1, len1, tolerance);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Tessellate a BREP into the standard mesh buffer
  * [vertexCount, positions..., indices...]. Crack-free across shared edges.
@@ -282,6 +505,26 @@ export function brep_tessellate(json, tolerance) {
     return v2;
 }
 
+/**
+ * Tessellate a BREP with per-face triangle ranges for face-level picking.
+ * `tolerance <= 0` selects the deterministic auto display tolerance (from the
+ * BREP's own extent), so triangle indices from a previously produced
+ * auto-tolerance display mesh stay valid across calls.
+ * Packing: [vertexCount, indexCount, rangeCount,
+ *           positions(3·vc), indices(ic), (face, firstTri, triCount)·rc].
+ * @param {string} json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function brep_tessellate_with_face_ranges(json, tolerance) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_tessellate_with_face_ranges(ptr0, len0, tolerance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Apply a row-major 4x4 matrix to a BREP. Returns transformed JSON.
  * @param {string} json
@@ -1930,6 +2173,30 @@ export function mesh_get_face_area(vertex_count, buffer, face_index) {
     return ret;
 }
 
+/**
+ * Boundary loops of the coplanar connected face group containing `face_index`.
+ *
+ * Boundary edges are the directed triangle edges whose reversed twin is not
+ * present within the group; chaining them preserves the group's winding.
+ * Consecutive collinear points (T-junction subdivisions) are collapsed so
+ * consumers receive clean polygon corners.
+ *
+ * Output format: [loopCount, (pointCount, x, y, z, ...) per loop].
+ * Loops are implicitly closed (last point connects back to the first).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_boundary_loops(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_face_boundary_loops(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 centroid as [x, y, z].
  * @param {number} vertex_count
@@ -2379,6 +2646,36 @@ export function mesh_solid_split_plane(vertex_count, buffer, nx, ny, nz, d, oper
     return v3;
 }
 
+/**
+ * One-shot production path: closed manifold triangle mesh ÷ NURBS surface →
+ * both halves as exact capped BREPs, in a single WASM crossing (mesh→BREP
+ * conversion, sheet construction and the parametric split all run kernel-side).
+ * Returns {"negative": <brep|null>, "positive": <brep|null>} or {"error":...}.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} surface_data
+ * @param {number} tolerance
+ * @param {number} normal_angle_tol_deg
+ * @param {number} max_faces
+ * @returns {string}
+ */
+export function mesh_split_by_surface_to_brep(vertex_count, buffer, surface_data, tolerance, normal_angle_tol_deg, max_faces) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(surface_data, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.mesh_split_by_surface_to_brep(vertex_count, ptr0, len0, ptr1, len1, tolerance, normal_angle_tol_deg, max_faces);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Trim an OPEN host surface by all closed cutter meshes in one WASM call.
  *