okgeometry-api 1.26.1 → 1.27.0

package/dist/wasm-bindings-threaded.d.ts

@@ -0,0 +1,2664 @@
+/**
+ * Get the length of an arc.
+ * @param {number} radius
+ * @param {number} start_angle
+ * @param {number} end_angle
+ * @returns {number}
+ */
+export function arc_length(radius: number, start_angle: number, end_angle: number): number;
+/**
+ * Evaluate a point on an arc at parameter t ∈ [0,1].
+ * Returns [x, y, z].
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} start_angle
+ * @param {number} end_angle
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function arc_point_at(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, radius: number, start_angle: number, end_angle: number, t: number): Float64Array;
+/**
+ * Parametric BREP boolean: exact surface–surface intersection curves with
+ * trimmed-surface output. Operands may be closed solids OR open sheets —
+ * the kernel dispatches on closedness (oriented-sheet convention: a sheet's
+ * "inside" is the FRONT of its normal):
+ * - closed × closed: full volumetric boolean.
+ * - sheet × solid: subtract keeps the sheet outside the solid, intersect
+ *   keeps the inside.
+ * - solid × sheet: subtract keeps the capped half BEHIND the sheet normal,
+ *   intersect the front half.
+ * - sheet × sheet: a sheet's material is its FRONT half-space, so union
+ *   stitches A-BACK + B-BACK at the intersection edges (front pieces are
+ *   interior to the union material; uncut pieces are kept, coincident
+ *   overlaps keep A's copy); subtract keeps A's back pieces; intersect
+ *   A's front pieces.
+ * - union of a solid and a sheet is not defined and returns an error.
+ * op: "union" | "intersect" | "subtract".
+ * Returns the result BREP as JSON, or {"error": "..."} on failure.
+ * @param {string} a_json
+ * @param {string} b_json
+ * @param {string} op
+ * @param {number} tolerance
+ * @returns {string}
+ */
+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).
+ * @param {Float64Array} curve_data
+ * @param {string} brep_json
+ * @returns {Float64Array}
+ */
+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.
+ * @param {string} json
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {Float64Array}
+ */
+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.
+ * @param {string} brep_json
+ * @param {Float64Array} curve_data
+ * @returns {Float64Array}
+ */
+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, ...].
+ * @param {string} json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+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.
+ * @param {string} json
+ * @param {number} face_index
+ * @returns {string}
+ */
+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`.
+ * @param {string} json
+ * @returns {string}
+ */
+export function brep_extract_faces(json: string): string;
+/**
+ * Extrude a profile curve into a BREP (closed profile → capped solid,
+ * open profile → sheet). Returns JSON.
+ * @param {Float64Array} curve_data
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} height
+ * @returns {string}
+ */
+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].
+ * @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: 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.
+ * @param {string} json
+ * @param {number} face_index
+ * @param {number} t
+ * @param {boolean} u_dir
+ * @returns {Float64Array}
+ */
+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.
+ * @param {string} json
+ * @param {number} face_index
+ * @param {number} t
+ * @param {boolean} u_dir
+ * @returns {Float64Array}
+ */
+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.
+ * @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: 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,
+ * or [1, surface_data...] for NURBS faces.
+ * @param {string} json
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+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.
+ * @param {string} json
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+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.
+ * @param {string} json
+ * @returns {Float64Array}
+ */
+export function brep_face_surfaces_cropped(json: string): Float64Array;
+/**
+ * Tessellate a single BREP face. Returns the standard mesh buffer.
+ * @param {string} json
+ * @param {number} face_index
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+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.
+ * @param {string} json
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+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": ...}.
+ * @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: number, buffer: Float64Array, normal_angle_tol_deg: number, max_faces: number): string;
+/**
+ * BREP structure summary: [face_count, edge_count, vertex_count, is_closed].
+ * @param {string} json
+ * @returns {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.
+ * @param {string} a_json
+ * @param {string} b_json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+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.
+ * @param {string} a_json
+ * @param {string} b_json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+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.
+ * @param {Float64Array} data
+ * @returns {string}
+ */
+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.
+ * @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: string, vertex_count: number, mesh_buffer: Float64Array, tolerance: number): Float64Array;
+/**
+ * BREP primitives.
+ * kind: "box"      [minx,miny,minz, maxx,maxy,maxz]
+ *       "cylinder" [bx,by,bz, ax,ay,az, radius, height]
+ *       "sphere"   [cx,cy,cz, radius]
+ *       "cone"     [bx,by,bz, ax,ay,az, radius0, radius1, height]
+ *       "torus"    [cx,cy,cz, major, minor]
+ * Returns the BREP as JSON ("" on failure).
+ * @param {string} kind
+ * @param {Float64Array} params
+ * @returns {string}
+ */
+export function brep_primitive(kind: string, params: Float64Array): string;
+/**
+ * Rebuild every NURBS face surface of a BREP with the given degrees and
+ * control counts, preserving each face's parameter domain so trims and
+ * edges stay coherent. Each face replacement is gated by `tolerance`
+ * (non-positive = accept all fits); planar faces pass through untouched.
+ * Returns JSON `{"maxDeviation": .., "rebuiltFaces": .., "skippedFaces": ..,
+ * "planarFaces": .., "brep": {...}}` or `{"error": "..."}`.
+ * @param {string} json
+ * @param {number} degree_u
+ * @param {number} degree_v
+ * @param {number} count_u
+ * @param {number} count_v
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function brep_rebuild_surfaces(json: string, degree_u: number, degree_v: number, count_u: number, count_v: number, tolerance: number): string;
+/**
+ * Revolve a profile curve into a BREP. Returns JSON.
+ * @param {Float64Array} curve_data
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} angle
+ * @returns {string}
+ */
+export function brep_revolve_curve(curve_data: Float64Array, ox: number, oy: number, oz: number, ax: number, ay: number, az: number, angle: number): string;
+/**
+ * Untrimmed sheet BREP from a NURBS surface. Returns JSON.
+ * @param {Float64Array} surface_data
+ * @returns {string}
+ */
+export function brep_sheet_from_surface(surface_data: Float64Array): string;
+/**
+ * Split an OPEN sheet BREP `a` by another OPEN sheet BREP `b`.
+ * Returns {"inside": <brep|null>, "outside": <brep|null>} or {"error":...}:
+ * `inside` = a's pieces in FRONT of b's oriented normal, `outside` = the
+ * pieces behind it (matching the oriented-sheet convention of
+ * `mesh_clip_polyline` and the sheet boolean dispatch).
+ * @param {string} a_json
+ * @param {string} b_json
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function brep_split_sheet_by_sheet_op(a_json: string, b_json: string, tolerance: number): string;
+/**
+ * Split an OPEN sheet BREP by a CLOSED solid BREP into containment sides.
+ * Returns {"inside": <brep|null>, "outside": <brep|null>} or {"error":...}:
+ * `inside` = the sheet pieces contained in the solid (ON-boundary pieces
+ * count as inside), `outside` = the rest. Both preserve the sheet's exact
+ * trimmed faces, pcurves and edges.
+ * @param {string} sheet_json
+ * @param {string} solid_json
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function brep_split_sheet_by_solid_op(sheet_json: string, solid_json: string, tolerance: number): 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`.
+ * @param {string} solid_json
+ * @param {string} sheet_json
+ * @param {number} tolerance
+ * @returns {string}
+ */
+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.
+ * @param {string} json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+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].
+ * @param {string} json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function brep_tessellate_with_face_ranges(json: string, tolerance: number): Float64Array;
+/**
+ * Apply a row-major 4x4 matrix to a BREP. Returns transformed JSON.
+ * @param {string} json
+ * @param {Float64Array} matrix
+ * @returns {string}
+ */
+export function brep_transform(json: string, matrix: Float64Array): string;
+/**
+ * Validate a BREP. Returns a JSON report:
+ * {"isClosed":bool,"boundaryEdgeCount":n,"maxCoherenceError":e,"issues":[...]}
+ * @param {string} json
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function brep_validate(json: string, tolerance: number): string;
+/**
+ * Volume and surface area from tessellation: [volume, area].
+ * @param {string} json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function brep_volume_area(json: string, tolerance: number): Float64Array;
+/**
+ * Wireframe of the whole BREP in ONE crossing: per face, `u_count` +
+ * `v_count` iso-parametric curves at evenly spaced INTERIOR normalized
+ * parameters, clipped to each face's trimmed region. The body JSON is
+ * parsed ONCE for the entire sweep. Same packing as
+ * `brep_face_iso_curves_trimmed_normalized`; faces that fail to evaluate
+ * are skipped atomically.
+ * @param {string} json
+ * @param {number} u_count
+ * @param {number} v_count
+ * @returns {Float64Array}
+ */
+export function brep_wireframe_curves(json: string, u_count: number, v_count: number): Float64Array;
+/**
+ * Build a NURBS curve from raw control points with kernel-managed knots and weights.
+ *
+ * * `degree` - Requested degree (clamped to the valid range for the point count)
+ * * `coords` - Flat control points [x,y,z, x,y,z, ...]. For closed curves the
+ *   first point must NOT be repeated at the end.
+ * * `closed` - When true, builds a periodic (C^{degree-1}) closed loop;
+ *   otherwise a clamped curve interpolating the first/last control points.
+ *
+ * Returns the encoded curve [degree, num_cp, cp_xyz..., weights..., knots...]
+ * (the same format consumed by `sample_nurbs_curve` / `evaluate_nurbs_curve_at`),
+ * or an empty buffer on failure.
+ * @param {number} degree
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function build_nurbs_curve(degree: number, coords: Float64Array, closed: boolean): Float64Array;
+/**
+ * Chamfer corners of a polyline by cutting each corner with a straight segment.
+ * Input: flat coords [x1,y1,z1, ...], distance from corner to cut.
+ * Output: encoded polycurve segments [segment_count, type, ...data, ...]
+ *   type 0 = Line: [sx,sy,sz, ex,ey,ez]
+ * @param {Float64Array} coords
+ * @param {number} distance
+ * @returns {Float64Array}
+ */
+export function chamfer_polycurve(coords: Float64Array, distance: number): Float64Array;
+/**
+ * Chamfer polyline corners with closed support and optional corner
+ * selection. `coords` is a flat point list (closed inputs without the
+ * duplicate seam point); `corner_indices` empty = all eligible corners.
+ * Returns the flat chamfered point list (closed outputs again without the
+ * seam duplicate), or empty on failure (see `geometry_last_error`).
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @param {number} distance
+ * @param {Float64Array} corner_indices
+ * @returns {Float64Array}
+ */
+export function chamfer_polyline_corners(coords: Float64Array, closed: boolean, distance: number, corner_indices: Float64Array): Float64Array;
+/**
+ * Get the circumference of a circle.
+ * @param {number} radius
+ * @returns {number}
+ */
+export function circle_length(radius: number): number;
+/**
+ * Evaluate a point on a circle at parameter t ∈ [0,1].
+ * Returns [x, y, z].
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function circle_point_at(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, radius: number, t: number): Float64Array;
+/**
+ * Create an arc and return sampled points
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} start_angle
+ * @param {number} end_angle
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function create_arc(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, radius: number, start_angle: number, end_angle: number, samples: number): Float64Array;
+/**
+ * Create a circle and return sampled points
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function create_circle(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, radius: number, samples: number): Float64Array;
+/**
+ * Create a line segment and return sampled points
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function create_line(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, samples: number): Float64Array;
+/**
+ * Create a polyline and return the points
+ * @param {Float64Array} coords
+ * @param {number} samples_per_segment
+ * @returns {Float64Array}
+ */
+export function create_polyline(coords: Float64Array, samples_per_segment: number): Float64Array;
+/**
+ * 2D REGION boolean between two CLOSED, COPLANAR curves (Rhino CurveBoolean).
+ *
+ * Both inputs are standard NURBS curve encodings (the TS layer coerces
+ * circles/arcs/polylines/polycurves to exact NURBS first). The curves are
+ * projected onto a common plane (fitted from A, coplanarity verified),
+ * tessellated to polygons, arranged in 2D, classified by inside-A/inside-B
+ * (nonzero winding), and the result loops emitted per op. CLOSURE is
+ * verified kernel-side: each curve's endpoints must coincide within a
+ * scale-relative tolerance, open curves error out (never silently
+ * chord-closed).
+ *
+ * `op`: 0 = union, 1 = subtract (A − B), 2 = intersect.
+ *
+ * Result loops are POLYLINE (degree-1 NURBS) closed curves — Rhino-parity
+ * fidelity. Tessellation samples include every distinct interior knot value,
+ * so degree-1 polygon corners and C0 kinks are preserved EXACTLY, and
+ * consecutive collinear points are collapsed so straight runs come back as
+ * single segments. Outer boundaries are CCW (positive plane-signed area),
+ * holes CW. CCW is measured about a DETERMINISTIC plane normal: the normal
+ * fitted from curve A, flipped so its dominant world-axis component is
+ * positive (for XY-plane curves the reference is +Z). The orientation is
+ * therefore independent of the inputs' drawing direction. Callers
+ * reconstruct nesting from the winding sign.
+ *
+ * Packing: `[curveCount, (bufLen, curveData…)·curveCount]` (same multi-curve
+ * packing as `nurbs_curve_split_at_params`). An EMPTY buffer signals an error
+ * (non-coplanar / open input / malformed input); a valid but EMPTY result
+ * (e.g. disjoint intersect) is the non-empty `[0]` packing.
+ * @param {Float64Array} a_data
+ * @param {Float64Array} b_data
+ * @param {number} op
+ * @returns {Float64Array}
+ */
+export function curve_region_boolean(a_data: Float64Array, b_data: Float64Array, op: number): Float64Array;
+/**
+ * SPLIT two CLOSED, COPLANAR curves into ALL region boundaries (Rhino
+ * "region split"): the arrangement of A and B partitions the plane into the
+ * pieces inside-A-only, inside-B-only and inside-both; each bounded region's
+ * outer and hole loops are returned as their own closed curves.
+ *
+ * Inputs, plane/coplanarity handling, fidelity and orientation follow
+ * `curve_region_boolean`. Same multi-curve packing; empty buffer on error.
+ * @param {Float64Array} a_data
+ * @param {Float64Array} b_data
+ * @returns {Float64Array}
+ */
+export function curve_region_split(a_data: Float64Array, b_data: Float64Array): Float64Array;
+/**
+ * Serialize a curve to a list of points for Three.js rendering
+ * Returns a flat array of coordinates: [x1, y1, z1, x2, y2, z2, ...]
+ * @param {string} curve_type
+ * @param {Float64Array} params
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function curve_to_points(curve_type: string, params: Float64Array, samples: number): Float64Array;
+/**
+ * Evaluate a NURBS curve at normalized parameter t in [0,1].
+ * Returns [x, y, z].
+ * @param {Float64Array} data
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function evaluate_nurbs_curve_at(data: Float64Array, t: number): Float64Array;
+/**
+ * Extrude a circle and return mesh buffers
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} radius
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} segments
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function extrude_circle(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, radius: number, dx: number, dy: number, dz: number, segments: number, with_caps: boolean): Float64Array;
+/**
+ * Extrude a line segment and return mesh buffers
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} segments
+ * @returns {Float64Array}
+ */
+export function extrude_line(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, dx: number, dy: number, dz: number, segments: number): Float64Array;
+/**
+ * Extrude a polyline and return mesh buffers.
+ * Uses the polyline's actual vertices (no resampling) to preserve sharp corners.
+ * @param {Float64Array} coords
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} _segments
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function extrude_polyline(coords: Float64Array, dx: number, dy: number, dz: number, _segments: number, with_caps: boolean): Float64Array;
+/**
+ * Fillet corners of a polyline with arcs of a given radius.
+ * Input: flat coords [x1,y1,z1, ...], radius, plane normal (nx,ny,nz; 0,0,0 for auto).
+ * Output: encoded polycurve segments [segment_count, type, ...data, type, ...data, ...]
+ *   type 0 = Line: [sx,sy,sz, ex,ey,ez]
+ *   type 1 = Arc: [cx,cy,cz, nx,ny,nz, radius, start_angle, end_angle]
+ * @param {Float64Array} coords
+ * @param {number} radius
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @returns {Float64Array}
+ */
+export function fillet_polycurve(coords: Float64Array, radius: number, nx: number, ny: number, nz: number): Float64Array;
+/**
+ * Human-readable reason for the most recent empty result returned by the
+ * offset/chamfer exports below. Cleared at the start of each such call.
+ * @returns {string}
+ */
+export function geometry_last_error(): string;
+/**
+ * @param {number} num_threads
+ * @returns {Promise<any>}
+ */
+export function initThreadPool(num_threads: number): Promise<any>;
+/**
+ * Get the length of a line segment.
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @returns {number}
+ */
+export function line_length(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
+/**
+ * Offset a line segment perpendicular to line direction relative to reference normal.
+ * Returns [startX,startY,startZ,endX,endY,endZ]
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @param {number} distance
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @returns {Float64Array}
+ */
+export function line_offset(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, distance: number, nx: number, ny: number, nz: number): Float64Array;
+/**
+ * Evaluate a point on a line segment at parameter t ∈ [0,1].
+ * Returns [x, y, z].
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function line_point_at(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, t: number): Float64Array;
+/**
+ * Get the tangent direction of a line segment. Returns [x, y, z].
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @returns {Float64Array}
+ */
+export function line_tangent(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): Float64Array;
+/**
+ * Loft between multiple circles
+ *
+ * # Parameters
+ * * `circle_data` - Flat array of circle definitions [cx, cy, cz, nx, ny, nz, radius, ...]
+ * * `segments` - Number of segments to sample along each curve
+ * * `with_caps` - Whether to create end caps
+ *
+ * # Returns
+ * Mesh buffers for the lofted surface
+ * @param {Float64Array} circle_data
+ * @param {number} segments
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function loft_circles(circle_data: Float64Array, segments: number, with_caps: boolean): Float64Array;
+/**
+ * Loft a NURBS surface through multiple NURBS curves.
+ * Input: [num_curves, degree_v, curve1_data..., curve2_data..., ...]
+ * Each curve_data: [degree, num_pts, x,y,z,..., w0,w1,..., k0,k1,...]
+ * Returns the NurbsSurface data (same format as tessellate input, without u_segs/v_segs).
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function loft_nurbs_surface(data: Float64Array): Float64Array;
+/**
+ * Loft between multiple polylines
+ *
+ * # Parameters
+ * * `polyline_data` - Flat array where each polyline is prefixed by its point count:
+ *   [count1, x1, y1, z1, x2, y2, z2, ..., count2, x1, y1, z1, ...]
+ * * `_segments` - Ignored for polylines (kept for API compat). Points are used directly.
+ * * `with_caps` - Whether to create end caps (fan triangulation from center)
+ *
+ * # Returns
+ * Mesh buffers for the lofted surface
+ * @param {Float64Array} polyline_data
+ * @param {number} _segments
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function loft_polylines(polyline_data: Float64Array, _segments: number, with_caps: boolean): Float64Array;
+/**
+ * Loft between raw profile polylines with kernel-managed compatibility
+ * (resampling to a common count, seam alignment, direction matching).
+ *
+ * # Parameters
+ * * `profile_data` - Flat array where each profile is prefixed by its point count:
+ *   [count1, x1, y1, z1, ..., count2, x1, y1, z1, ...]
+ * * `closed` - Whether profiles are closed loops (input must NOT repeat the
+ *   first point). Closed profiles loft into a tube, open profiles into a sheet.
+ * * `with_caps` - Cap the first/last profiles (closed profiles only) to produce
+ *   a watertight solid ready for booleans.
+ *
+ * # Returns
+ * Mesh buffers for the lofted surface (empty on failure)
+ * @param {Float64Array} profile_data
+ * @param {boolean} closed
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function loft_profiles(profile_data: Float64Array, closed: boolean, with_caps: boolean): Float64Array;
+/**
+ * Make multiple NURBS curves compatible (same knot vectors, same CP count).
+ * Input: [curve_count, curve1_data..., curve2_data..., ...]
+ * Each curve: [degree, num_cp, cp_xyz..., weights..., knots...]
+ * Output: same format with unified curves.
+ * @param {Float64Array} curves_data
+ * @returns {Float64Array}
+ */
+export function make_nurbs_curves_compatible(curves_data: Float64Array): Float64Array;
+/**
+ * Apply a 4x4 transformation matrix to a mesh.
+ * matrix: flat [m00,m01,m02,m03, m10,m11,..., m30,m31,m32,m33] (16 elements, row-major)
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} matrix
+ * @returns {Float64Array}
+ */
+export function mesh_apply_matrix(vertex_count: number, buffer: Float64Array, matrix: Float64Array): Float64Array;
+/**
+ * Subtract all cutter meshes from the host in one WASM call.
+ *
+ * `packed` layout matches `mesh_boolean_union_all`; the FIRST mesh is the
+ * host and every following mesh is a cutter.
+ * `flags`: `""` or `"trustedInput"`.
+ * Returns a standard result mesh buffer, or an empty vector on failure.
+ * @param {Float64Array} packed
+ * @param {string} flags
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_difference_all(packed: Float64Array, flags: string): Float64Array;
+/**
+ * Perform boolean intersection on two meshes
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_intersection(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array): Float64Array;
+/**
+ * Debug helper: run the live kernel-mesh boolean entrypoint and surface the
+ * exact error instead of collapsing it into an empty output buffer.
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_kernel_mesh_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @returns {number}
+ */
+export function mesh_boolean_last_debug_marker(): number;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {string} cleanup_stage
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_cleanup_triangle_dump(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string, cleanup_stage: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} face_index
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_face2tri_face_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string, face_index: number): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} face_index
+ * @param {number} rotate_offset
+ * @param {boolean} reverse
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_face2tri_face_transform_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string, face_index: number, rotate_offset: number, reverse: boolean): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_final_triangle_dump(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_flag_edge_attempts_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_intersections_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} face_p
+ * @param {number} face_q
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_new_edge_bucket_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string, face_p: number, face_q: number): string;
+/**
+ * @param {string} cleanup_stage
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_overlap_boxes_cleanup_triangle_dump(cleanup_stage: string): string;
+/**
+ * @param {number} face_index
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_overlap_boxes_face2tri_face_debug(face_index: number): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} face_index
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_raw_face_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string, face_index: number): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_short_edge_attempts_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @param {number} edge
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_single_swap_triangle_dump(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string, edge: number): string;
+/**
+ * Debug helper: run the isolated direct-port pipeline and surface stage counts
+ * so we can see where geometry diverges without involving legacy routing.
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_stage_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_swappable_edges_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_manifold_port_triangulated_triangle_dump(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_operation(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
+/**
+ * Debug helper: perform boolean operation and return a textual status,
+ * including kernel error reason on failure.
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_operation_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {string}
+ */
+export function mesh_boolean_port_triangle_dump(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_split(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
+/**
+ * Perform boolean subtraction on two meshes (A - B)
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_subtraction(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array): Float64Array;
+/**
+ * Perform boolean operation and return stage-level profiling data followed by
+ * the result mesh buffer.
+ *
+ * Output format:
+ * [profile_len(=95), broadphase_ms, segments_ms, split_ms,
+ *  split_touched_faces_a, split_source_faces_a, split_touched_faces_b, split_source_faces_b,
+ *  classify_ms, classify_seed_ms, classify_strict_ms, classify_open_component_ms,
+ *  extract_ms, extract_primary_ms, extract_fallback_ms,
+ * Perform boolean union on two meshes
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_union(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array): Float64Array;
+/**
+ * Union all meshes in the packed buffer into a single mesh in one WASM call.
+ *
+ * `packed` layout: `[meshCount, (bufferLen, [vertexCount, positions..., indices...])...]`.
+ * `flags`: `""` or `"trustedInput"`.
+ * Returns a standard result mesh buffer, or an empty vector on failure.
+ * @param {Float64Array} packed
+ * @param {string} flags
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_union_all(packed: Float64Array, flags: string): Float64Array;
+/**
+ * Flat 3D endpoints of every open boundary edge: `[x0,y0,z0, x1,y1,z1, ...]`,
+ * six values per segment. Empty when the mesh is closed. Drives the red
+ * "open edge" viewport highlight.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_boundary_edge_segments(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Handle variant of `mesh_boundary_edge_segments`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_boundary_edge_segments_h(id: number): Float64Array;
+/**
+ * Extract boundary (perimeter) edges from a mesh as polylines.
+ * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_boundary_polylines(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Coplanar connected face groups.
+ * Output format:
+ * [groupCount, triCount, tri..., centroidX,centroidY,centroidZ, normalX,normalY,normalZ, ...]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_build_coplanar_connected_face_groups(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Display-ready render buffers: creased (split) vertex normals plus feature
+ * edges, computed in one pass. Replaces THREE's toCreasedNormals +
+ * EdgesGeometry in app layers (orders of magnitude faster on large meshes).
+ *
+ * Output (f32-packed):
+ * [vertexCount, positions (vertexCount*3), normals (vertexCount*3),
+ *  edgeSegmentCount, edgePositions (edgeSegmentCount*6)]
+ * Vertices are non-indexed in input triangle order, so raycast face indices
+ * against the source mesh stay valid.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} crease_angle_deg
+ * @returns {Float32Array}
+ */
+export function mesh_build_render_buffers(vertex_count: number, buffer: Float64Array, crease_angle_deg: number): Float32Array;
+/**
+ * Handle variant of `mesh_build_render_buffers`.
+ * @param {number} id
+ * @param {number} crease_angle_deg
+ * @returns {Float32Array}
+ */
+export function mesh_build_render_buffers_h(id: number, crease_angle_deg: number): Float32Array;
+/**
+ * Chamfer all edges of a primitive mesh (flat bevel)
+ *
+ * # Arguments
+ * * `mesh_type` - "box", "cylinder", or "prism"
+ * * `params` - Parameters: [width,height,depth] for box, [radius,height,segments] for cylinder/prism
+ * * `offset` - Chamfer offset distance
+ *
+ * # Returns
+ * Result mesh buffer [vertexCount, vertices..., indices...]
+ * @param {string} mesh_type
+ * @param {Float64Array} params
+ * @param {number} offset
+ * @returns {Float64Array}
+ */
+export function mesh_chamfer_all_edges(mesh_type: string, params: Float64Array, offset: number): Float64Array;
+/**
+ * Chamfer feature edges of a closed solid. `edges` is a flat buffer of
+ * segment endpoint pairs [ax,ay,az,bx,by,bz, ...]; each picked segment
+ * expands to its full feature-edge chain (straight box edges, tessellated
+ * rims). `distance` is the setback along each adjacent face.
+ * Returns a standard mesh buffer, or empty on failure (see
+ * `geometry_last_error`).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} edges
+ * @param {number} distance
+ * @returns {Float64Array}
+ */
+export function mesh_chamfer_edges(vertex_count: number, buffer: Float64Array, edges: Float64Array, distance: number): Float64Array;
+/**
+ * Clip a polyline against a closed mesh volume (boolean intersection for curves).
+ *
+ * `points` is a flat [x,y,z, ...] vertex list; `closed` marks a closed loop
+ * (no duplicated seam point required, one is tolerated).
+ * Returns two concatenated polyline buffers — inside pieces first, then
+ * outside pieces — each encoded as [num_polylines, n1, x,y,z,..., ...].
+ * Returns an empty buffer on failure (open cutter, degenerate polyline).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {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).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_clip_polyline_by_sheet(vertex_count: number, buffer: Float64Array, points: Float64Array, closed: boolean): Float64Array;
+/**
+ * Compute planar curve normal from ordered points.
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_compute_planar_curve_normal(coords: Float64Array, closed: boolean): Float64Array;
+/**
+ * Odd/even mesh containment test.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {boolean}
+ */
+export function mesh_contains_point(vertex_count: number, buffer: Float64Array, px: number, py: number, pz: number): boolean;
+/**
+ * Create a box mesh and return buffers
+ * Returns [vertices..., indices...]
+ * @param {number} width
+ * @param {number} height
+ * @param {number} depth
+ * @returns {Float64Array}
+ */
+export function mesh_create_box(width: number, height: number, depth: number): Float64Array;
+/**
+ * Create a Manifold-aligned centered Z-axis cone mesh and return buffers
+ * @param {number} radius
+ * @param {number} height
+ * @param {number} segments
+ * @returns {Float64Array}
+ */
+export function mesh_create_cone(radius: number, height: number, segments: number): Float64Array;
+/**
+ * Create a Manifold-aligned centered Z-axis cylinder mesh and return buffers
+ * @param {number} radius
+ * @param {number} height
+ * @param {number} segments
+ * @returns {Float64Array}
+ */
+export function mesh_create_cylinder(radius: number, height: number, segments: number): Float64Array;
+/**
+ * Create a prism mesh and return buffers
+ * @param {number} radius
+ * @param {number} height
+ * @param {number} sides
+ * @returns {Float64Array}
+ */
+export function mesh_create_prism(radius: number, height: number, sides: number): Float64Array;
+/**
+ * Create a geodesic sphere mesh matching Manifold's sphere topology and return buffers
+ * @param {number} radius
+ * @param {number} segments
+ * @param {number} rings
+ * @returns {Float64Array}
+ */
+export function mesh_create_sphere(radius: number, segments: number, rings: number): Float64Array;
+/**
+ * Evaluate a point on a mesh surface at parametric coordinates (u, v).
+ * Maps u ∈ [0,1] and v ∈ [0,1] to the mesh's AABB bounding box,
+ * then casts a ray perpendicular to the best-fit projection plane.
+ * Returns [x, y, z] of the intersection point, or [NaN, NaN, NaN] if no hit.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} u
+ * @param {number} v
+ * @returns {Float64Array}
+ */
+export function mesh_evaluate(vertex_count: number, buffer: Float64Array, u: number, v: number): Float64Array;
+/**
+ * Export a mesh to OBJ format
+ * Takes the standard mesh buffer (`[vertexCount, ...positions, ...indices]`,
+ * same format as `mesh_to_buffers` / `Mesh.rawBuffer`) and returns OBJ text.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {string}
+ */
+export function mesh_export_obj(vertex_count: number, buffer: Float64Array): string;
+/**
+ * Export a mesh (standard buffer format) to ASCII STL text.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {string} name
+ * @returns {string}
+ */
+export function mesh_export_stl_ascii(vertex_count: number, buffer: Float64Array, name: string): string;
+/**
+ * Export a mesh (standard buffer format) to binary STL bytes.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Uint8Array}
+ */
+export function mesh_export_stl_binary(vertex_count: number, buffer: Float64Array): Uint8Array;
+/**
+ * Push/pull a planar face set by moving its coplanar connected region.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @param {number} distance
+ * @returns {Float64Array}
+ */
+export function mesh_extrude_face(vertex_count: number, buffer: Float64Array, face_index: number, distance: number): Float64Array;
+/**
+ * Extrude planar curve profile by normal * height.
+ * @param {Float64Array} coords
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} height
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_extrude_planar_curve(coords: Float64Array, nx: number, ny: number, nz: number, height: number, closed: boolean): Float64Array;
+/**
+ * Feature-edge chains of a mesh for chamfer highlighting: every connected
+ * chain of edges separating the same two smooth face groups — the exact
+ * grouping `mesh_chamfer_edges` expands picks to, so highlighting a chain
+ * shows precisely what one pick will chamfer. Packed as
+ * `[chainCount, (closed, pointCount, x,y,z ...)...]`; closed chains omit the
+ * duplicate seam point. A mesh with no feature edges returns `[0]`; an
+ * invalid mesh returns an empty buffer (see `geometry_last_error`).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_feature_edge_chains(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Handle variant of `mesh_feature_edge_chains`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_feature_edge_chains_h(id: number): Float64Array;
+/**
+ * Find the best matching coplanar connected face group by normal and optional near-point.
+ * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} near_x
+ * @param {number} near_y
+ * @param {number} near_z
+ * @param {boolean} use_near_point
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_normal(vertex_count: number, buffer: Float64Array, nx: number, ny: number, nz: number, near_x: number, near_y: number, near_z: number, use_near_point: boolean): Float64Array;
+/**
+ * Handle variant of `mesh_find_face_group_by_normal`.
+ * @param {number} id
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} near_x
+ * @param {number} near_y
+ * @param {number} near_z
+ * @param {boolean} use_near_point
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_normal_h(id: number, nx: number, ny: number, nz: number, near_x: number, near_y: number, near_z: number, use_near_point: boolean): Float64Array;
+/**
+ * Find the coplanar connected face group containing triangle_index.
+ * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} triangle_index
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_triangle_index(vertex_count: number, buffer: Float64Array, triangle_index: number): Float64Array;
+/**
+ * Handle variant of `mesh_find_face_group_by_triangle_index`.
+ * @param {number} id
+ * @param {number} triangle_index
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_triangle_index_h(id: number, triangle_index: number): Float64Array;
+/**
+ * Axis-aligned bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_get_bounds(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Coplanar connected face-group centroid containing a given triangle face index.
+ * Output format: [x, y, z] or [] when unavailable.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_group_centroid(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
+/**
+ * Handle variant of `mesh_get_coplanar_face_group_centroid`.
+ * @param {number} id
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_group_centroid_h(id: number, face_index: number): Float64Array;
+/**
+ * Edge-connected coplanar triangle indices as [count, i0, i1, ...].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_indices(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
+/**
+ * Handle variant of `mesh_get_coplanar_face_indices`.
+ * @param {number} id
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_indices_h(id: number, face_index: number): Float64Array;
+/**
+ * Coplanar connected face region projected to a plane basis.
+ * Output format:
+ * [faceCount, faceIndex0, faceIndex1, ..., uMin, uMax, vMin, vMax]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} ux
+ * @param {number} uy
+ * @param {number} uz
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} margin_scale
+ * @param {number} min_margin
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_region(vertex_count: number, buffer: Float64Array, face_index: number, ox: number, oy: number, oz: number, ux: number, uy: number, uz: number, vx: number, vy: number, vz: number, margin_scale: number, min_margin: number): Float64Array;
+/**
+ * Unique undirected triangle edges as [edgeCount, v0a, v0b, v1a, v1b, ...].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_get_edge_vertex_pairs(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Handle variant of `mesh_get_edge_vertex_pairs`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_get_edge_vertex_pairs_h(id: number): Float64Array;
+/**
+ * Face area.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {number}
+ */
+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).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_boundary_loops(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
+/**
+ * Handle variant of `mesh_get_face_boundary_loops`.
+ * @param {number} id
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_boundary_loops_h(id: number, face_index: number): Float64Array;
+/**
+ * Face centroid as [x, y, z].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_centroid(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
+/**
+ * Face normal as [x, y, z].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_normal(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
+/**
+ * Edge-connected smooth face group (dihedral angle below `max_angle_deg`).
+ * Output format: [count, isPlanar (0|1), tri0, tri1, ...]
+ * `isPlanar` is 1 when every triangle normal in the group aligns with the
+ * seed triangle's normal (i.e. the group is a flat face), 0 for curved
+ * regions such as cylinder walls or lofted patches.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @param {number} max_angle_deg
+ * @returns {Float64Array}
+ */
+export function mesh_get_smooth_face_group(vertex_count: number, buffer: Float64Array, face_index: number, max_angle_deg: number): Float64Array;
+/**
+ * Handle variant of `mesh_get_smooth_face_group`.
+ * @param {number} id
+ * @param {number} face_index
+ * @param {number} max_angle_deg
+ * @returns {Float64Array}
+ */
+export function mesh_get_smooth_face_group_h(id: number, face_index: number, max_angle_deg: number): Float64Array;
+/**
+ * Get mesh statistics
+ * Returns [vertex_count, face_count, edge_count]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_get_stats(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Import OBJ data and return mesh buffers
+ * @param {string} obj_data
+ * @returns {Float64Array}
+ */
+export function mesh_import_obj(obj_data: string): Float64Array;
+/**
+ * Import STL data (binary or ASCII, auto-detected) and return the standard
+ * mesh buffer (`[vertexCount, ...positions, ...indices]`). STL stores an
+ * unindexed triangle soup, so coincident vertices are welded.
+ *
+ * `weld_tolerance`: absolute distance under which vertices merge; `<= 0`
+ * selects an automatic tolerance from the bounding box. Returns an empty
+ * buffer on parse failure.
+ * @param {Uint8Array} data
+ * @param {number} weld_tolerance
+ * @returns {Float64Array}
+ */
+export function mesh_import_stl(data: Uint8Array, weld_tolerance: number): Float64Array;
+/**
+ * Check if triangulated mesh is a closed volume (no welded boundary edges).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {boolean}
+ */
+export function mesh_is_closed_volume(vertex_count: number, buffer: Float64Array): boolean;
+/**
+ * Layered "make watertight": first geometry-preserving repair; if that already
+ * closes the mesh, return it. Otherwise fall back to voxel remeshing.
+ *
+ * Output: `[ before(13), after(13), method, effectiveResolution, vertexCount,
+ * ...positions, ...indices ]` where `method` is 0 (repair) or 1 (remesh) and
+ * `after` describes the returned mesh.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} resolution
+ * @param {number} iso
+ * @returns {Float64Array}
+ */
+export function mesh_make_watertight(vertex_count: number, buffer: Float64Array, resolution: number, iso: number): Float64Array;
+/**
+ * Debug helper: run only the isolated direct-port `MeshGL -> Impl -> MeshGL`
+ * normalization owner and return a JSON dump for local port validation.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {boolean} trusted_input
+ * @returns {string}
+ */
+export function mesh_manifold_port_import_roundtrip_debug(vertex_count: number, buffer: Float64Array, trusted_input: boolean): string;
+/**
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {boolean} trusted_input
+ * @returns {string}
+ */
+export function mesh_manifold_port_import_stage_hashes_debug(vertex_count: number, buffer: Float64Array, trusted_input: boolean): string;
+/**
+ * @param {Float64Array} data
+ * @param {number} epsilon
+ * @param {boolean} allow_convex
+ * @returns {string}
+ */
+export function mesh_manifold_port_triangulate_projected_polygon_debug(data: Float64Array, epsilon: number, allow_convex: boolean): string;
+/**
+ * Merge multiple mesh buffers while preserving per-mesh vertex order and index remapping.
+ * Input format: [mesh_count, len1, mesh1..., len2, mesh2..., ...]
+ * @param {Float64Array} mesh_data
+ * @returns {Float64Array}
+ */
+export function mesh_merge(mesh_data: Float64Array): Float64Array;
+/**
+ * Intersect two meshes, returning intersection polyline points.
+ * Returns: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
+ * @param {number} va_count
+ * @param {Float64Array} buffer_a
+ * @param {number} vb_count
+ * @param {Float64Array} buffer_b
+ * @returns {Float64Array}
+ */
+export function mesh_mesh_intersect(va_count: number, buffer_a: Float64Array, vb_count: number, buffer_b: Float64Array): Float64Array;
+/**
+ * Create a planar patch mesh from boundary points using CDT.
+ * Correctly handles concave polygons (unlike fan triangulation).
+ * Input: flat coordinate array [x1,y1,z1, x2,y2,z2, ...]
+ * Output: mesh buffer [vertexCount, x1,y1,z1,..., i0,i1,i2, ...]
+ * @param {Float64Array} coords
+ * @returns {Float64Array}
+ */
+export function mesh_patch_from_points(coords: Float64Array): Float64Array;
+/**
+ * Evaluate a point on a planar mesh-face surface at normalized parameters.
+ * Parameters map across the face group's local 2D bounds.
+ * Returns [x, y, z] or [NaN, NaN, NaN] when the query falls outside the face region.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @param {number} u
+ * @param {number} v
+ * @returns {Float64Array}
+ */
+export function mesh_planar_face_evaluate(vertex_count: number, buffer: Float64Array, face_index: number, u: number, v: number): Float64Array;
+/**
+ * Intersect a mesh with a plane, returning polyline points.
+ * Input: vertex_count, mesh_buffer..., nx, ny, nz, d
+ * Returns: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} d
+ * @returns {Float64Array}
+ */
+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).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+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,...]
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} height
+ * @returns {Float64Array}
+ */
+export function mesh_prepare_boolean_cutter_curve(coords: Float64Array, closed: boolean, nx: number, ny: number, nz: number, height: number): Float64Array;
+/**
+ * Host-aware boolean cutter preparation: like
+ * `mesh_prepare_boolean_cutter_curve`, but the bias is raised past the
+ * measured host-surface deviation under the cutter footprint (sculpted /
+ * non-planar faces). The host arrives as a standard triangulated buffer.
+ * Returns [height, epsilon, pointCount, x,y,z,...]
+ * @param {number} host_vertex_count
+ * @param {Float64Array} host_buffer
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} height
+ * @returns {Float64Array}
+ */
+export function mesh_prepare_hosted_boolean_cutter(host_vertex_count: number, host_buffer: Float64Array, coords: Float64Array, closed: boolean, nx: number, ny: number, nz: number, height: number): Float64Array;
+/**
+ * Raycast against mesh and return closest hit.
+ * Output: [] when no hit, otherwise [pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast(vertex_count: number, buffer: Float64Array, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
+/**
+ * Raycast against mesh and return all hits sorted by distance.
+ * Output: [hitCount, (point, normal, faceIndex, distance)*]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_all(vertex_count: number, buffer: Float64Array, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
+/**
+ * Handle variant of `mesh_raycast_all` — reuses the stored mesh's cached BVH.
+ * @param {number} id
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_all_h(id: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
+/**
+ * Handle variant of `mesh_raycast` — reuses the stored mesh's cached BVH.
+ * @param {number} id
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_h(id: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
+/**
+ * Raycast against many meshes packed as:
+ * [meshCount, meshLen0, meshRaw0..., meshLen1, meshRaw1..., ...]
+ * Output: [hitCount, meshIndex, pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance, ...]
+ * @param {Float64Array} mesh_data
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_many(mesh_data: Float64Array, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, max_distance: number): Float64Array;
+/**
+ * Geometry-preserving repair: weld, drop degenerate/duplicate triangles,
+ * remove orphan vertices, fix winding, and fill holes.
+ *
+ * `flags` bitmask: 1=weld, 2=removeDegenerate, 4=removeDuplicate,
+ * 8=fillHoles, 16=fixWinding, 32=removeUnreferenced. `weld_tolerance <= 0`
+ * = auto; `max_hole_edges <= 0` = fill every hole.
+ *
+ * Output: `[ before(13), after(13), weldedVertices, removedTriangles,
+ * filledHoles, vertexCount, ...positions, ...indices ]` — the trailing mesh
+ * buffer is a standard `[vertexCount, positions, indices]` block.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} flags
+ * @param {number} weld_tolerance
+ * @param {number} max_hole_edges
+ * @returns {Float64Array}
+ */
+export function mesh_repair(vertex_count: number, buffer: Float64Array, flags: number, weld_tolerance: number, max_hole_edges: number): Float64Array;
+/**
+ * Full mesh health report (see [`push_repair_diag`] for the 13-value layout).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_repair_diagnostics(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Handle variant of `mesh_repair_diagnostics`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_repair_diagnostics_h(id: number): Float64Array;
+/**
+ * Rotate a mesh around an arbitrary axis and return new buffers
+ * Axis is defined by (ax, ay, az), angle in radians
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} angle
+ * @returns {Float64Array}
+ */
+export function mesh_rotate(vertex_count: number, buffer: Float64Array, ax: number, ay: number, az: number, angle: number): Float64Array;
+/**
+ * Scale a mesh non-uniformly and return new buffers
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} sx
+ * @param {number} sy
+ * @param {number} sz
+ * @returns {Float64Array}
+ */
+export function mesh_scale(vertex_count: number, buffer: Float64Array, sx: number, sy: number, sz: number): Float64Array;
+/**
+ * Union of two OPEN oriented sheets (mesh A ∪ mesh B): mutual trim + join.
+ * A sheet's material is its FRONT half-space, so the union boundary keeps
+ * A's pieces BEHIND B and B's pieces BEHIND A (pieces in front of the other
+ * sheet are interior to the union material and are dropped), stitched at
+ * the shared intersection seam; regions the other operand never cuts are
+ * kept wholesale (coincident-overlap regions keep A's copy only). Rejects
+ * closed operands — those belong to the solid boolean. Returns one mesh
+ * buffer in the standard `[vertexCount, positions…, indices…]` layout.
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} flags
+ * @returns {Float64Array}
+ */
+export function mesh_sheet_union(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, flags: string): Float64Array;
+/**
+ * Split a closed solid (mesh A) by a surface (mesh B) into BOTH capped solids.
+ * `outside` = the solid on the negative side of the surface, `inside` = the
+ * positive side; each is capped by the portion of the surface inside the
+ * solid, welded into a watertight result. Same packed layout as the other
+ * split exports.
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {Float64Array}
+ */
+export function mesh_solid_split_by_surface(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
+/**
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} d
+ * @param {string} operation
+ * @returns {Float64Array}
+ */
+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":...}.
+ * @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: 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.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_split_polyline(vertex_count: number, buffer: Float64Array, points: Float64Array, closed: boolean): Float64Array;
+/**
+ * Store a mesh buffer `[vertexCount, x,y,z..., i0,i1,i2...]` WASM-side.
+ * Returns a non-zero id, or 0 on invalid input.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {number}
+ */
+export function mesh_store(vertex_count: number, buffer: Float64Array): number;
+/**
+ * Approximate bytes held by stored mesh raw buffers (diagnostics/tests).
+ * Excludes lazy raycast caches.
+ * @returns {number}
+ */
+export function mesh_store_bytes(): number;
+/**
+ * Number of stored meshes (diagnostics/tests).
+ * @returns {number}
+ */
+export function mesh_store_count(): number;
+/**
+ * Release a stored mesh and free its memory (idempotent).
+ * @param {number} id
+ */
+export function mesh_store_free(id: number): void;
+/**
+ * Trim an OPEN host surface by all closed cutter meshes in one WASM call.
+ *
+ * `packed` layout matches `mesh_boolean_difference_all`: the FIRST mesh is
+ * the open host and every following mesh is a closed cutter volume.
+ * `flags`: `""` or `"trustedInput"`.
+ *
+ * Unlike folding pairwise surface-split subtracts over the cutter list,
+ * every host triangle is cut by ALL relevant cutters at once (one CDT per
+ * triangle) and classified inside-any-cutter — one pass over the host
+ * instead of N passes over an ever-growing, ever-degrading host.
+ * Returns the outside (kept) mesh buffer, or an empty vector on failure.
+ * @param {Float64Array} packed
+ * @param {string} flags
+ * @returns {Float64Array}
+ */
+export function mesh_surface_difference_all(packed: Float64Array, flags: string): Float64Array;
+/**
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {Float64Array}
+ */
+export function mesh_surface_split(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
+/**
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} d
+ * @param {string} operation
+ * @returns {Float64Array}
+ */
+export function mesh_surface_split_plane(vertex_count: number, buffer: Float64Array, nx: number, ny: number, nz: number, d: number, operation: string): Float64Array;
+/**
+ * Return welded-edge topology metrics for a triangulated mesh buffer:
+ * `[boundary_edges, non_manifold_edges]`.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_topology_metrics(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Return raw index-topology metrics for a triangulated mesh buffer:
+ * `[boundary_edges, non_manifold_edges]`.
+ *
+ * Unlike `mesh_topology_metrics`, this preserves duplicate same-position seam
+ * vertices. That makes it a closer fit for trusted MeshGL-style boolean meshes,
+ * where manifoldness comes from explicit topology rather than position welding.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_topology_metrics_raw(vertex_count: number, buffer: Float64Array): Float64Array;
+/**
+ * Translate a mesh by an offset vector and return new buffers
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @returns {Float64Array}
+ */
+export function mesh_translate(vertex_count: number, buffer: Float64Array, dx: number, dy: number, dz: number): Float64Array;
+/**
+ * Rebuild a mesh as a guaranteed-watertight solid via generalized-winding-
+ * number voxel remeshing. `resolution` = cells along the longest axis
+ * (`0` = 64 default, auto-capped by a work budget). `iso` = winding threshold
+ * (`<=0` or `>=1` → 0.5).
+ *
+ * Output: a standard `[vertexCount, ...positions, ...indices]` mesh buffer.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} resolution
+ * @param {number} iso
+ * @returns {Float64Array}
+ */
+export function mesh_voxel_remesh(vertex_count: number, buffer: Float64Array, resolution: number, iso: number): Float64Array;
+/**
+ * Intersect two NURBS curves.
+ * Returns: [num_points, x,y,z, ...]
+ * @param {Float64Array} data_a
+ * @param {Float64Array} data_b
+ * @returns {Float64Array}
+ */
+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.
+ * @param {Float64Array} curve_a_data
+ * @param {Float64Array} curve_b_data
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_curve_intersect_params(curve_a_data: Float64Array, curve_b_data: Float64Array): Float64Array;
+/**
+ * Offset a planar NURBS curve by `distance` within the plane with normal
+ * (nx, ny, nz), refit to `tolerance`. Input/output use the standard curve
+ * buffer format [degree, n, cps(xyz)..., weights..., knots...].
+ * Returns an empty buffer on failure (see `geometry_last_error`).
+ * @param {Float64Array} data
+ * @param {number} distance
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_offset(data: Float64Array, distance: number, nx: number, ny: number, nz: number, tolerance: number): Float64Array;
+/**
+ * Intersect a NURBS curve with a plane.
+ * Input: same curve format as sample_nurbs_curve + plane normal (nx,ny,nz) and d.
+ * Returns: [num_points, x,y,z, x,y,z, ...]
+ * @param {Float64Array} data
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} d
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_plane_intersect(data: Float64Array, nx: number, ny: number, nz: number, d: number): Float64Array;
+/**
+ * Rebuild a NURBS curve with the given degree and control point count via
+ * global least-squares fitting (Rhino-style Rebuild). Geometrically closed
+ * inputs produce a periodic (seamlessly closed) result; output is always
+ * non-rational. Input uses the standard curve buffer format
+ * [degree, n, cps(xyz)..., weights..., knots...]; output prepends the fit
+ * report: [maxDeviation, avgDeviation, degree, n, cps..., weights...,
+ * knots...]. Returns an empty buffer on failure (see `geometry_last_error`).
+ * @param {Float64Array} data
+ * @param {number} degree
+ * @param {number} count
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_rebuild(data: Float64Array, degree: number, count: 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.
+ * @param {Float64Array} curve_data
+ * @param {Float64Array} params
+ * @param {number} closed_hint
+ * @returns {Float64Array}
+ */
+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.
+ * @param {Float64Array} curve_data
+ * @param {Float64Array} surface_data
+ * @returns {Float64Array}
+ */
+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].
+ * @param {Float64Array} data
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_closest_point(data: Float64Array, x: number, y: number, z: number): Float64Array;
+/**
+ * Surface curvature at normalized (u, v): [k1, k2, gaussian, mean, nx, ny, nz].
+ * @param {Float64Array} data
+ * @param {number} u
+ * @param {number} v
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_curvature(data: Float64Array, u: number, v: number): Float64Array;
+/**
+ * Analytic surface derivatives at normalized (u, v) in [0,1]².
+ * Returns 18 floats: [S, Su, Sv, Suu, Suv, Svv] (xyz each), derivatives taken
+ * with respect to the NORMALIZED parameters (chain rule applied).
+ * @param {Float64Array} data
+ * @param {number} u
+ * @param {number} v
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_derivatives(data: Float64Array, u: number, v: number): Float64Array;
+/**
+ * Exact degree elevation by `t` in one direction.
+ * @param {Float64Array} data
+ * @param {boolean} u_dir
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_elevate_degree(data: Float64Array, u_dir: boolean, t: number): Float64Array;
+/**
+ * Evaluate a NURBS surface at normalized parameters (u, v) in [0,1].
+ * Returns [x, y, z]
+ * @param {Float64Array} data
+ * @param {number} u
+ * @param {number} v
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_evaluate(data: Float64Array, u: number, v: number): Float64Array;
+/**
+ * Exact sub-patch extraction over normalized ranges.
+ * @param {Float64Array} data
+ * @param {number} u0
+ * @param {number} u1
+ * @param {number} v0
+ * @param {number} v1
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_extract_region(data: Float64Array, u0: number, u1: number, v0: number, v1: number): Float64Array;
+/**
+ * Exact extruded (translational) surface from a profile curve.
+ * @param {Float64Array} curve_data
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_extrude(curve_data: Float64Array, dx: number, dy: number, dz: number): Float64Array;
+/**
+ * Exact knot insertion at normalized parameter t (repeated `times`).
+ * Returns the refined surface in standard surface format.
+ * @param {Float64Array} data
+ * @param {boolean} u_dir
+ * @param {number} t
+ * @param {number} times
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_insert_knot(data: Float64Array, u_dir: boolean, t: number, times: number): Float64Array;
+/**
+ * Exact rational iso-parametric curve. `u_dir = true` extracts the curve
+ * running along u at constant v = t; false extracts along v at constant u = t.
+ * t is normalized [0,1]. Returns curve data [degree, n, pts..., w..., knots...].
+ * @param {Float64Array} data
+ * @param {number} t
+ * @param {boolean} u_dir
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_iso_curve(data: Float64Array, t: number, u_dir: boolean): Float64Array;
+/**
+ * Evaluate a NURBS surface unit normal at normalized parameters (u, v) in [0,1].
+ * Returns [x, y, z]
+ * @param {Float64Array} data
+ * @param {number} u
+ * @param {number} v
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_normal(data: Float64Array, u: number, v: number): Float64Array;
+/**
+ * Offset a NURBS surface by `distance` along its normal field, refit to
+ * `tolerance`. Input/output use the standard surface buffer format.
+ * Returns an empty buffer on failure (see `geometry_last_error`).
+ * @param {Float64Array} data
+ * @param {number} distance
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_offset(data: Float64Array, distance: number, tolerance: number): Float64Array;
+/**
+ * Intersect a NURBS surface with a plane.
+ * Input: same surface format as tessellate_nurbs_surface, then plane (nx,ny,nz,d) appended.
+ * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
+ * @param {Float64Array} surface_data
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} d
+ * @param {number} tess
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_plane_intersect(surface_data: Float64Array, nx: number, ny: number, nz: number, d: number, tess: number): Float64Array;
+/**
+ * Exact rational primitive surfaces.
+ * kind: "cylinder" [bx,by,bz, ax,ay,az, radius, height]
+ *       "sphere"   [cx,cy,cz, radius]
+ *       "cone"     [bx,by,bz, ax,ay,az, radius0, radius1, height]
+ *       "torus"    [cx,cy,cz, major, minor]
+ * @param {string} kind
+ * @param {Float64Array} params
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_primitive(kind: string, params: Float64Array): Float64Array;
+/**
+ * Rebuild a NURBS surface with the given degrees and control counts via the
+ * two-stage least-squares scheme. Closed directions stay closed (periodic
+ * basis); poles stay exactly degenerate; output is non-rational. Input uses
+ * the standard surface buffer format; output prepends the fit report:
+ * [maxDeviation, avgDeviation, ...surface buffer]. Returns an empty buffer
+ * on failure (see `geometry_last_error`).
+ * @param {Float64Array} data
+ * @param {number} degree_u
+ * @param {number} degree_v
+ * @param {number} count_u
+ * @param {number} count_v
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_rebuild(data: Float64Array, degree_u: number, degree_v: number, count_u: number, count_v: number): Float64Array;
+/**
+ * Exact surface of revolution from a profile curve (A8.1).
+ * @param {Float64Array} curve_data
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} angle
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_revolve(curve_data: Float64Array, ox: number, oy: number, oz: number, ax: number, ay: number, az: number, angle: number): Float64Array;
+/**
+ * Exact ruled surface between two curves (auto degree/knot compatibility).
+ * @param {Float64Array} curve_a
+ * @param {Float64Array} curve_b
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_ruled(curve_a: Float64Array, curve_b: Float64Array): Float64Array;
+/**
+ * Exact split at normalized parameter t. Returns [lenA, surfaceA..., lenB, surfaceB...].
+ * @param {Float64Array} data
+ * @param {boolean} u_dir
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_split(data: Float64Array, u_dir: boolean, t: number): Float64Array;
+/**
+ * Intersect two NURBS surfaces.
+ * Returns polyline buffer.
+ * @param {Float64Array} data_a
+ * @param {Float64Array} data_b
+ * @param {number} tess
+ * @returns {Float64Array}
+ */
+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.
+ * @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: Float64Array, surf_b_data: Float64Array, tolerance: number): Float64Array;
+/**
+ * Curvature-adaptive tessellation against a chordal tolerance.
+ * Returns the standard mesh buffer [vertexCount, positions..., indices...].
+ * @param {Float64Array} data
+ * @param {number} tolerance
+ * @param {number} max_segments_per_span
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_tessellate_adaptive(data: Float64Array, tolerance: number, max_segments_per_span: number): Float64Array;
+/**
+ * Display-ready render tessellation: twist-aware adaptive grid with ANALYTIC
+ * surface normals, plus feature edges only where the surface really has them
+ * (boundaries, kinked C0 knot lines, kinked closed seams).
+ * Output (f32, same packing as `mesh_build_render_buffers`):
+ * [vertexCount, positions..., normals..., edgeSegmentCount, edgeSegments...]
+ * @param {Float64Array} data
+ * @param {number} tolerance
+ * @param {number} max_segments_per_span
+ * @param {number} crease_angle_deg
+ * @returns {Float32Array}
+ */
+export function nurbs_surface_tessellate_render(data: Float64Array, tolerance: number, max_segments_per_span: number, crease_angle_deg: number): Float32Array;
+/**
+ * Offset a polycurve made of line and arc segments.
+ * Input format: [segment_count, type, ...data, ...]
+ *   type 0 = Line: [sx,sy,sz, ex,ey,ez]
+ *   type 1 = Arc:  [cx,cy,cz, nx,ny,nz, radius, start_angle, end_angle]
+ * Output uses the same encoded segment format.
+ * @param {Float64Array} segment_data
+ * @param {number} distance
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} join_style_code
+ * @returns {Float64Array}
+ */
+export function offset_polycurve(segment_data: Float64Array, distance: number, nx: number, ny: number, nz: number, join_style_code: number): Float64Array;
+/**
+ * Offset a polycurve and return every exact result curve.
+ * Output format: [curve_count, curve_len, curve_data..., curve_len, curve_data..., ...]
+ * @param {Float64Array} segment_data
+ * @param {number} distance
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} join_style_code
+ * @returns {Float64Array}
+ */
+export function offset_polycurve_all(segment_data: Float64Array, distance: number, nx: number, ny: number, nz: number, join_style_code: number): Float64Array;
+/**
+ * Offset a polyline by a distance in a given plane.
+ * If nx=ny=nz=0, the plane normal is auto-detected.
+ * Returns flat [x1,y1,z1, x2,y2,z2, ...] of the offset polyline.
+ * @param {Float64Array} coords
+ * @param {number} distance
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @returns {Float64Array}
+ */
+export function offset_polyline_curve(coords: Float64Array, distance: number, nx: number, ny: number, nz: number): Float64Array;
+/**
+ * Convert a polycurve (Line/Arc segments) to an exact NURBS curve.
+ * Input format: [segment_count, type1, ...data1..., type2, ...data2..., ...]
+ * type 0 = Line (6 floats: start_xyz, end_xyz)
+ * type 1 = Arc (9 floats: center_xyz, normal_xyz, radius, start_angle, end_angle)
+ * Output format: [degree, num_cp, cp_x1,y1,z1,..., w1,w2,..., k1,k2,...]
+ * @param {Float64Array} segment_data
+ * @returns {Float64Array}
+ */
+export function polycurve_to_nurbs(segment_data: Float64Array): Float64Array;
+/**
+ * Get the total length of a polyline.
+ * Input: flat coords [x1,y1,z1, x2,y2,z2, ...]
+ * @param {Float64Array} coords
+ * @returns {number}
+ */
+export function polyline_length(coords: Float64Array): number;
+/**
+ * Evaluate a point on a polyline at parameter t ∈ [0,1].
+ * Input: flat coords [x1,y1,z1, x2,y2,z2, ...]
+ * Returns [x, y, z].
+ * @param {Float64Array} coords
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function polyline_point_at(coords: Float64Array, t: number): Float64Array;
+/**
+ * Find the closest point on a ray to a given point.
+ * Returns [x, y, z] of the closest point on the ray.
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {Float64Array}
+ */
+export function ray_closest_point(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, px: number, py: number, pz: number): Float64Array;
+/**
+ * Find the parameter t for the closest point on a ray to a given point.
+ * The closest point is at: origin + t * direction
+ * Note: t can be negative if the closest point is "behind" the ray origin.
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number}
+ */
+export function ray_closest_point_parameter(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, px: number, py: number, pz: number): number;
+/**
+ * Compute the distance from a ray to a point.
+ * Ray is defined by origin (ox, oy, oz) and direction (dx, dy, dz).
+ * Direction should be normalized for accurate distance.
+ * Returns the perpendicular distance from the ray to the point.
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number}
+ */
+export function ray_distance_to_point(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, px: number, py: number, pz: number): number;
+/**
+ * Get a point along the ray at parameter t.
+ * Returns [x, y, z] = origin + t * direction
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} t
+ * @returns {Float64Array}
+ */
+export function ray_point_at(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, t: number): Float64Array;
+/**
+ * Sample a NURBS curve.
+ * Input: degree, then flat control points [x,y,z,...], then flat weights, then flat knots
+ * Format: [degree, num_pts, x0,y0,z0, ..., w0,w1,..., k0,k1,...]
+ * @param {Float64Array} data
+ * @param {number} samples
+ * @returns {Float64Array}
+ */
+export function sample_nurbs_curve(data: Float64Array, samples: number): Float64Array;
+/**
+ * Begin a stroke. `brush` and `falloff` are stable enum codes
+ * (see okgeometry-api SculptBrush / SculptFalloff). Flags: bit 0 = invert,
+ * bit 1 = front faces only. `symmetry`: bit 0 = X, bit 1 = Y, bit 2 = Z.
+ * @param {number} id
+ * @param {number} brush
+ * @param {number} radius
+ * @param {number} strength
+ * @param {number} falloff
+ * @param {number} flags
+ * @param {number} plane_offset
+ * @param {number} symmetry
+ * @returns {number}
+ */
+export function sculpt_session_begin_stroke(id: number, brush: number, radius: number, strength: number, falloff: number, flags: number, plane_offset: number, symmetry: number): number;
+/**
+ * Create a sculpt session from a standard mesh buffer
+ * `[vertexCount, x,y,z..., i0,i1,i2...]`. Returns the session id, or 0 on
+ * invalid input.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {number}
+ */
+export function sculpt_session_create(vertex_count: number, buffer: Float64Array): number;
+/**
+ * Apply one dab. Returns the render patch `[index, x,y,z, nx,ny,nz]` per
+ * changed vertex (f32), empty when nothing changed.
+ * @param {number} id
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} dragx
+ * @param {number} dragy
+ * @param {number} dragz
+ * @param {number} pressure
+ * @returns {Float32Array}
+ */
+export function sculpt_session_dab(id: number, cx: number, cy: number, cz: number, vx: number, vy: number, vz: number, dragx: number, dragy: number, dragz: number, pressure: number): Float32Array;
+/**
+ * Locally REDUCE point density in the given triangle group (constrained
+ * edge collapse of interior vertices; the group boundary is preserved)
+ * until the group has at most `target_points` unique vertices or no safe
+ * collapse remains. Returns 1 when at least one collapse happened, 0
+ * otherwise. Clears session undo history; callers must refetch
+ * `sculpt_session_render_data` afterwards.
+ * @param {number} id
+ * @param {Uint32Array} triangles
+ * @param {number} target_points
+ * @returns {number}
+ */
+export function sculpt_session_decimate_faces(id: number, triangles: Uint32Array, target_points: number): number;
+/**
+ * Finish the active stroke (pushes one undo entry).
+ * @param {number} id
+ */
+export function sculpt_session_end_stroke(id: number): void;
+/**
+ * Smooth face group around a seed triangle (dihedral flood fill, same
+ * semantics as the mesh-level query push-pull uses). Returns the group's
+ * triangle indices; empty when the session/seed is invalid.
+ * @param {number} id
+ * @param {number} seed_triangle
+ * @param {number} max_angle_deg
+ * @returns {Uint32Array}
+ */
+export function sculpt_session_face_group(id: number, seed_triangle: number, max_angle_deg: number): Uint32Array;
+/**
+ * Session stats: `[vertexCount, triangleCount, averageEdgeLength, undoDepth,
+ * redoDepth]`; empty if the session does not exist.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function sculpt_session_info(id: number): Float64Array;
+/**
+ * Fill the sculpt mask with one value (0 clears). Undoable; returns the
+ * render patch (stride 8) of changed vertices.
+ * @param {number} id
+ * @param {number} value
+ * @returns {Float32Array}
+ */
+export function sculpt_session_mask_fill(id: number, value: number): Float32Array;
+/**
+ * Invert the sculpt mask. Undoable; returns the render patch (stride 8).
+ * @param {number} id
+ * @returns {Float32Array}
+ */
+export function sculpt_session_mask_invert(id: number): Float32Array;
+/**
+ * Current mesh as a standard f64 buffer (for committing back to a document).
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function sculpt_session_mesh_buffer(id: number): Float64Array;
+/**
+ * Raycast the CURRENT (deforming) surface. Returns
+ * `[px,py,pz, nx,ny,nz, distance, triangleIndex]` or empty on miss.
+ * @param {number} id
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @returns {Float64Array}
+ */
+export function sculpt_session_raycast(id: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number): Float64Array;
+/**
+ * Redo the last undone stroke. Same contract as `sculpt_session_undo`.
+ * @param {number} id
+ * @returns {Float32Array}
+ */
+export function sculpt_session_redo(id: number): Float32Array;
+/**
+ * Release a sculpt session and free its memory.
+ * @param {number} id
+ */
+export function sculpt_session_release(id: number): void;
+/**
+ * Full render snapshot as f32:
+ * `[vertexCount, triangleCount, positions..., normals..., mask..., indices...]`.
+ * @param {number} id
+ * @returns {Float32Array}
+ */
+export function sculpt_session_render_data(id: number): Float32Array;
+/**
+ * Uniform 1:4 shape-preserving subdivision (adds sculptable detail).
+ * Clears session undo history. Returns 1 on success, 0 when refused
+ * (session missing or the result would exceed the safety cap). Callers must
+ * refetch `sculpt_session_render_data` afterwards.
+ * @param {number} id
+ * @returns {number}
+ */
+export function sculpt_session_subdivide(id: number): number;
+/**
+ * Locally refine the given triangles 1:4 with crack-free conforming
+ * neighbor splits (red-green refinement). Returns 1 on success, 0 when
+ * refused (bad input or safety cap). Clears session undo history; callers
+ * must refetch `sculpt_session_render_data` afterwards.
+ * @param {number} id
+ * @param {Uint32Array} triangles
+ * @returns {number}
+ */
+export function sculpt_session_subdivide_faces(id: number, triangles: Uint32Array): number;
+/**
+ * Undo the last stroke. Returns the render patch restoring the previous
+ * positions; empty when there is nothing to undo.
+ * @param {number} id
+ * @returns {Float32Array}
+ */
+export function sculpt_session_undo(id: number): Float32Array;
+/**
+ * Sweep a profile curve along a path curve using exact curve evaluation.
+ * profile_data/path_data: encoded curve (see decode_curve)
+ * Returns mesh buffers.
+ * @param {Float64Array} profile_data
+ * @param {Float64Array} path_data
+ * @param {number} profile_segments
+ * @param {number} path_segments
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function sweep_curves(profile_data: Float64Array, path_data: Float64Array, profile_segments: number, path_segments: number, with_caps: boolean): Float64Array;
+/**
+ * Sweep a profile polyline along a path polyline.
+ * profile_coords: flat [x,y,z,...] for profile curve
+ * path_coords: flat [x,y,z,...] for path curve
+ * with_caps: whether to close the ends
+ * Returns mesh buffers.
+ * @param {Float64Array} profile_coords
+ * @param {Float64Array} path_coords
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function sweep_polylines(profile_coords: Float64Array, path_coords: Float64Array, with_caps: boolean): Float64Array;
+/**
+ * Tessellate a NURBS surface to a mesh buffer.
+ * Input format: [degree_u, degree_v, num_u, num_v, ...control_points(flat)..., ...weights(flat)..., ...knots_u..., ...knots_v..., u_segs, v_segs]
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function tessellate_nurbs_surface(data: Float64Array): Float64Array;
+/**
+ * Simple test function to verify WASM is working
+ * @returns {string}
+ */
+export function test_wasm(): string;
+/**
+ * Thicken an open polycurve into a single closed loop.
+ * Input format: [segment_count, type, ...data, ...]
+ *   type 0 = Line: [sx,sy,sz, ex,ey,ez]
+ *   type 1 = Arc:  [cx,cy,cz, nx,ny,nz, radius, start_angle, end_angle]
+ * Output uses the same encoded segment format.
+ * @param {Float64Array} segment_data
+ * @param {number} distance
+ * @param {boolean} both_sides
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} join_style_code
+ * @returns {Float64Array}
+ */
+export function thicken_polycurve(segment_data: Float64Array, distance: number, both_sides: boolean, nx: number, ny: number, nz: number, join_style_code: number): Float64Array;
+/**
+ * Get version info
+ * @returns {string}
+ */
+export function version(): string;
+/**
+ * @param {number} receiver
+ */
+export function wbg_rayon_start_worker(receiver: number): void;
+export class wbg_rayon_PoolBuilder {
+    static __wrap(ptr: any): any;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+    build(): void;
+    /**
+     * @returns {number}
+     */
+    numThreads(): number;
+    /**
+     * @returns {number}
+     */
+    receiver(): number;
+}
+export function initSync(module: any, memory: any): any;
+declare function __wbg_init(module_or_path: any, memory: any): Promise<any>;
+export { __wbg_init as default };
+//# sourceMappingURL=wasm-bindings-threaded.d.ts.map