okgeometry-api 1.11.1 → 1.15.0

package/dist/wasm-bindings.js

@@ -61,6 +61,75 @@ export function brep_boolean_op(a_json, b_json, op, tolerance) {
         wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
 }
+/**
+ * Boolean-intersection clip of an exact NURBS curve against a CLOSED solid
+ * BREP: the curve is split exactly (knot insertion) at every boundary
+ * crossing and each piece is classified by containment. Every returned
+ * piece lies exactly on the input curve; closed curves merge the run
+ * spanning the parameter seam (same convention as `mesh_clip_polyline`).
+ *
+ * Packing: `[insideCount, (bufLen, curveData…)·insideCount,
+ * outsideCount, (bufLen, curveData…)·outsideCount]` — two concatenated
+ * multi-curve packings, inside pieces first. Returns an empty buffer on
+ * failure (malformed input, or a BREP that is not a closed solid).
+ * @param {Float64Array} curve_data
+ * @param {string} brep_json
+ * @returns {Float64Array}
+ */
+export function brep_clip_curve_op(curve_data, brep_json) {
+    const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_clip_curve_op(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+/**
+ * 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;
+}
+/**
+ * Find all points where a NURBS curve pierces a BREP's faces: per face, the
+ * curve is intersected with the EXACT surface and kept only when the hit
+ * lies INSIDE the face's trimmed region; crossings on shared edges are
+ * deduplicated (smallest face index kept).
+ *
+ * `curve_data` is the standard NURBS curve encoding. Hits are sorted by
+ * curve parameter (normalized [0, 1]); (u, v) are in the face's OWN
+ * parameter space (knot domain for NURBS faces, plane-frame coordinates for
+ * planar faces).
+ *
+ * Packing: `[count, (x, y, z, curveParam, faceIndex, u, v)·count]`.
+ * Returns an empty buffer on malformed input.
+ * @param {string} brep_json
+ * @param {Float64Array} curve_data
+ * @returns {Float64Array}
+ */
+export function brep_curve_intersection_op(brep_json, curve_data) {
+    const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_curve_intersection_op(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
 /**
  * All BREP edges as polylines: [num_polylines, n1, x,y,z..., n2, ...].
  * @param {string} json
@@ -75,6 +144,51 @@ export function brep_edges(json, tolerance) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     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.
@@ -100,6 +214,24 @@ export function brep_extrude_curve(curve_data, dx, dy, dz, height) {
         wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
+/**
+ * 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.
@@ -117,6 +249,44 @@ export function brep_face_iso_curve(json, face_index, t, u_dir) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     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,
@@ -133,6 +303,37 @@ export function brep_face_surface(json, face_index) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     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
@@ -148,6 +349,46 @@ export function brep_face_tessellate(json, face_index, tolerance) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     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
@@ -161,6 +402,35 @@ export function brep_info(json) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v2;
 }
+/**
+ * TRIM-EXACT intersection curves between two BREPs (solids OR sheets): the
+ * parametric boolean's SSI → clip → convergence stages run and the fitted 3D
+ * intersection edges come back WITHOUT classification/assembly.
+ *
+ * A closed intersection loop may come back as several contiguous pieces
+ * (split at surface seams and face-boundary crossings); the pieces chain
+ * end-to-end exactly. Coincident (overlapping) face pairs contribute no
+ * curves.
+ *
+ * Packing: `[curveCount, (bufLen, curveData…)·curveCount]` (standard NURBS
+ * curve encoding). Returns an EMPTY buffer on failure (invalid BREP JSON or
+ * a pipeline error) — distinguishable from `[0]`, which means the operands
+ * genuinely do not intersect.
+ * @param {string} a_json
+ * @param {string} b_json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function brep_intersection_curves_op(a_json, b_json, tolerance) {
+    const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_intersection_curves_op(ptr0, len0, ptr1, len1, tolerance);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
 /**
  * Loft through profile curves into a BREP.
  * Input: [num_curves, curve1_data..., curve2_data...]. Returns JSON.
@@ -182,6 +452,32 @@ export function brep_loft_curves(data) {
         wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
+/**
+ * Intersection curves between a BREP and a triangle mesh.
+ *
+ * TESSELLATION-BASED (documented approximation): the BREP is tessellated at
+ * `tolerance` (pass `<= 0` for the deterministic auto display tolerance)
+ * and intersected with the mesh via BVH-pruned tri-tri crossing + chaining.
+ *
+ * Mesh input is the standard `[vertexCount, positions..., indices...]`
+ * buffer. Returns the standard polyline group packing
+ * `[num_polylines, n1, x,y,z,..., n2, x,y,z,...]`; empty on failure.
+ * @param {string} brep_json
+ * @param {number} vertex_count
+ * @param {Float64Array} mesh_buffer
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function brep_mesh_intersection_curves_op(brep_json, vertex_count, mesh_buffer, tolerance) {
+    const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(mesh_buffer, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_mesh_intersection_curves_op(ptr0, len0, vertex_count, ptr1, len1, tolerance);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
 /**
  * BREP primitives.
  * kind: "box"      [minx,miny,minz, maxx,maxy,maxz]
@@ -258,6 +554,33 @@ export function brep_sheet_from_surface(surface_data) {
         wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
+/**
+ * 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.
@@ -273,6 +596,25 @@ export function brep_tessellate(json, tolerance) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     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
@@ -1517,6 +1859,35 @@ export function mesh_clip_polyline(vertex_count, buffer, points, closed) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v3;
 }
+/**
+ * Clip a polyline by an OPEN oriented sheet: split it at every sheet
+ * crossing and classify each piece by the SIGNED SIDE of the sheet. This is
+ * side classification, NOT containment (unlike `mesh_clip_polyline`, which
+ * requires a closed volume): pieces far from the sheet still classify by
+ * the nearest facet's normal. `inside` = the positive side, in FRONT of the
+ * sheet normal; `outside` = behind it. The sheet may be any non-empty
+ * triangle mesh, open or closed; its stored winding defines the normals.
+ *
+ * Returns two concatenated polyline buffers — inside pieces first, then
+ * outside pieces — each encoded as `[num_polylines, n1, x,y,z,..., ...]`
+ * (identical packing to `mesh_clip_polyline`). Returns an empty buffer on
+ * failure (degenerate polyline/sheet).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_clip_polyline_by_sheet(vertex_count, buffer, points, closed) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_clip_polyline_by_sheet(vertex_count, ptr0, len0, ptr1, len1, closed);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
 /**
  * Compute planar curve normal from ordered points.
  * @param {Float64Array} coords
@@ -1864,6 +2235,29 @@ export function mesh_get_face_area(vertex_count, buffer, face_index) {
     const ret = wasm.mesh_get_face_area(vertex_count, ptr0, len0, 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
@@ -2127,6 +2521,35 @@ export function mesh_plane_intersect(vertex_count, buffer, nx, ny, nz, d) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v2;
 }
+/**
+ * Compute all transversal crossing points of a polyline with a triangle
+ * mesh. Works on OPEN meshes (sheets) — the mesh is NOT required to be a
+ * closed volume, unlike `mesh_clip_polyline`.
+ *
+ * `points` is a flat [x,y,z, ...] vertex list; `closed` marks a closed loop
+ * (segment `i` runs `points[i] → points[(i+1) % n]`; open polylines have
+ * n−1 segments, closed ones n).
+ *
+ * Packing: `[count, (x, y, z, segmentIndex, segmentT, triangleIndex)·count]`,
+ * sorted by (segmentIndex, segmentT). Shared-edge/vertex crossings dedupe to
+ * one hit (smallest triangle index kept); coplanar sliding overlaps yield no
+ * hits. Returns an empty buffer on failure (degenerate polyline/mesh).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_polyline_intersection_points(vertex_count, buffer, points, closed) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_polyline_intersection_points(vertex_count, ptr0, len0, ptr1, len1, closed);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
 /**
  * Shift closed boolean cutter curve and adjust height.
  * Returns [height, epsilon, pointCount, x,y,z,...]
@@ -2293,6 +2716,63 @@ export function mesh_solid_split_plane(vertex_count, buffer, nx, ny, nz, d, oper
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     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);
+    }
+}
+/**
+ * Intersect a polyline with a triangle mesh (open sheets allowed) and split
+ * it into pieces at every crossing. Hit points become the shared endpoints
+ * of adjacent pieces; a closed loop is opened at the first hit (N hits → N
+ * pieces), an open polyline yields N + 1 pieces. With no crossings the
+ * original polyline comes back as one piece.
+ *
+ * Packing: a single flat polyline-group buffer
+ * `[num_polylines, n1, x,y,z,..., n2, x,y,z,...]` (same group encoding as
+ * `mesh_clip_polyline`, but ONE list — pieces are not classified). Returns
+ * an empty buffer on failure.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_split_polyline(vertex_count, buffer, points, closed) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_split_polyline(vertex_count, ptr0, len0, ptr1, len1, closed);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
 /**
  * Trim an OPEN host surface by all closed cutter meshes in one WASM call.
  *
@@ -2427,6 +2907,31 @@ export function nurbs_curve_curve_intersect(data_a, data_b) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v3;
 }
+/**
+ * Find all intersections between two NURBS curves, with exact parameters.
+ *
+ * Inputs are standard NURBS curve encodings
+ * `[degree, num_cp, cp_xyz..., weights..., knots...]` (the same format
+ * consumed by `sample_nurbs_curve` / produced by `build_nurbs_curve`).
+ *
+ * Packing: `[count, (x, y, z, paramA, paramB)·count]`. Parameters are
+ * normalized to [0, 1]; results are sorted by `paramA`. Coincident
+ * (overlapping) curve runs yield NO points (identical curves return
+ * `[0]`). Returns an empty buffer on malformed input.
+ * @param {Float64Array} curve_a_data
+ * @param {Float64Array} curve_b_data
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_curve_intersect_params(curve_a_data, curve_b_data) {
+    const ptr0 = passArrayF64ToWasm0(curve_a_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(curve_b_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_curve_curve_intersect_params(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
 /**
  * Intersect a NURBS curve with a plane.
  * Input: same curve format as sample_nurbs_curve + plane normal (nx,ny,nz) and d.
@@ -2446,6 +2951,66 @@ export function nurbs_curve_plane_intersect(data, nx, ny, nz, d) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v2;
 }
+/**
+ * Split a NURBS curve at multiple normalized parameters t ∈ [0, 1].
+ *
+ * Splitting is exact (knot insertion), so every returned piece lies exactly
+ * on the input curve. Parameters are sorted/deduplicated/clamped internally;
+ * closed curves are opened at the FIRST parameter (N interior parameters →
+ * N pieces), open curves yield N + 1 pieces. With no valid parameters the
+ * (clamped) curve comes back as the single piece.
+ *
+ * `closed_hint` is an explicit topology override: `> 0` forces closed
+ * (seam-rejoin) semantics, `0` forces open semantics (an open curve whose
+ * endpoints merely coincide keeps N + 1 pieces), `< 0` infers closedness
+ * geometrically from the endpoint distance (the historical behavior).
+ *
+ * Packing: `[curveCount, (bufLen, curveData…)·curveCount]` where curveData
+ * is the standard NURBS curve encoding (same multi-curve packing as
+ * `brep_face_iso_curves_trimmed`). Returns an empty buffer on malformed
+ * input.
+ * @param {Float64Array} curve_data
+ * @param {Float64Array} params
+ * @param {number} closed_hint
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_split_at_params(curve_data, params, closed_hint) {
+    const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_curve_split_at_params(ptr0, len0, ptr1, len1, closed_hint);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+/**
+ * Find all isolated intersections of a NURBS curve with a NURBS surface,
+ * with exact parameters.
+ *
+ * `curve_data` is the standard NURBS curve encoding; `surface_data` is the
+ * standard NURBS surface encoding `[degree_u, degree_v, num_u, num_v,
+ * cp(flat)..., weights..., knots_u..., knots_v...]` (same as
+ * `nurbs_surface_evaluate`).
+ *
+ * Packing: `[count, (x, y, z, t, u, v)·count]`. All parameters are
+ * normalized to [0, 1]; results are sorted by `t`. Curve segments lying ON
+ * the surface (coincident runs) yield no points. Returns an empty buffer on
+ * malformed input.
+ * @param {Float64Array} curve_data
+ * @param {Float64Array} surface_data
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_surface_intersect_exact(curve_data, surface_data) {
+    const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(surface_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_curve_surface_intersect_exact(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
 /**
  * Closest point on the surface to (x, y, z).
  * Returns [u, v, px, py, pz] with u, v normalized to [0,1].
@@ -2718,6 +3283,36 @@ export function nurbs_surface_surface_intersect(data_a, data_b, tess) {
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v3;
 }
+/**
+ * EXACT intersection curves of two FULL (untrimmed) NURBS surfaces: the
+ * parametric boolean's SSI pipeline (seeded tri-tri, chaining, tangent-plane
+ * relaxation) fitted to tolerance-verified interpolating NURBS curves —
+ * unlike `nurbs_surface_surface_intersect`, which returns tessellated
+ * polylines.
+ *
+ * Inputs are standard NURBS surface encodings; `tolerance` is absolute
+ * (floored relative to the combined model scale kernel-side). Closed loops
+ * come back as ONE closed curve; coincident (overlapping) surfaces yield no
+ * curves (their overlap is a 2D region).
+ *
+ * Packing: `[curveCount, (bufLen, curveData…)·curveCount]` where curveData
+ * is the standard NURBS curve encoding. Returns an empty buffer on
+ * malformed input.
+ * @param {Float64Array} surf_a_data
+ * @param {Float64Array} surf_b_data
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_surface_intersect_curves(surf_a_data, surf_b_data, tolerance) {
+    const ptr0 = passArrayF64ToWasm0(surf_a_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(surf_b_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_surface_intersect_curves(ptr0, len0, ptr1, len1, tolerance);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
 /**
  * Curvature-adaptive tessellation against a chordal tolerance.
  * Returns the standard mesh buffer [vertexCount, positions..., indices...].