okgeometry-api 1.14.0 → 1.16.0

package/src/wasm-bindings.d.ts

@@ -20,12 +20,42 @@ 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, ...].
  */
@@ -123,12 +153,59 @@ export function brep_from_mesh_buffer(vertex_count: number, buffer: Float64Array
  */
 export function brep_info(json: string): Float64Array;
 
+/**
+ * [`brep_intersection_curves_op`] with the per-face-pair pieces JOINED into
+ * maximal curves: greedy reversal-aware endpoint chaining, exact degree
+ * elevation to the chain maximum, exact `join_arcs` knot concatenation
+ * (junction multiplicity = degree, no re-parameterization), and a per-curve
+ * verification gate (dense samples within 5·tolerance of BOTH operands'
+ * surfaces — a chain failing the gate comes back unjoined, never corrupted).
+ * A closed intersection loop (e.g. plane through a cylinder) comes back as
+ * ONE closed curve.
+ *
+ * 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_joined_op(a_json: string, b_json: string, tolerance: number): 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]
@@ -515,6 +592,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.
  */
@@ -734,6 +827,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,...]
@@ -789,6 +898,20 @@ export function mesh_solid_split_plane(vertex_count: number, buffer: Float64Arra
  */
 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.
  *
@@ -835,6 +958,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.
@@ -842,6 +979,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].
@@ -937,6 +1111,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...].
@@ -1078,7 +1270,9 @@ 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];
@@ -1094,7 +1288,10 @@ export interface InitOutput {
     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_joined_op: (a: number, b: number, c: number, d: number, e: 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];
@@ -1159,6 +1356,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];
@@ -1196,6 +1394,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];
@@ -1205,6 +1404,7 @@ export interface InitOutput {
     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];
@@ -1212,7 +1412,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];
@@ -1229,6 +1432,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];