okgeometry-api 1.6.0 → 1.10.0

package/src/wasm-bindings.js

@@ -34,6 +34,314 @@ export function arc_point_at(cx, cy, cz, nx, ny, nz, radius, start_angle, end_an
     return v1;
 }
 
+/**
+ * Parametric BREP boolean: exact surface–surface intersection curves with
+ * trimmed-surface output. Both operands must be closed solids.
+ * 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, b_json, op, tolerance) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_boolean_op(ptr0, len0, ptr1, len1, ptr2, len2, tolerance);
+        deferred4_0 = ret[0];
+        deferred4_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * 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, tolerance) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_edges(ptr0, len0, tolerance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, dx, dy, dz, height) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_extrude_curve(ptr0, len0, dx, dy, dz, height);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * 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, face_index, t, u_dir) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_face_iso_curve(ptr0, len0, face_index, t, u_dir);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Geometric backing of a face.
+ * Returns [0, ox,oy,oz, ux,uy,uz, vx,vy,vz] for planes,
+ * or [1, surface_data...] for NURBS faces.
+ * @param {string} json
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function brep_face_surface(json, face_index) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_face_surface(ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Tessellate a single BREP face. Returns the standard mesh buffer.
+ * @param {string} json
+ * @param {number} face_index
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function brep_face_tessellate(json, face_index, tolerance) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_face_tessellate(ptr0, len0, face_index, tolerance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * BREP structure summary: [face_count, edge_count, vertex_count, is_closed].
+ * @param {string} json
+ * @returns {Float64Array}
+ */
+export function brep_info(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_info(ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_loft_curves(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * 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, params) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_primitive(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * 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, ox, oy, oz, ax, ay, az, angle) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_revolve_curve(ptr0, len0, ox, oy, oz, ax, ay, az, angle);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Untrimmed sheet BREP from a NURBS surface. Returns JSON.
+ * @param {Float64Array} surface_data
+ * @returns {string}
+ */
+export function brep_sheet_from_surface(surface_data) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(surface_data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_sheet_from_surface(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * 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, tolerance) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_tessellate(ptr0, len0, tolerance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Apply a row-major 4x4 matrix to a BREP. Returns transformed JSON.
+ * @param {string} json
+ * @param {Float64Array} matrix
+ * @returns {string}
+ */
+export function brep_transform(json, matrix) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(matrix, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_transform(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * 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, tolerance) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_validate(ptr0, len0, tolerance);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Volume and surface area from tessellation: [volume, area].
+ * @param {string} json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function brep_volume_area(json, tolerance) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_volume_area(ptr0, len0, tolerance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Build a NURBS curve from raw control points with kernel-managed knots and weights.
  *
@@ -1231,6 +1539,31 @@ export function mesh_chamfer_all_edges(mesh_type, params, offset) {
     return v3;
 }
 
+/**
+ * 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, buffer, points, closed) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_clip_polyline(vertex_count, ptr0, len0, ptr1, len1, closed);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Compute planar curve normal from ordered points.
  * @param {Float64Array} coords
@@ -1939,6 +2272,32 @@ export function mesh_scale(vertex_count, buffer, sx, sy, sz) {
     return v2;
 }
 
+/**
+ * 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, buffer_a, vertex_count_b, buffer_b, operation) {
+    const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_solid_split_by_surface(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2);
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
 /**
  * @param {number} vertex_count
  * @param {Float64Array} buffer
@@ -2121,6 +2480,74 @@ export function nurbs_curve_plane_intersect(data, nx, ny, nz, d) {
     return v2;
 }
 
+/**
+ * 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, x, y, z) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_closest_point(ptr0, len0, x, y, z);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, u, v) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_curvature(ptr0, len0, u, v);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, u, v) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_derivatives(ptr0, len0, u, v);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, u_dir, t) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_elevate_degree(ptr0, len0, u_dir, t);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Evaluate a NURBS surface at normalized parameters (u, v) in [0,1].
  * Returns [x, y, z]
@@ -2138,6 +2565,77 @@ export function nurbs_surface_evaluate(data, u, v) {
     return v2;
 }
 
+/**
+ * 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, u0, u1, v0, v1) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_extract_region(ptr0, len0, u0, u1, v0, v1);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, dx, dy, dz) {
+    const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_extrude(ptr0, len0, dx, dy, dz);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, u_dir, t, times) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_insert_knot(ptr0, len0, u_dir, t, times);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, t, u_dir) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_iso_curve(ptr0, len0, t, u_dir);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Evaluate a NURBS surface unit normal at normalized parameters (u, v) in [0,1].
  * Returns [x, y, z]
@@ -2176,6 +2674,81 @@ export function nurbs_surface_plane_intersect(surface_data, nx, ny, nz, d, tess)
     return v2;
 }
 
+/**
+ * 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, params) {
+    const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_primitive(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * 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, ox, oy, oz, ax, ay, az, angle) {
+    const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_revolve(ptr0, len0, ox, oy, oz, ax, ay, az, angle);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, curve_b) {
+    const ptr0 = passArrayF64ToWasm0(curve_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(curve_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_ruled(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * 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, u_dir, t) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_split(ptr0, len0, u_dir, t);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Intersect two NURBS surfaces.
  * Returns polyline buffer.
@@ -2195,6 +2768,44 @@ export function nurbs_surface_surface_intersect(data_a, data_b, tess) {
     return v3;
 }
 
+/**
+ * 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, tolerance, max_segments_per_span) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_tessellate_adaptive(ptr0, len0, tolerance, max_segments_per_span);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, tolerance, max_segments_per_span, crease_angle_deg) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_tessellate_render(ptr0, len0, tolerance, max_segments_per_span, crease_angle_deg);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
 /**
  * Offset a polycurve made of line and arc segments.
  * Input format: [segment_count, type, ...data, ...]