brepkit-wasm 0.1.0

package/brepkit_wasm.d.ts

@@ -0,0 +1,1210 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * The B-Rep modeling kernel.
+ *
+ * Owns all topological state. JavaScript holds this reference and
+ * invokes methods to create, transform, and query geometry.
+ */
+export class BrepKernel {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add hole wires to an existing face, creating a new face with the same
+     * surface but additional inner wires.
+     *
+     * Returns a new face handle (`u32`).
+     */
+    addHolesToFace(face: number, hole_wire_handles: Uint32Array): number;
+    /**
+     * Get faces adjacent to a given face within a solid.
+     *
+     * Returns an array of face handles.
+     */
+    adjacentFaces(solid: number, face: number): Uint32Array;
+    /**
+     * Approximate a curve through points (least-squares).
+     *
+     * Returns an edge handle.
+     */
+    approximateCurve(coords: Float64Array, degree: number, num_control_points: number): number;
+    /**
+     * Approximate a curve through points using LSPIA (progressive iteration).
+     *
+     * Returns an edge handle.
+     */
+    approximateCurveLspia(coords: Float64Array, degree: number, num_control_points: number, tolerance: number, max_iterations: number): number;
+    /**
+     * Approximate a grid of points into a NURBS surface using LSPIA.
+     *
+     * Returns a face handle.
+     */
+    approximateSurfaceLspia(coords: Float64Array, rows: number, cols: number, degree_u: number, degree_v: number, num_cps_u: number, num_cps_v: number, tolerance: number, max_iterations: number): number;
+    /**
+     * Add a child component to a parent in an assembly.
+     *
+     * Returns the component ID.
+     */
+    assemblyAddChild(assembly: number, parent: number, name: string, solid: number, matrix: Float64Array): number;
+    /**
+     * Add a root component to an assembly.
+     *
+     * Returns the component ID.
+     */
+    assemblyAddRoot(assembly: number, name: string, solid: number, matrix: Float64Array): number;
+    /**
+     * Get the bill of materials for an assembly.
+     *
+     * Returns a JSON string: `[{"name": "...", "solidIndex": n, "instanceCount": n}, ...]`.
+     */
+    assemblyBom(assembly: number): string;
+    /**
+     * Flatten an assembly into `[(solid, matrix), ...]`.
+     *
+     * Returns a JSON string: `[{"solid": u32, "matrix": [16 floats]}, ...]`.
+     */
+    assemblyFlatten(assembly: number): string;
+    /**
+     * Create a new empty assembly. Returns an assembly index.
+     */
+    assemblyNew(name: string): number;
+    /**
+     * Compute the axis-aligned bounding box of a solid.
+     *
+     * Returns `[min_x, min_y, min_z, max_x, max_y, max_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or has no vertices.
+     */
+    boundingBox(solid: number): Float64Array;
+    /**
+     * Compute the center of mass of a solid (uniform density).
+     *
+     * Returns `[x, y, z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid has zero volume or tessellation fails.
+     */
+    centerOfMass(solid: number, deflection: number): Float64Array;
+    /**
+     * Chamfer edges of a solid.
+     *
+     * `edge_handles` is an array of edge handles. Returns a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if distance is non-positive or edges are invalid.
+     */
+    chamfer(solid: number, edge_handles: Uint32Array, distance: number): number;
+    /**
+     * Create a circular pattern of a solid around an axis.
+     *
+     * Returns a compound handle.
+     */
+    circularPattern(solid: number, ax: number, ay: number, az: number, count: number): number;
+    /**
+     * Classify a point relative to a solid: inside, outside, or on boundary.
+     *
+     * Returns `"inside"`, `"outside"`, or `"boundary"`.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    classifyPoint(solid: number, x: number, y: number, z: number, tolerance: number): string;
+    /**
+     * Classify a point using robust dual-method (winding + ray casting).
+     *
+     * Returns "inside", "outside", or "boundary".
+     */
+    classifyPointRobust(solid: number, x: number, y: number, z: number, tolerance: number): string;
+    /**
+     * Classify a point relative to a solid using generalized winding numbers.
+     *
+     * Returns "inside", "outside", or "boundary".
+     */
+    classifyPointWinding(solid: number, x: number, y: number, z: number, tolerance: number): string;
+    /**
+     * Build a convex hull solid from a point cloud.
+     *
+     * Uses a simple Quickhull-inspired algorithm for 3D point sets.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if fewer than 4 points are provided.
+     */
+    convexHull(coords: Float64Array): number;
+    /**
+     * Copy a solid and apply a 4×4 row-major affine transform in one pass.
+     *
+     * Equivalent to `copySolid` + `transformSolid` but performs both in a
+     * single topology traversal, avoiding redundant NURBS clones.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid, the matrix doesn't
+     * have 16 elements, or the matrix is singular.
+     */
+    copyAndTransformSolid(solid: number, matrix: Float64Array): number;
+    /**
+     * Deep copy a solid, returning a new independent solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    copySolid(solid: number): number;
+    /**
+     * Elevate the degree of an edge's NURBS curve.
+     *
+     * Returns a new edge handle.
+     */
+    curveDegreeElevate(edge: number, elevate_by: number): number;
+    /**
+     * Insert a knot into an edge's NURBS curve.
+     *
+     * Returns a new edge handle with the refined curve.
+     */
+    curveKnotInsert(edge: number, knot: number, times: number): number;
+    /**
+     * Remove a knot from an edge's NURBS curve.
+     *
+     * Returns a new edge handle with the simplified curve.
+     */
+    curveKnotRemove(edge: number, knot: number, tolerance: number): number;
+    /**
+     * Split an edge's NURBS curve at a parameter value.
+     *
+     * Returns two edge handles as `[u32; 2]`.
+     */
+    curveSplit(edge: number, u: number): Uint32Array;
+    /**
+     * Cut (subtract) solid `b` from solid `a`.
+     *
+     * Returns a new solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid or the operation
+     * produces an empty or non-manifold result.
+     */
+    cut(a: number, b: number): number;
+    /**
+     * Remove specified faces from a solid (defeaturing).
+     *
+     * `face_handles` is an array of face handles to remove.
+     * Returns a new solid handle.
+     */
+    defeature(solid: number, face_handles: Uint32Array): number;
+    /**
+     * Detect small features (faces below an area threshold).
+     *
+     * Returns an array of face handles.
+     */
+    detectSmallFeatures(solid: number, area_threshold: number, deflection: number): Uint32Array;
+    /**
+     * Apply draft angle to faces of a solid.
+     *
+     * `face_handles` is an array of face handles to draft.
+     * Returns a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if angle is zero or faces are invalid.
+     */
+    draft(solid: number, face_handles: Uint32Array, pull_x: number, pull_y: number, pull_z: number, neutral_x: number, neutral_y: number, neutral_z: number, angle_degrees: number): number;
+    /**
+     * Compute the length of an edge.
+     *
+     * # Errors
+     *
+     * Returns an error if the edge handle is invalid.
+     */
+    edgeLength(edge: number): number;
+    /**
+     * Get the edge-to-face adjacency map for a solid.
+     *
+     * Returns a JSON string: `{"edgeId": [faceId, ...], ...}`.
+     */
+    edgeToFaceMap(solid: number): string;
+    /**
+     * Evaluate a point on an edge curve at parameter `t`.
+     *
+     * Returns `[x, y, z]`.
+     */
+    evaluateEdgeCurve(edge: number, t: number): Float64Array;
+    /**
+     * Evaluate a point and tangent on an edge curve at parameter `t`.
+     *
+     * Returns `[px, py, pz, tx, ty, tz]`.
+     */
+    evaluateEdgeCurveD1(edge: number, t: number): Float64Array;
+    /**
+     * Evaluate a point on a face surface at (u, v).
+     *
+     * Returns `[x, y, z]`.
+     */
+    evaluateSurface(face: number, u: number, v: number): Float64Array;
+    /**
+     * Evaluate a surface normal at (u, v) on a face.
+     *
+     * Returns `[nx, ny, nz]`.
+     */
+    evaluateSurfaceNormal(face: number, u: number, v: number): Float64Array;
+    /**
+     * Execute a batch of operations, crossing the JS/WASM boundary once.
+     *
+     * Accepts a JSON string containing an array of operation objects:
+     * ```json
+     * [
+     *   {"op": "makeBox", "args": {"width": 2.0, "height": 2.0, "depth": 2.0}},
+     *   {"op": "fuse", "args": {"solidA": 0, "solidB": 1}},
+     *   {"op": "volume", "args": {"solid": 2, "deflection": 0.1}}
+     * ]
+     * ```
+     *
+     * Returns a JSON string with an array of results:
+     * ```json
+     * [
+     *   {"ok": 0},
+     *   {"ok": 2},
+     *   {"error": "invalid solid id"}
+     * ]
+     * ```
+     *
+     * Operations are executed sequentially; an error in one does not
+     * prevent execution of subsequent operations.
+     */
+    executeBatch(json: string): string;
+    /**
+     * Export a solid to 3MF format (ZIP archive as bytes).
+     *
+     * Returns a `Uint8Array` in JavaScript containing the `.3mf` file.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or export fails.
+     */
+    export3mf(solid: number, deflection: number): Uint8Array;
+    /**
+     * Export a solid to glTF binary (.glb) format.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    exportGlb(solid: number, deflection: number): Uint8Array;
+    /**
+     * Export a solid to IGES format.
+     *
+     * Returns the IGES file as a UTF-8 encoded byte vector.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or export fails.
+     */
+    exportIges(solid: number): Uint8Array;
+    /**
+     * Export a solid to OBJ format (UTF-8 string as bytes).
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    exportObj(solid: number, deflection: number): Uint8Array;
+    /**
+     * Export a solid to PLY format (binary little-endian).
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    exportPly(solid: number, deflection: number): Uint8Array;
+    /**
+     * Export a solid to STEP AP203 format.
+     *
+     * Returns the STEP file as a UTF-8 encoded byte vector.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or export fails.
+     */
+    exportStep(solid: number): Uint8Array;
+    /**
+     * Export a solid to binary STL format.
+     *
+     * Returns a `Uint8Array` containing the `.stl` file.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or export fails.
+     */
+    exportStl(solid: number, deflection: number): Uint8Array;
+    /**
+     * Extrude a planar face along a direction vector to create a solid.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid or the extrusion fails.
+     */
+    extrude(face: number, dir_x: number, dir_y: number, dir_z: number, distance: number): number;
+    /**
+     * Compute the area of a single face.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid or tessellation fails.
+     */
+    faceArea(face: number, deflection: number): number;
+    /**
+     * Compute the perimeter of a face.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid.
+     */
+    facePerimeter(face: number): number;
+    /**
+     * Get the wires (outer + inner) of a face.
+     *
+     * Returns an array of wire handles.
+     */
+    faceWires(face: number): Uint32Array;
+    /**
+     * Fill a 4-sided boundary with a Coons patch surface.
+     *
+     * `boundary_coords` is flat `[x,y,z, ...]` for all 4 curves concatenated.
+     * `curve_lengths` is `[n0, n1, n2, n3]` — number of points per curve.
+     * Returns a face handle.
+     */
+    fillCoonsPatch(boundary_coords: Float64Array, curve_lengths: Uint32Array): number;
+    /**
+     * Fillet (round) edges of a solid.
+     *
+     * `edge_handles` is an array of edge handles. Returns a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if radius is non-positive or edges are invalid.
+     */
+    fillet(solid: number, edge_handles: Uint32Array, radius: number): number;
+    /**
+     * Apply variable-radius fillets to edges.
+     *
+     * `json` is a JSON string: `[{"edge": u32, "law": "constant"|"linear"|"scurve", "start": f64, "end": f64}]`
+     * Returns a new solid handle.
+     */
+    filletVariable(solid: number, json: string): number;
+    /**
+     * Fix face orientations to ensure consistent outward normals.
+     *
+     * Returns the number of faces fixed.
+     */
+    fixFaceOrientations(solid: number): number;
+    /**
+     * Fuse (union) two solids into one.
+     *
+     * Returns a new solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid or the operation
+     * produces an empty or non-manifold result.
+     */
+    fuse(a: number, b: number): number;
+    /**
+     * Get analytic surface parameters for a face.
+     *
+     * Returns a JSON string with type-dependent fields.
+     */
+    getAnalyticSurfaceParams(face: number): string;
+    /**
+     * Get the parameter domain of an edge curve.
+     *
+     * Returns `[t_start, t_end]`.
+     * For line edges: `[0.0, length]`.
+     * For NURBS edges: knot domain.
+     */
+    getEdgeCurveParameters(edge: number): Float64Array;
+    /**
+     * Get the curve type of an edge.
+     *
+     * Returns `"line"` or `"bspline"`.
+     */
+    getEdgeCurveType(edge: number): string;
+    /**
+     * Build an edge's NURBS curve data for JS consumption.
+     *
+     * Returns `null` for line edges, or a JSON string with
+     * `{degree, knots, controlPoints, weights}` for NURBS edges.
+     */
+    getEdgeNurbsData(edge: number): any;
+    /**
+     * Get the vertex positions of an edge.
+     *
+     * Returns `[start_x, start_y, start_z, end_x, end_y, end_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the edge handle is invalid.
+     */
+    getEdgeVertices(edge: number): Float64Array;
+    /**
+     * Get entity counts of a solid: `[faces, edges, vertices]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    getEntityCounts(solid: number): Uint32Array;
+    /**
+     * Get the edge handles of a face.
+     *
+     * Returns an array of edge handles (`u32[]`).
+     */
+    getFaceEdges(face: number): Uint32Array;
+    /**
+     * Get the face normal of a planar face.
+     *
+     * Returns `[nx, ny, nz]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the face is invalid or NURBS.
+     */
+    getFaceNormal(face: number): Float64Array;
+    /**
+     * Get the outer wire handle of a face.
+     *
+     * Returns a wire handle (`u32`).
+     */
+    getFaceOuterWire(face: number): number;
+    /**
+     * Get the vertex handles of a face.
+     *
+     * Returns an array of vertex handles (`u32[]`).
+     */
+    getFaceVertices(face: number): Uint32Array;
+    /**
+     * Get all edge handles of a solid.
+     *
+     * Returns an array of unique edge handles (`u32[]`).
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    getSolidEdges(solid: number): Uint32Array;
+    /**
+     * Get all face handles of a solid.
+     *
+     * Returns an array of face handles (`u32[]`).
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    getSolidFaces(solid: number): Uint32Array;
+    /**
+     * Get all vertex handles of a solid.
+     *
+     * Returns an array of unique vertex handles (`u32[]`).
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    getSolidVertices(solid: number): Uint32Array;
+    /**
+     * Get the UV parameter domain of a face's surface.
+     *
+     * Returns `[u_min, u_max, v_min, v_max]`.
+     */
+    getSurfaceDomain(face: number): Float64Array;
+    /**
+     * Get the surface type of a face.
+     *
+     * Returns one of: `"plane"`, `"cylinder"`, `"cone"`, `"sphere"`,
+     * `"torus"`, `"bspline"`.
+     */
+    getSurfaceType(face: number): string;
+    /**
+     * Get the position of a vertex.
+     *
+     * Returns `[x, y, z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the vertex handle is invalid.
+     */
+    getVertexPosition(vertex: number): Float64Array;
+    /**
+     * Heal a solid topology.
+     *
+     * Returns the number of issues fixed.
+     */
+    healSolid(solid: number): number;
+    /**
+     * Create a helical sweep of a profile face.
+     *
+     * Sweeps the profile along a helix defined by axis, radius, pitch,
+     * and number of turns. Used for generating thread geometry.
+     *
+     * # Errors
+     *
+     * Returns an error if parameters are invalid or the sweep fails.
+     */
+    helicalSweep(profile: number, axis_origin_x: number, axis_origin_y: number, axis_origin_z: number, axis_dir_x: number, axis_dir_y: number, axis_dir_z: number, radius: number, pitch: number, turns: number): number;
+    /**
+     * Import a 3MF file and return solid handles.
+     *
+     * Returns handles for each object found in the 3MF archive.
+     *
+     * # Errors
+     *
+     * Returns an error if the 3MF data is malformed.
+     */
+    import3mf(data: Uint8Array): Uint32Array;
+    /**
+     * Import a GLB (glTF binary) file and return a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the file is malformed or mesh import fails.
+     */
+    importGlb(data: Uint8Array): number;
+    /**
+     * Import an IGES file and return solid handles.
+     *
+     * # Errors
+     *
+     * Returns an error if the IGES data is malformed.
+     */
+    importIges(data: Uint8Array): Uint32Array;
+    /**
+     * Import an OBJ file and return a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the file is malformed or mesh import fails.
+     */
+    importObj(data: Uint8Array): number;
+    /**
+     * Import a STEP file and return solid handles.
+     *
+     * Returns handles for each solid found in the STEP file.
+     *
+     * # Errors
+     *
+     * Returns an error if the STEP data is malformed.
+     */
+    importStep(data: Uint8Array): Uint32Array;
+    /**
+     * Import an STL file (binary or ASCII) and return a solid handle.
+     *
+     * The mesh triangles are converted to planar B-Rep faces with
+     * vertex merging.
+     *
+     * # Errors
+     *
+     * Returns an error if the STL data is malformed or empty.
+     */
+    importStl(data: Uint8Array): number;
+    /**
+     * Interpolate a NURBS curve through points and create an edge.
+     *
+     * Uses chord-length parameterization with the given degree.
+     * Returns an edge handle (`u32`).
+     */
+    interpolatePoints(coords: Float64Array, degree: number): number;
+    /**
+     * Interpolate a grid of points into a NURBS surface.
+     *
+     * `coords` is a flat array `[x,y,z, ...]` of `rows * cols` points.
+     * Returns a face handle.
+     */
+    interpolateSurface(coords: Float64Array, rows: number, cols: number, degree_u: number, degree_v: number): number;
+    /**
+     * Intersect two solids, keeping only their common volume.
+     *
+     * Returns a new solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid or the operation
+     * produces an empty result.
+     */
+    intersect(a: number, b: number): number;
+    /**
+     * Check if an edge is forward-oriented in a given wire.
+     *
+     * Returns `true` if the edge is forward in the wire, `false` if reversed.
+     */
+    isEdgeForwardInWire(edge: number, wire: number): boolean;
+    /**
+     * Create a linear pattern of a solid.
+     *
+     * Returns a compound handle containing all copies.
+     *
+     * # Errors
+     *
+     * Returns an error if inputs are invalid.
+     */
+    linearPattern(solid: number, dx: number, dy: number, dz: number, spacing: number, count: number): number;
+    /**
+     * Loft two or more profile faces into a solid.
+     *
+     * Takes an array of face handles. Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if fewer than 2 faces or profiles have
+     * different vertex counts.
+     */
+    loft(faces: Uint32Array): number;
+    /**
+     * Create a box solid with the given dimensions, centered at the origin.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if any dimension is non-positive or non-finite.
+     */
+    makeBox(dx: number, dy: number, dz: number): number;
+    /**
+     * Create a circular polygon approximation on the XY plane.
+     *
+     * The circle is centered at the origin with the given `radius`,
+     * approximated by `segments` straight edges.
+     * Returns a face handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if fewer than 3 segments are specified.
+     */
+    makeCircle(radius: number, segments: number): number;
+    /**
+     * Create a circular face on the XY plane (using NURBS arcs).
+     *
+     * Returns a face handle.
+     */
+    makeCircleFace(radius: number, segments: number): number;
+    /**
+     * Create a compound from multiple solid handles.
+     *
+     * Returns a compound handle (stored as `u32`).
+     */
+    makeCompound(solid_handles: Uint32Array): number;
+    /**
+     * Create a cone or frustum solid centered at the origin, axis along +Z.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if height is non-positive or both radii are zero.
+     */
+    makeCone(bottom_radius: number, top_radius: number, height: number): number;
+    /**
+     * Create a cylinder solid centered at the origin, axis along +Z.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if radius or height is non-positive.
+     */
+    makeCylinder(radius: number, height: number): number;
+    /**
+     * Create a planar face from a wire (computes normal from first 3 vertices).
+     *
+     * Returns a face handle (`u32`).
+     */
+    makeFaceFromWire(wire: number): number;
+    /**
+     * Create a straight-line edge between two points.
+     *
+     * Returns an edge handle (`u32`).
+     */
+    makeLineEdge(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
+    /**
+     * Create a NURBS curve edge.
+     *
+     * Returns an edge handle (`u32`).
+     */
+    makeNurbsEdge(start_x: number, start_y: number, start_z: number, end_x: number, end_y: number, end_z: number, degree: number, knots: Float64Array, control_points: Float64Array, weights: Float64Array): number;
+    /**
+     * Create a polygonal face from flat coordinate triples `[x,y,z, ...]`.
+     *
+     * Requires at least 3 points (9 `f64` values).
+     * Returns a face handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if `coords` length is not a multiple of 3,
+     * fewer than 3 points are provided, or the face normal is degenerate.
+     */
+    makePolygon(coords: Float64Array): number;
+    /**
+     * Create a closed polygon wire from flat coordinates.
+     *
+     * Returns a wire handle.
+     */
+    makePolygonWire(coords: Float64Array): number;
+    /**
+     * Create a rectangular face on the XY plane centered at the origin.
+     *
+     * Returns a face handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if `width` or `height` is non-positive, NaN,
+     * or infinite, or if the face geometry cannot be constructed.
+     */
+    makeRectangle(width: number, height: number): number;
+    /**
+     * Create a regular polygon wire on the XY plane.
+     *
+     * Returns a wire handle.
+     */
+    makeRegularPolygonWire(radius: number, n_sides: number): number;
+    /**
+     * Create a sphere solid centered at the origin.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if radius is non-positive or segments < 4.
+     */
+    makeSphere(radius: number, segments: number): number;
+    /**
+     * Create a torus solid centered at the origin in the XY plane.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if radii are non-positive or minor >= major.
+     */
+    makeTorus(major_radius: number, minor_radius: number, segments: number): number;
+    /**
+     * Create a vertex at the given position.
+     *
+     * Returns a vertex handle (`u32`).
+     */
+    makeVertex(x: number, y: number, z: number): number;
+    /**
+     * Create a closed wire from an ordered array of edge handles.
+     *
+     * Returns a wire handle (`u32`).
+     */
+    makeWire(edge_handles: Uint32Array, closed: boolean): number;
+    /**
+     * Merge coincident vertices in a solid.
+     *
+     * Returns the number of vertices merged.
+     */
+    mergeCoincidentVertices(solid: number, tolerance: number): number;
+    /**
+     * Perform a mesh boolean on raw triangle data.
+     *
+     * Returns a `JsMesh` with the result.
+     */
+    meshBoolean(positions_a: Float64Array, indices_a: Uint32Array, positions_b: Float64Array, indices_b: Uint32Array, op: string, tolerance: number): JsMesh;
+    /**
+     * Mirror a solid across a plane.
+     *
+     * Returns a new solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or the normal is zero.
+     */
+    mirror(solid: number, px: number, py: number, pz: number, nx: number, ny: number, nz: number): number;
+    /**
+     * Create a new, empty kernel.
+     */
+    constructor();
+    /**
+     * Offset a face by a distance along its surface normal.
+     *
+     * Returns the new offset face handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid or the operation fails.
+     */
+    offsetFace(face: number, distance: number, samples: number): number;
+    /**
+     * Offset a 2D polygon by a signed distance.
+     *
+     * `coords` is a flat array `[x,y, x,y, ...]` of 2D points.
+     * Returns a flat array of offset polygon coordinates.
+     */
+    offsetPolygon2d(coords: Float64Array, distance: number, tolerance: number): Float64Array;
+    /**
+     * Offset (shell) a solid by a distance.
+     *
+     * Returns a new solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the distance is zero or the solid is invalid.
+     */
+    offsetSolid(solid: number, distance: number): number;
+    /**
+     * Offset a wire on a planar face.
+     *
+     * Returns a new wire handle.
+     */
+    offsetWire(face: number, distance: number): number;
+    /**
+     * Pipe sweep: sweep a profile along a NURBS path (no guide).
+     *
+     * Returns a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the face or path is invalid.
+     */
+    pipe(face: number, path_degree: number, path_knots: Float64Array, path_control_points: Float64Array, path_weights: Float64Array): number;
+    /**
+     * Compute minimum distance from a point to a solid.
+     *
+     * Returns `[distance, closest_x, closest_y, closest_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    pointToSolidDistance(px: number, py: number, pz: number, solid: number): Float64Array;
+    /**
+     * Project a 3D point onto a face surface using Newton iteration.
+     *
+     * Returns `[u, v, px, py, pz, distance]`.
+     */
+    projectPointOnSurface(face: number, px: number, py: number, pz: number): Float64Array;
+    /**
+     * Recognize geometric features in a solid.
+     *
+     * Returns a JSON string describing the recognized features.
+     */
+    recognizeFeatures(solid: number, deflection: number): string;
+    /**
+     * Remove degenerate (zero-length) edges from a solid.
+     *
+     * Returns the number of edges removed.
+     */
+    removeDegenerateEdges(solid: number, tolerance: number): number;
+    /**
+     * Revolve a planar face around an axis to create a solid of revolution.
+     *
+     * The axis is defined by an origin point `(ox, oy, oz)` and a direction
+     * `(dx, dy, dz)`. The angle is in degrees and must be in (0, 360].
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if any input is non-finite, the face handle is
+     * invalid, or the revolve operation fails.
+     */
+    revolve(face: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, angle_degrees: number): number;
+    /**
+     * Section a solid with a plane, returning cross-section face handles.
+     *
+     * Returns an array of face handles (`u32[]`).
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or the plane doesn't
+     * intersect the solid.
+     */
+    section(solid: number, px: number, py: number, pz: number, nx: number, ny: number, nz: number): Uint32Array;
+    /**
+     * Sew loose faces into a connected solid.
+     *
+     * `face_handles` is an array of face handles. Returns a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if fewer than 2 faces or sewing fails.
+     */
+    sewFaces(face_handles: Uint32Array, tolerance: number): number;
+    /**
+     * Get edges shared between two faces.
+     *
+     * Returns an array of edge handles.
+     */
+    sharedEdges(face_a: number, face_b: number): Uint32Array;
+    /**
+     * Hollow a solid with uniform wall thickness.
+     *
+     * `open_faces` is an array of face handles to remove (creating openings).
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if thickness is non-positive or the solid is invalid.
+     */
+    shell(solid: number, thickness: number, open_faces: Uint32Array): number;
+    /**
+     * Add a constraint to a sketch from a JSON string.
+     *
+     * Formats: `{"type":"coincident","p1":0,"p2":1}`,
+     * `{"type":"distance","p1":0,"p2":1,"value":5.0}`,
+     * `{"type":"fixX","point":0,"value":1.0}`, etc.
+     */
+    sketchAddConstraint(sketch: number, json: string): void;
+    /**
+     * Add a point to a sketch. Returns the point index.
+     */
+    sketchAddPoint(sketch: number, x: number, y: number, fixed: boolean): number;
+    /**
+     * Create a new empty sketch. Returns a sketch index.
+     */
+    sketchNew(): number;
+    /**
+     * Solve the sketch constraints.
+     *
+     * Returns a JSON string: `{"converged": bool, "iterations": n, "maxResidual": f, "points": [[x,y], ...]}`.
+     */
+    sketchSolve(sketch: number, max_iterations: number, tolerance: number): string;
+    /**
+     * Create a solid from a shell.
+     *
+     * Returns a solid handle (`u32`).
+     */
+    solidFromShell(shell: number): number;
+    /**
+     * Compute minimum distance between two solids.
+     *
+     * Returns `[distance]`.
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid.
+     */
+    solidToSolidDistance(a: number, b: number): number;
+    /**
+     * Split a solid into two halves along a plane.
+     *
+     * Returns `[positive_solid_handle, negative_solid_handle]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the plane doesn't intersect the solid.
+     */
+    split(solid: number, px: number, py: number, pz: number, nx: number, ny: number, nz: number): Uint32Array;
+    /**
+     * Compute the total surface area of a solid.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    surfaceArea(solid: number, deflection: number): number;
+    /**
+     * Sweep a planar face along a NURBS curve path to create a solid.
+     *
+     * The path is specified as flat arrays for JS interop:
+     * - `path_degree` — polynomial degree of the path curve
+     * - `path_knots` — knot vector
+     * - `path_control_points` — flat `[x,y,z, ...]` control point coordinates
+     * - `path_weights` — per-control-point weights
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid, the NURBS arrays have
+     * inconsistent lengths, or the sweep operation fails.
+     */
+    sweep(face: number, path_degree: number, path_knots: Float64Array, path_control_points: Float64Array, path_weights: Float64Array): number;
+    /**
+     * Sweep a face along a path defined by a chain of edges.
+     *
+     * Collects points from the edges, fits an interpolating NURBS curve,
+     * then sweeps the profile along that curve.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if fewer than 2 edges or the fit fails.
+     */
+    sweepAlongEdges(face: number, edge_handles: Uint32Array): number;
+    /**
+     * Sweep a face along a NURBS path with advanced options.
+     *
+     * `contact_mode`: "rmf" (default), "fixed", or "constantNormal:x,y,z"
+     * `scale_values`: flat `[t0,s0,t1,s1,...]` pairs for piecewise-linear scale law.
+     * Returns a solid handle.
+     */
+    sweepWithOptions(profile: number, path_edge: number, contact_mode: string, scale_values: Float64Array, segments: number): number;
+    /**
+     * Tessellate an edge curve into polyline segments.
+     *
+     * For line edges, returns just start and end points.
+     * For NURBS edges, samples at `num_points` along the curve.
+     *
+     * Returns flattened `[x, y, z, x, y, z, ...]` array.
+     */
+    tessellateEdge(edge: number, num_points: number): Float64Array;
+    /**
+     * Tessellate a single face into a triangle mesh.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid or tessellation fails.
+     */
+    tessellateFace(face: number, deflection: number): JsMesh;
+    /**
+     * Tessellate all faces of a solid into a single merged triangle mesh.
+     *
+     * Includes both the outer shell and any inner shells (voids).
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    tessellateSolid(solid: number, deflection: number): JsMesh;
+    /**
+     * Apply a 4×4 affine transform to a solid (in place).
+     *
+     * The `matrix` must contain exactly 16 values in row-major order.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid, the matrix doesn't
+     * have 16 elements, or the matrix is singular.
+     */
+    transformSolid(solid: number, matrix: Float64Array): void;
+    /**
+     * Untrim a NURBS face by fitting a new surface to the trimmed region.
+     *
+     * Returns a new face handle.
+     */
+    untrimFace(face: number, samples_per_curve: number, interior_samples: number): number;
+    /**
+     * Validate a solid, returning the number of errors found.
+     *
+     * Returns 0 if the solid is valid.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    validateSolid(solid: number): number;
+    /**
+     * Compute the volume of a solid.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    volume(solid: number, deflection: number): number;
+}
+
+/**
+ * A triangle mesh exposed to JavaScript.
+ *
+ * Positions and normals are flattened to `[x, y, z, x, y, z, ...]` format
+ * for efficient WASM transfer and direct use as GPU vertex buffers.
+ */
+export class JsMesh {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Return all mesh data in a single packed buffer for efficient FFI transfer.
+     *
+     * Layout: `[pos_bytes: u32 LE, norm_bytes: u32 LE, idx_bytes: u32 LE,
+     *          positions: f64 LE..., normals: f64 LE..., indices: u32 LE...]`
+     *
+     * This avoids three separate `.clone()` + FFI copies that the individual
+     * getters (`positions`, `normals`, `indices`) would incur.
+     */
+    packedBuffer(): Uint8Array;
+    /**
+     * Triangle indices (groups of 3).
+     */
+    readonly indices: Uint32Array;
+    /**
+     * Flattened per-vertex normals as `[nx, ny, nz, ...]`.
+     */
+    readonly normals: Float64Array;
+    /**
+     * Flattened vertex positions as `[x, y, z, ...]`.
+     */
+    readonly positions: Float64Array;
+    /**
+     * Number of triangles in the mesh.
+     */
+    readonly triangleCount: number;
+    /**
+     * Number of vertices in the mesh.
+     */
+    readonly vertexCount: number;
+}
+
+/**
+ * A 3D point exposed to JavaScript.
+ */
+export class JsPoint3 {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new 3D point.
+     */
+    constructor(x: number, y: number, z: number);
+    /**
+     * X coordinate.
+     */
+    x: number;
+    /**
+     * Y coordinate.
+     */
+    y: number;
+    /**
+     * Z coordinate.
+     */
+    z: number;
+}
+
+/**
+ * A 3D vector exposed to JavaScript.
+ */
+export class JsVec3 {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute the length of this vector.
+     */
+    length(): number;
+    /**
+     * Create a new 3D vector.
+     */
+    constructor(x: number, y: number, z: number);
+    /**
+     * X component.
+     */
+    x: number;
+    /**
+     * Y component.
+     */
+    y: number;
+    /**
+     * Z component.
+     */
+    z: number;
+}