okgeometry-api 1.11.1 → 1.15.0

package/src/wasm-bindings.d.ts

@@ -20,23 +20,95 @@ 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;
 
+/**
+ * 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).
+ */
+export function brep_clip_curve_op(curve_data: Float64Array, brep_json: string): Float64Array;
+
+/**
+ * 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;
+
+/**
+ * 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.
+ */
+export function brep_curve_intersection_op(brep_json: string, curve_data: Float64Array): 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,22 +116,79 @@ 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].
  */
 export function brep_info(json: string): Float64Array;
 
+/**
+ * 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.
+ */
+export function brep_intersection_curves_op(a_json: string, b_json: string, tolerance: number): Float64Array;
+
 /**
  * Loft through profile curves into a BREP.
  * Input: [num_curves, curve1_data..., curve2_data...]. Returns JSON.
  */
 export function brep_loft_curves(data: Float64Array): string;
 
+/**
+ * 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.
+ */
+export function brep_mesh_intersection_curves_op(brep_json: string, vertex_count: number, mesh_buffer: Float64Array, tolerance: number): Float64Array;
+
 /**
  * BREP primitives.
  * kind: "box"      [minx,miny,minz, maxx,maxy,maxz]
@@ -81,12 +210,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.
  */
@@ -428,6 +575,22 @@ export function mesh_chamfer_all_edges(mesh_type: string, params: Float64Array,
  */
 export function mesh_clip_polyline(vertex_count: number, buffer: Float64Array, points: Float64Array, closed: boolean): Float64Array;
 
+/**
+ * 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).
+ */
+export function mesh_clip_polyline_by_sheet(vertex_count: number, buffer: Float64Array, points: Float64Array, closed: boolean): Float64Array;
+
 /**
  * Compute planar curve normal from ordered points.
  */
@@ -544,6 +707,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].
  */
@@ -634,6 +810,22 @@ export function mesh_planar_face_evaluate(vertex_count: number, buffer: Float64A
  */
 export function mesh_plane_intersect(vertex_count: number, buffer: Float64Array, nx: number, ny: number, nz: number, d: number): Float64Array;
 
+/**
+ * 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).
+ */
+export function mesh_polyline_intersection_points(vertex_count: number, buffer: Float64Array, points: Float64Array, closed: boolean): Float64Array;
+
 /**
  * Shift closed boolean cutter curve and adjust height.
  * Returns [height, epsilon, pointCount, x,y,z,...]
@@ -681,6 +873,28 @@ 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;
+
+/**
+ * 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.
+ */
+export function mesh_split_polyline(vertex_count: number, buffer: Float64Array, points: Float64Array, closed: boolean): Float64Array;
+
 /**
  * Trim an OPEN host surface by all closed cutter meshes in one WASM call.
  *
@@ -727,6 +941,20 @@ export function mesh_translate(vertex_count: number, buffer: Float64Array, dx: n
  */
 export function nurbs_curve_curve_intersect(data_a: Float64Array, data_b: Float64Array): Float64Array;
 
+/**
+ * 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.
+ */
+export function nurbs_curve_curve_intersect_params(curve_a_data: Float64Array, curve_b_data: Float64Array): Float64Array;
+
 /**
  * Intersect a NURBS curve with a plane.
  * Input: same curve format as sample_nurbs_curve + plane normal (nx,ny,nz) and d.
@@ -734,6 +962,43 @@ export function nurbs_curve_curve_intersect(data_a: Float64Array, data_b: Float6
  */
 export function nurbs_curve_plane_intersect(data: Float64Array, nx: number, ny: number, nz: number, d: number): Float64Array;
 
+/**
+ * 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.
+ */
+export function nurbs_curve_split_at_params(curve_data: Float64Array, params: Float64Array, closed_hint: number): Float64Array;
+
+/**
+ * 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.
+ */
+export function nurbs_curve_surface_intersect_exact(curve_data: Float64Array, surface_data: Float64Array): Float64Array;
+
 /**
  * Closest point on the surface to (x, y, z).
  * Returns [u, v, px, py, pz] with u, v normalized to [0,1].
@@ -829,6 +1094,24 @@ export function nurbs_surface_split(data: Float64Array, u_dir: boolean, t: numbe
  */
 export function nurbs_surface_surface_intersect(data_a: Float64Array, data_b: Float64Array, tess: number): Float64Array;
 
+/**
+ * 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.
+ */
+export function nurbs_surface_surface_intersect_curves(surf_a_data: Float64Array, surf_b_data: Float64Array, tolerance: number): Float64Array;
+
 /**
  * Curvature-adaptive tessellation against a chordal tolerance.
  * Returns the standard mesh buffer [vertexCount, positions..., indices...].
@@ -970,17 +1253,33 @@ 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_clip_curve_op: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly brep_closest_face: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly brep_curve_intersection_op: (a: number, b: number, c: number, d: 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_intersection_curves_op: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly brep_loft_curves: (a: number, b: number) => [number, number];
+    readonly brep_mesh_intersection_curves_op: (a: number, b: number, c: number, d: number, e: number, f: 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];
@@ -1039,6 +1338,7 @@ export interface InitOutput {
     readonly mesh_build_render_buffers: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_chamfer_all_edges: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_clip_polyline: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly mesh_clip_polyline_by_sheet: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_compute_planar_curve_normal: (a: number, b: number, c: number) => [number, number];
     readonly mesh_contains_point: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly mesh_create_box: (a: number, b: number, c: number) => [number, number];
@@ -1060,6 +1360,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];
@@ -1075,6 +1376,7 @@ export interface InitOutput {
     readonly mesh_patch_from_points: (a: number, b: number) => [number, number];
     readonly mesh_planar_face_evaluate: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_plane_intersect: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly mesh_polyline_intersection_points: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_prepare_boolean_cutter_curve: (a: number, b: number, c: number, d: number, e: number, f: number, g: 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];
@@ -1083,6 +1385,8 @@ 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_split_polyline: (a: number, b: number, c: number, d: number, e: number, f: 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];
@@ -1090,7 +1394,10 @@ export interface InitOutput {
     readonly mesh_topology_metrics_raw: (a: number, b: number, c: number) => [number, number];
     readonly mesh_translate: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly nurbs_curve_curve_intersect: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly nurbs_curve_curve_intersect_params: (a: number, b: number, c: number, d: number) => [number, number];
     readonly nurbs_curve_plane_intersect: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly nurbs_curve_split_at_params: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly nurbs_curve_surface_intersect_exact: (a: number, b: number, c: number, d: number) => [number, number];
     readonly nurbs_surface_closest_point: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly nurbs_surface_curvature: (a: number, b: number, c: number, d: number) => [number, number];
     readonly nurbs_surface_derivatives: (a: number, b: number, c: number, d: number) => [number, number];
@@ -1107,6 +1414,7 @@ export interface InitOutput {
     readonly nurbs_surface_ruled: (a: number, b: number, c: number, d: number) => [number, number];
     readonly nurbs_surface_split: (a: number, b: number, c: number, d: number) => [number, number];
     readonly nurbs_surface_surface_intersect: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly nurbs_surface_surface_intersect_curves: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly nurbs_surface_tessellate_adaptive: (a: number, b: number, c: number, d: number) => [number, number];
     readonly nurbs_surface_tessellate_render: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly offset_polycurve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];