okgeometry-api 1.2.0 → 1.4.0

package/src/wasm-bindings.d.ts

@@ -12,6 +12,21 @@ export function arc_length(radius: number, start_angle: number, end_angle: numbe
  */
 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;
 
+/**
+ * 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.
+ */
+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.
@@ -145,6 +160,23 @@ export function loft_nurbs_surface(data: Float64Array): 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)
+ */
+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..., ...]
@@ -249,6 +281,19 @@ export function mesh_boundary_polylines(vertex_count: number, buffer: Float64Arr
  */
 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.
+ */
+export function mesh_build_render_buffers(vertex_count: number, buffer: Float64Array, crease_angle_deg: number): Float32Array;
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -378,6 +423,15 @@ export function mesh_get_face_centroid(vertex_count: number, buffer: Float64Arra
  */
 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.
+ */
+export function mesh_get_smooth_face_group(vertex_count: number, buffer: Float64Array, face_index: number, max_angle_deg: number): Float64Array;
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -424,6 +478,13 @@ export function mesh_mesh_intersect(va_count: number, buffer_a: Float64Array, vb
  */
 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.
+ */
+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
@@ -508,12 +569,17 @@ export function nurbs_curve_curve_intersect(data_a: Float64Array, data_b: Float6
 export function nurbs_curve_plane_intersect(data: Float64Array, nx: number, ny: number, nz: number, d: number): Float64Array;
 
 /**
- * Evaluate a NURBS surface at (u, v) parameters.
- * Input format: same as tessellate but last 2 values are u, v instead of u_segs, v_segs
+ * Evaluate a NURBS surface at normalized parameters (u, v) in [0,1].
  * Returns [x, y, z]
  */
 export function nurbs_surface_evaluate(data: Float64Array, u: number, v: number): Float64Array;
 
+/**
+ * Evaluate a NURBS surface unit normal at normalized parameters (u, v) in [0,1].
+ * Returns [x, y, z]
+ */
+export function nurbs_surface_normal(data: Float64Array, u: number, v: number): Float64Array;
+
 /**
  * Intersect a NURBS surface with a plane.
  * Input: same surface format as tessellate_nurbs_surface, then plane (nx,ny,nz,d) appended.
@@ -527,6 +593,21 @@ export function nurbs_surface_plane_intersect(surface_data: Float64Array, nx: nu
  */
 export function nurbs_surface_surface_intersect(data_a: Float64Array, data_b: Float64Array, tess: number): Float64Array;
 
+/**
+ * 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.
+ */
+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..., ...]
+ */
+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.
@@ -617,6 +698,15 @@ export function tessellate_nurbs_surface(data: Float64Array): Float64Array;
  */
 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.
+ */
+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
  */
@@ -628,6 +718,7 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly arc_length: (a: number, b: number, c: number) => number;
     readonly arc_point_at: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly build_nurbs_curve: (a: number, b: number, c: number, d: number) => [number, number];
     readonly chamfer_polycurve: (a: number, b: number, c: number) => [number, number];
     readonly circle_length: (a: number) => number;
     readonly circle_point_at: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
@@ -648,6 +739,7 @@ export interface InitOutput {
     readonly loft_circles: (a: number, b: number, c: number, d: number) => [number, number];
     readonly loft_nurbs_surface: (a: number, b: number) => [number, number];
     readonly loft_polylines: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly loft_profiles: (a: number, b: number, c: number, d: number) => [number, number];
     readonly make_nurbs_curves_compatible: (a: number, b: number) => [number, number];
     readonly mesh_apply_matrix: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_boolean_intersection: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
@@ -676,6 +768,7 @@ export interface InitOutput {
     readonly mesh_boolean_union: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_boundary_polylines: (a: number, b: number, c: number) => [number, number];
     readonly mesh_build_coplanar_connected_face_groups: (a: number, b: number, c: number) => [number, number];
+    readonly mesh_build_render_buffers: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_chamfer_all_edges: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_compute_planar_curve_normal: (a: number, b: number, c: number) => [number, number];
     readonly mesh_contains_point: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
@@ -698,6 +791,7 @@ export interface InitOutput {
     readonly mesh_get_face_area: (a: number, b: number, c: number, d: number) => number;
     readonly mesh_get_face_centroid: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_get_face_normal: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly mesh_get_smooth_face_group: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_get_stats: (a: number, b: number, c: number) => [number, number];
     readonly mesh_import_obj: (a: number, b: number) => [number, number];
     readonly mesh_is_closed_volume: (a: number, b: number, c: number) => number;
@@ -707,6 +801,7 @@ export interface InitOutput {
     readonly mesh_merge: (a: number, b: number) => [number, number];
     readonly mesh_mesh_intersect: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_patch_from_points: (a: number, b: number) => [number, number];
+    readonly mesh_planar_face_evaluate: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_plane_intersect: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly mesh_prepare_boolean_cutter_curve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly mesh_raycast: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
@@ -723,8 +818,11 @@ export interface InitOutput {
     readonly nurbs_curve_curve_intersect: (a: number, b: number, c: number, d: number) => [number, number];
     readonly nurbs_curve_plane_intersect: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly nurbs_surface_evaluate: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly nurbs_surface_normal: (a: number, b: number, c: number, d: number) => [number, number];
     readonly nurbs_surface_plane_intersect: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly nurbs_surface_surface_intersect: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly offset_polycurve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly offset_polycurve_all: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly offset_polyline_curve: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly polycurve_to_nurbs: (a: number, b: number) => [number, number];
     readonly polyline_length: (a: number, b: number) => number;
@@ -737,6 +835,7 @@ export interface InitOutput {
     readonly sweep_polylines: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly tessellate_nurbs_surface: (a: number, b: number) => [number, number];
     readonly test_wasm: () => [number, number];
+    readonly thicken_polycurve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly version: () => [number, number];
     readonly ray_distance_to_point: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;

package/src/wasm-bindings.js

@@ -34,6 +34,32 @@ export function arc_point_at(cx, cy, cz, nx, ny, nz, radius, start_angle, end_an
     return v1;
 }
 
+/**
+ * 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, coords, closed) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.build_nurbs_curve(degree, ptr0, len0, closed);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Chamfer corners of a polyline by cutting each corner with a straight segment.
  * Input: flat coords [x1,y1,z1, ...], distance from corner to cut.
@@ -415,6 +441,34 @@ export function loft_polylines(polyline_data, _segments, with_caps) {
     return v2;
 }
 
+/**
+ * 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, closed, with_caps) {
+    const ptr0 = passArrayF64ToWasm0(profile_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.loft_profiles(ptr0, len0, closed, with_caps);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Make multiple NURBS curves compatible (same knot vectors, same CP count).
  * Input: [curve_count, curve1_data..., curve2_data..., ...]
@@ -1084,6 +1138,30 @@ export function mesh_build_coplanar_connected_face_groups(vertex_count, buffer)
     return v2;
 }
 
+/**
+ * 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, buffer, crease_angle_deg) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_build_render_buffers(vertex_count, ptr0, len0, crease_angle_deg);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -1469,6 +1547,27 @@ export function mesh_get_face_normal(vertex_count, buffer, face_index) {
     return v2;
 }
 
+/**
+ * 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, buffer, face_index, max_angle_deg) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_smooth_face_group(vertex_count, ptr0, len0, face_index, max_angle_deg);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -1629,6 +1728,26 @@ export function mesh_patch_from_points(coords) {
     return v2;
 }
 
+/**
+ * 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, buffer, face_index, u, v) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_planar_face_evaluate(vertex_count, ptr0, len0, face_index, u, v);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Intersect a mesh with a plane, returning polyline points.
  * Input: vertex_count, mesh_buffer..., nx, ny, nz, d
@@ -1933,8 +2052,7 @@ export function nurbs_curve_plane_intersect(data, nx, ny, nz, d) {
 }
 
 /**
- * Evaluate a NURBS surface at (u, v) parameters.
- * Input format: same as tessellate but last 2 values are u, v instead of u_segs, v_segs
+ * Evaluate a NURBS surface at normalized parameters (u, v) in [0,1].
  * Returns [x, y, z]
  * @param {Float64Array} data
  * @param {number} u
@@ -1950,6 +2068,23 @@ export function nurbs_surface_evaluate(data, u, v) {
     return v2;
 }
 
+/**
+ * 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, u, v) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_normal(ptr0, len0, u, v);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Intersect a NURBS surface with a plane.
  * Input: same surface format as tessellate_nurbs_surface, then plane (nx,ny,nz,d) appended.
@@ -1990,6 +2125,49 @@ export function nurbs_surface_surface_intersect(data_a, data_b, tess) {
     return v3;
 }
 
+/**
+ * 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, distance, nx, ny, nz, join_style_code) {
+    const ptr0 = passArrayF64ToWasm0(segment_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.offset_polycurve(ptr0, len0, distance, nx, ny, nz, join_style_code);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * 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, distance, nx, ny, nz, join_style_code) {
+    const ptr0 = passArrayF64ToWasm0(segment_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.offset_polycurve_all(ptr0, len0, distance, nx, ny, nz, join_style_code);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Offset a polyline by a distance in a given plane.
  * If nx=ny=nz=0, the plane normal is auto-detected.
@@ -2232,6 +2410,30 @@ export function test_wasm() {
     }
 }
 
+/**
+ * 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, distance, both_sides, nx, ny, nz, join_style_code) {
+    const ptr0 = passArrayF64ToWasm0(segment_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.thicken_polycurve(ptr0, len0, distance, both_sides, nx, ny, nz, join_style_code);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Get version info
  * @returns {string}
@@ -2283,11 +2485,24 @@ function __wbg_get_imports() {
     };
 }
 
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayF64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
 let cachedFloat64ArrayMemory0 = null;
 function getFloat64ArrayMemory0() {
     if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
@@ -2386,6 +2601,7 @@ let wasmModule, wasm;
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     wasmModule = module;
+    cachedFloat32ArrayMemory0 = null;
     cachedFloat64ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();