@faicad/brepkit2-wasm 2.129.15

package/brepkit_wasm.d.ts

@@ -0,0 +1,2368 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Typed result for `boundingBox`.
+ */
+export interface BoundingBoxResult {
+    min_x: number;
+    min_y: number;
+    min_z: number;
+    max_x: number;
+    max_y: number;
+    max_z: number;
+}
+
+/**
+ * Typed result for `sketchSolve`.
+ */
+export interface SketchSolveResult {
+    converged: boolean;
+    points: number[];
+    residual: number;
+}
+
+/**
+ * Typed result for `tessellateSolidGrouped`.
+ */
+export interface GroupedMeshResult {
+    positions: number[];
+    normals: number[];
+    indices: number[];
+    faceOffsets: number[];
+}
+
+/**
+ * Typed result for `tessellateSolidUV`.
+ */
+export interface UvMeshResult {
+    positions: number[];
+    normals: number[];
+    indices: number[];
+    uvs: number[];
+}
+
+/**
+ * Typed result for boolean operations with evolution tracking.
+ */
+export interface EvolutionResult {
+    solid: number;
+    generated: number[];
+    modified: number[];
+}
+
+
+/**
+ * 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 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 curve through points (least-squares).
+     *
+     * Returns an edge handle.
+     */
+    approximateCurve(coords: Float64Array, degree: number, num_control_points: 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;
+    /**
+     * Cut corners of a 2D polygon with flat bevels.
+     *
+     * `coords` is a flat array `[x,y, x,y, ...]`.
+     * `distance` is the chamfer distance from each corner.
+     * Returns a flat array of the chamfered polygon coordinates.
+     */
+    chamfer2d(coords: Float64Array, distance: number): Float64Array;
+    /**
+     * Chamfer edges with distance and angle using the v2 blend engine.
+     *
+     * Returns a new solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid or edge handles are invalid, or the
+     * blend computation fails.
+     */
+    chamferDistanceAngle(solid: number, edge_handles: Uint32Array, distance: number, angle: number): number;
+    /**
+     * Chamfer edges with two distances using the v2 blend engine.
+     *
+     * Returns a new solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid or edge handles are invalid, or the
+     * blend computation fails.
+     */
+    chamferV2(solid: number, edge_handles: Uint32Array, d1: number, d2: number): number;
+    /**
+     * 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;
+    /**
+     * Returns the number of saved checkpoints.
+     */
+    checkpointCount(): number;
+    /**
+     * Save a snapshot of the current kernel state.
+     *
+     * Returns a checkpoint ID (zero-based index) that can be passed to
+     * `restore` or `discardCheckpoint`.
+     *
+     * The snapshot is a clone of all topology, assembly, and sketch state.
+     * Existing entity handles remain valid after restore.
+     */
+    checkpoint(): 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 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;
+    /**
+     * 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;
+    /**
+     * Find common (shared) edges between two adjacent 2D polygons.
+     *
+     * Both polygons are flat arrays `[x,y, x,y, ...]`.
+     * Returns a flat array of common segment endpoints `[x1,y1, x2,y2, ...]`,
+     * or an empty array if no common segments exist.
+     */
+    commonSegment2d(coords_a: Float64Array, coords_b: Float64Array): Float64Array;
+    /**
+     * Compose (multiply) two 4x4 transformation matrices.
+     *
+     * Returns the composed matrix as a flat 16-element array (row-major).
+     * This computes `a * b`, meaning `b` is applied first, then `a`.
+     *
+     * # Errors
+     *
+     * Returns an error if either matrix doesn't have 16 elements.
+     */
+    composeTransforms(matrix_a: Float64Array, matrix_b: Float64Array): Float64Array;
+    /**
+     * Cut a target solid by multiple tool solids in a single pass.
+     *
+     * This is more efficient than sequential `cut()` calls when many tools
+     * are applied to the same target — it avoids re-processing unchanged
+     * faces at each step.
+     *
+     * `tool_ids` is a JS `Uint32Array` or array of solid handles.
+     *
+     * # Errors
+     *
+     * Returns an error if any handle is invalid or the operation fails.
+     */
+    compoundCut(target: number, tool_ids: Uint32Array): number;
+    /**
+     * Convert all analytic geometry in a solid to NURBS representation.
+     *
+     * Replaces planes, cylinders, cones, spheres, tori with NURBS surfaces and
+     * lines, circles, ellipses with NURBS curves. NURBS surfaces and curves
+     * already in the model are left untouched. Returns the number of entities
+     * converted.
+     *
+     * Converts every analytic surface and curve to a NURBS representation.
+     * Stored pcurves are dropped during conversion — callers that depend on
+     * pcurves should recompute them afterwards.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or conversion fails.
+     */
+    convertToBspline(solid: number): number;
+    /**
+     * Recognize and replace NURBS faces and edges with their analytic
+     * (elementary) forms wherever possible (Plane/Cylinder/Sphere/
+     * Cone/Torus surfaces; Line/Circle/Ellipse edges).
+     *
+     * Inverse of `convertToBspline`: useful after STEP/IGES import
+     * to recover analytic types from B-spline-only exports.
+     * Returns the total number of faces and edges converted.
+     *
+     * # Errors
+     *
+     * Returns an error if topology lookups fail.
+     */
+    convertToElementary(solid: number): number;
+    /**
+     * Build a convex hull solid from a point cloud.
+     *
+     * Uses the Quickhull algorithm for 3D point sets.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if fewer than 4 non-coplanar 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 face, returning a new independent face handle.
+     *
+     * The copy shares no sub-entities with the original, so translating it
+     * (to form a pocket or boss profile) does not mutate the donor solid.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid.
+     */
+    copyFace(face: number): 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;
+    /**
+     * Deep copy a wire, returning a new independent wire handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the wire handle is invalid.
+     */
+    copyWire(wire: 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` and return evolution tracking data.
+     *
+     * Returns a JSON string: `{"solid": <u32>, "evolution": {...}}`.
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid or the operation
+     * produces an empty or non-manifold result.
+     */
+    cutWithEvolution(a: number, b: number): any;
+    /**
+     * 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;
+    /**
+     * Reconstruct a solid from a buffer produced by [`Self::serialize_solid`].
+     *
+     * # Errors
+     *
+     * Returns an error if the buffer is malformed or reconstruction fails.
+     */
+    deserializeSolid(data: Uint8Array): number;
+    /**
+     * Detect surface-level coincident face pairs between two solids
+     * without performing a boolean operation.
+     *
+     * Useful for warning users about same-domain configurations
+     * (face stacks, coaxial cylinders, concentric spheres) before a
+     * boolean. Returns a JSON array string of objects:
+     * `[{"faceA": <u32>, "faceB": <u32>, "sameOrientation": <bool>, "aabbOverlap": <bool>}, ...]`.
+     *
+     * `sameOrientation` is `true` when the surface normals point the
+     * same way at corresponding parametric points (e.g., two coplanar
+     * faces with the same `+z` normal). `aabbOverlap` filters pairs
+     * that are same-domain on the surface but geometrically disjoint.
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid or any face /
+     * edge / vertex lookup fails internally.
+     */
+    detectCoincidentFaces(a: number, b: number): string;
+    /**
+     * Detect small features (faces below an area threshold).
+     *
+     * Returns an array of face handles.
+     */
+    detectSmallFeatures(solid: number, area_threshold: number, deflection: number): Uint32Array;
+    /**
+     * Discard a checkpoint and all checkpoints after it, freeing their memory.
+     *
+     * # Errors
+     *
+     * Returns an error if `checkpoint_id` does not refer to a valid checkpoint.
+     */
+    discardCheckpoint(checkpoint_id: number): void;
+    /**
+     * 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 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 an edge curve at parameter `t`.
+     *
+     * Returns `[x, y, z]`.
+     */
+    evaluateEdgeCurve(edge: number, t: number): Float64Array;
+    /**
+     * Evaluate a surface normal at (u, v) on a face.
+     *
+     * Returns `[nx, ny, nz]`.
+     */
+    evaluateSurfaceNormal(face: number, u: number, v: number): Float64Array;
+    /**
+     * Evaluate a point on a face surface at (u, v).
+     *
+     * Returns `[x, y, z]`.
+     */
+    evaluateSurface(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 STL ASCII format.
+     *
+     * Returns the ASCII STL as UTF-8 bytes.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or export fails.
+     */
+    exportStlAscii(solid: number, deflection: 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;
+    /**
+     * Round corners of a 2D polygon by inserting arc-approximation vertices.
+     *
+     * `coords` is a flat array `[x,y, x,y, ...]`.
+     * `radius` is the fillet radius.
+     * Returns a flat array of the filleted polygon coordinates.
+     */
+    fillet2d(coords: Float64Array, radius: number): Float64Array;
+    /**
+     * Fillet edges using the v2 walking-based blend engine.
+     *
+     * Returns a new solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid or edge handles are invalid, or the
+     * blend computation fails.
+     */
+    filletV2(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}]`
+     *
+     * Also accepts brepjs-style fields: `startRadius`/`endRadius` as aliases for `start`/`end`.
+     * When `law` is omitted and `startRadius` != `endRadius`, the law auto-detects as `"linear"`.
+     *
+     * Returns a new solid handle.
+     */
+    filletVariable(solid: number, json: string): number;
+    /**
+     * Apply a constant-radius fillet and return face-evolution tracking data.
+     *
+     * Returns a JSON string `{"solid": <u32>, "evolution": {modified,
+     * generated, deleted}}` — the same shape as `fuseWithEvolution`. Blend
+     * faces appear under `generated` and surviving faces under `modified`.
+     * Provenance is matched geometrically (face normal + centroid), so it is
+     * unaffected by how the fillet renumbers faces.
+     *
+     * # Errors
+     *
+     * Returns an error if a handle is invalid, the radius is non-positive, or
+     * the fillet fails.
+     */
+    filletWithEvolution(solid: number, edge_handles: Uint32Array, radius: number): any;
+    /**
+     * 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;
+    /**
+     * Fix face orientations to ensure consistent outward normals.
+     *
+     * Returns the number of faces fixed.
+     */
+    fixFaceOrientations(solid: number): number;
+    /**
+     * Reconstruct a solid from a BREP string.
+     *
+     * Accepts both STEP format (from `toBREP`) and JSON format (from
+     * `toBrepJson`). Auto-detects the format: strings starting with `{`
+     * are parsed as JSON, otherwise as STEP.
+     *
+     * Only single-solid STEP files are supported. Multi-solid files will
+     * return only the first solid.
+     *
+     * # Errors
+     *
+     * Returns an error if the data is invalid or reconstruction fails.
+     */
+    fromBREP(data: string): number;
+    /**
+     * Fuse (union) many solids into one in a single call.
+     *
+     * Faster than a left-fold over `fuse`: overlapping solids are reduced
+     * pairwise in a balanced tree while disjoint groups are merged directly
+     * without a boolean.
+     *
+     * Returns a new solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if any solid handle is invalid, the list is empty,
+     * or a boolean operation produces an empty or non-manifold result.
+     */
+    fuseAll(solid_handles: Uint32Array): number;
+    /**
+     * Fuse (union) two solids and return evolution tracking data.
+     *
+     * Returns a JSON string: `{"solid": <u32>, "evolution": {...}}`.
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid or the operation
+     * produces an empty or non-manifold result.
+     */
+    fuseWithEvolution(a: number, b: number): any;
+    /**
+     * 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 the analytic surface parameters of a face.
+     *
+     * Returns a JSON string with surface-type-specific parameters.
+     */
+    getAnalyticSurfaceParams(face: number): string;
+    /**
+     * Get the solid handles within a compound.
+     *
+     * Returns an array of solid handles (`u32[]`).
+     *
+     * # Errors
+     *
+     * Returns an error if the compound handle is invalid.
+     */
+    getCompoundSolids(compound: number): Uint32Array;
+    /**
+     * 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"`, `"BSPLINE_CURVE"`, `"CIRCLE"`, or `"ELLIPSE"`.
+     *
+     * For NURBS curves that exactly represent analytic curves, this
+     * returns the underlying analytic type (e.g. `"CIRCLE"` for a
+     * rational NURBS circle).
+     */
+    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 *handles* (not positions) of an edge.
+     *
+     * Returns `[start_vertex_handle, end_vertex_handle]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the edge handle is invalid.
+     */
+    getEdgeVertexHandles(edge: number): Uint32Array;
+    /**
+     * 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 wires of a face (outer wire first, then inner/hole wires).
+     *
+     * # Errors
+     * Returns an error if the face handle is invalid.
+     */
+    getFaceWires(face: number): Uint32Array;
+    /**
+     * Read-only canonical NURBS data for the curve underlying an edge.
+     *
+     * Analytic curves (line, circle, ellipse) are converted to their exact
+     * NURBS form. Returns a JSON string with `degree`, `controlPoints`,
+     * `weights`, the flat `knots` vector, compressed `distinctKnots` /
+     * `multiplicities`, `rational`, `closed` / `periodic`, and `domain`.
+     */
+    getNurbsCurveData(edge: number): string;
+    /**
+     * Type-gated read-only B-Spline/NURBS surface data for a face.
+     *
+     * Unlike `getNurbsSurfaceData`, this never converts analytic surfaces:
+     * faces backed by a plane, cylinder, cone, sphere, or torus return the
+     * JSON literal `null`. Only intrinsically free-form (B-Spline/NURBS) faces
+     * yield a record with `degreeU`/`degreeV`, `nbPolesU`/`nbPolesV`, the
+     * row-major `poles` grid (u-major, v-minor) with the matching `weights`
+     * grid, distinct `knotsU`/`knotsV` paired with `multiplicitiesU`/
+     * `multiplicitiesV`, `isPeriodicU`/`isPeriodicV`, and `isRational`.
+     */
+    getNurbsSurfaceDataParity(face: number): string;
+    /**
+     * Read-only canonical NURBS data for the surface underlying a face.
+     *
+     * Analytic surfaces are converted to NURBS (planes/cylinders exact;
+     * cones/spheres/tori via the exact rational forms). Returns a JSON
+     * string with `degreeU`/`degreeV`, the row-major `controlPoints` grid,
+     * the matching `weights` grid, flat `knotsU`/`knotsV`, compressed
+     * distinct-knots/multiplicities per direction, `rational`,
+     * `periodicU`/`periodicV`, and `domainU`/`domainV`.
+     */
+    getNurbsSurfaceData(face: number): string;
+    /**
+     * Get the orientation of a shape.
+     *
+     * Returns `"forward"` for all faces (brepkit faces don't have an
+     * independent orientation flag; the normal direction is canonical).
+     */
+    getShapeOrientation(_id: number): string;
+    /**
+     * Get the face handles of a shell.
+     *
+     * Returns an array of face handles (`u32[]`).
+     *
+     * # Errors
+     *
+     * Returns an error if the shell handle is invalid.
+     */
+    getShellFaces(shell: 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 shell handles of a solid.
+     *
+     * Returns the outer shell first, followed by any inner void shells
+     * (cavities produced by `shell`/hollow operations or boolean cuts).
+     * A simple solid such as a box reports exactly one shell.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    getSolidShells(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"`.
+     *
+     * For NURBS surfaces that exactly represent analytic shapes, this
+     * returns the underlying analytic type (e.g. `"sphere"` for a NURBS
+     * sphere patch).
+     */
+    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;
+    /**
+     * Get the edge handles of a wire.
+     *
+     * Returns an array of unique edge handles (`u32[]`).
+     *
+     * # Errors
+     *
+     * Returns an error if the wire handle is invalid.
+     */
+    getWireEdges(wire: number): Uint32Array;
+    /**
+     * Create a 2D grid pattern of a solid.
+     *
+     * Produces `count_x × count_y` copies arranged in a rectangular grid.
+     */
+    gridPattern(solid: number, dir_x_x: number, dir_x_y: number, dir_x_z: number, dir_y_x: number, dir_y_y: number, dir_y_z: number, spacing_x: number, spacing_y: number, count_x: number, count_y: number): number;
+    /**
+     * Guided (two-rail) sweep: sweep `face` along a spine, orienting the
+     * profile so its up-vector tracks an auxiliary spine.
+     *
+     * The spine and auxiliary spine are each passed as raw NURBS data
+     * (`degree`, `knots`, flat `control_points`, `weights`). Returns a solid
+     * handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error for a non-finite or malformed curve, a non-planar
+     * profile, or a degenerate path.
+     */
+    guidedSweep(face: number, spine_degree: number, spine_knots: Float64Array, spine_control_points: Float64Array, spine_weights: Float64Array, aux_degree: number, aux_knots: Float64Array, aux_control_points: Float64Array, aux_weights: Float64Array): number;
+    /**
+     * 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 a triangle mesh from flat vertex/index arrays.
+     *
+     * `positions` is a flat `[x0,y0,z0, x1,y1,z1, ...]` array.
+     * `indices` is a flat `[i0,i1,i2, i3,i4,i5, ...]` array of triangle
+     * vertex indices. Returns a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the arrays are malformed or mesh import fails.
+     */
+    importIndexedMesh(positions: Float64Array, indices: Uint32Array): number;
+    /**
+     * 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;
+    /**
+     * Compute the boolean intersection of two 2D polygons.
+     *
+     * Both polygons are flat arrays `[x,y, x,y, ...]`.
+     * Returns a flat array of the intersection polygon coordinates,
+     * or an empty array if they don't intersect.
+     *
+     * Uses the Sutherland-Hodgman algorithm (convex clipper).
+     */
+    intersectPolygons2d(coords_a: Float64Array, coords_b: Float64Array): Float64Array;
+    /**
+     * Intersect two solids and return evolution tracking data.
+     *
+     * Returns a JSON string: `{"solid": <u32>, "evolution": {...}}`.
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid or the operation
+     * produces an empty result.
+     */
+    intersectWithEvolution(a: number, b: number): any;
+    /**
+     * 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;
+    /**
+     * Check whether a wire is closed (last edge connects back to first).
+     */
+    isWireClosed(wire: number): boolean;
+    /**
+     * Lift a 2D curve onto a 3D plane, producing an edge.
+     *
+     * `curve_type`: 0 = Line, 1 = Circle, 2 = Ellipse, 3 = NURBS.
+     * `curve_params` layout varies by type (see docs).
+     * The plane is defined by an origin, x-axis, and normal.
+     * `t_start`/`t_end` specify the parameter range on the 2D curve.
+     *
+     * Returns an edge handle (`u32`).
+     */
+    liftCurve2dToPlane(curve_type: number, curve_params: Float64Array, origin_x: number, origin_y: number, origin_z: number, x_axis_x: number, x_axis_y: number, x_axis_z: number, normal_x: number, normal_y: number, normal_z: number, t_start: number, t_end: number): number;
+    /**
+     * 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 profiles with smooth NURBS interpolation.
+     *
+     * Like `loft()`, but produces smooth NURBS side surfaces for 3+
+     * profiles instead of piecewise-planar quads. The surfaces
+     * interpolate through all intermediate profiles with C1+ continuity.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if fewer than 2 profiles are given, profiles have
+     * different vertex counts, or surface fitting fails.
+     */
+    loftSmooth(faces: Uint32Array): number;
+    /**
+     * Loft profiles with options for start/end points and ruled mode.
+     *
+     * `options` is a JSON string with optional fields:
+     * - `startPoint: [x, y, z]` — apex point before first profile
+     * - `endPoint: [x, y, z]` — apex point after last profile
+     * - `ruled: bool` — true for ruled (linear) surfaces (default), false for smooth
+     */
+    loftWithOptions(faces: Uint32Array, options: string): 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 arc edge between two points.
+     *
+     * The arc lies on a circle with the given center, normal axis, and
+     * radius derived from `|start − center|`. The arc goes from start
+     * to end counter-clockwise when viewed along the normal.
+     *
+     * Returns an edge handle (`u32`).
+     */
+    makeCircleArc3d(start_x: number, start_y: number, start_z: number, end_x: number, end_y: number, end_z: number, center_x: number, center_y: number, center_z: number, axis_x: number, axis_y: number, axis_z: number): number;
+    /**
+     * Create a closed circular edge with a caller-supplied reference x-direction.
+     *
+     * Like [`makeCircleEdge`](Self::make_circle_edge), but `ref_dir = (rx, ry, rz)`
+     * is projected onto the plane perpendicular to the normal to fix the
+     * circle's `u_axis` — which controls the seam vertex position at
+     * `circle.evaluate(0.0)`. Use when downstream code (PCurve computation,
+     * extrusion frame) depends on a specific seam placement.
+     *
+     * `ref_dir` must be non-zero (rejected at this boundary) and ideally
+     * not parallel to the normal — `Frame3::from_normal_and_ref` falls
+     * back to an arbitrary perpendicular when the projection of `ref_dir`
+     * onto the plane is degenerate, defeating the purpose of this call.
+     *
+     * Returns an edge handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if any coordinate is NaN/infinite, `radius` is
+     * non-positive, or the normal vector or `ref_dir` is zero.
+     */
+    makeCircleEdgeWithRef(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, radius: number, rx: number, ry: number, rz: number): number;
+    /**
+     * Create a closed circular edge with true `Circle` curve geometry.
+     *
+     * Unlike `makeCircle` (which returns a polygon face approximation),
+     * this creates a single closed edge with an [`EdgeCurve::Circle`]
+     * backing curve and parameter domain `[0, 2π]`. The start and end
+     * vertex are shared at the seam point `circle.evaluate(0.0)`.
+     *
+     * Returns an edge handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if any coordinate is NaN/infinite, `radius` is
+     * non-positive, or the normal vector is zero.
+     */
+    makeCircleEdge(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, radius: 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 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 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 trimmed elliptical arc edge.
+     *
+     * The ellipse is defined by `center`, `axis` (plane normal), the
+     * `ref` major-axis direction, and `semi_major`/`semi_minor`. The
+     * `start`/`end` points trim it to the CCW arc between them (they must
+     * lie on the ellipse). Produces an `EdgeCurve::Ellipse` edge — not a
+     * NURBS approximation — so it reports CIRCLE/ELLIPSE-class geometry.
+     *
+     * Returns an edge handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if any coordinate is NaN/infinite, a semi-axis is
+     * non-positive, `semi_minor` exceeds `semi_major`, or `axis`/`ref` is
+     * a zero vector.
+     */
+    makeEllipseArc3d(start_x: number, start_y: number, start_z: number, end_x: number, end_y: number, end_z: number, center_x: number, center_y: number, center_z: number, axis_x: number, axis_y: number, axis_z: number, ref_x: number, ref_y: number, ref_z: number, semi_major: number, semi_minor: number): number;
+    /**
+     * Create a closed elliptical edge with a caller-supplied reference major-axis.
+     *
+     * Like [`makeEllipseEdge`](Self::make_ellipse_edge), but `ref_dir = (rx, ry, rz)`
+     * is projected onto the plane perpendicular to the normal to fix the
+     * ellipse's major-axis direction (`u_axis`, carrying `semi_major`).
+     * Use this when the caller has an intended major-axis orientation —
+     * otherwise the default-frame variant chooses an arbitrary
+     * perpendicular, which can cause adapters to fall back to NURBS
+     * approximations to preserve their requested orientation.
+     *
+     * `ref_dir` must be non-zero (rejected at this boundary) and ideally
+     * not parallel to the normal — `Frame3::from_normal_and_ref` falls
+     * back to an arbitrary perpendicular when the projection of `ref_dir`
+     * onto the plane is degenerate, defeating the purpose of this call.
+     *
+     * Returns an edge handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if any coordinate is NaN/infinite, either
+     * semi-axis is non-positive, `semi_minor` exceeds `semi_major`, or
+     * the normal vector or `ref_dir` is zero.
+     */
+    makeEllipseEdgeWithRef(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, semi_major: number, semi_minor: number, rx: number, ry: number, rz: number): number;
+    /**
+     * Create a closed elliptical edge with true `Ellipse` curve geometry.
+     *
+     * Creates a single closed edge with an [`EdgeCurve::Ellipse`] backing
+     * curve and parameter domain `[0, 2π]`. The start and end vertex are
+     * shared at the seam point `ellipse.evaluate(0.0)`.
+     *
+     * Returns an edge handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if any coordinate is NaN/infinite, either
+     * semi-axis is non-positive, `semi_minor` exceeds `semi_major`, or
+     * the normal vector is zero.
+     */
+    makeEllipseEdge(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, semi_major: number, semi_minor: number): number;
+    /**
+     * Create an ellipsoid solid centered at the origin.
+     *
+     * Built by creating a unit sphere and scaling it by `(rx, ry, rz)`.
+     *
+     * # Errors
+     *
+     * Returns an error if any radius is non-positive.
+     */
+    makeEllipsoid(rx: number, ry: number, rz: number): number;
+    /**
+     * Create a face from a wire.
+     *
+     * Samples the wire's edges and attaches a planar surface only if the
+     * geometry lies within tolerance of a single plane; otherwise a
+     * non-planar surface is attached, so `getSurfaceType` never reports
+     * `"plane"` for a non-coplanar wire.
+     *
+     * 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 strictly planar face from a wire.
+     *
+     * Fails with a "wire is not planar" error if the wire's geometry does
+     * not lie within tolerance of a single plane. Use this for planar-only
+     * construction intent (probing whether a wire is planar).
+     *
+     * Returns a face handle (`u32`).
+     */
+    makePlanarFaceFromWire(wire: number): number;
+    /**
+     * Create a closed polygon wire from flat coordinates.
+     *
+     * Returns a wire handle.
+     */
+    makePolygonWire(coords: 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 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 solid from a set of faces by sewing them together.
+     *
+     * Alias for `sewFaces` with a default tolerance. This is the equivalent
+     * of sewing faces into a closed shell and building a solid.
+     */
+    makeSolid(face_handles: Uint32Array): 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 circular arc edge defined by start point, tangent direction
+     * at start, and end point.
+     *
+     * If the tangent is parallel to the start→end chord (collinear), falls
+     * back to a straight line edge.
+     *
+     * Returns an edge handle (`u32`).
+     */
+    makeTangentArc3d(start_x: number, start_y: number, start_z: number, tangent_x: number, tangent_y: number, tangent_z: number, end_x: number, end_y: number, end_z: 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;
+    /**
+     * Measure curvature of an edge curve at parameter `t`.
+     *
+     * Returns `[curvature, tangent_x, tangent_y, tangent_z, normal_x, normal_y, normal_z]`.
+     * Curvature is 1/radius. For lines, curvature is 0.
+     */
+    measureCurvatureAtEdge(edge: number, t: number): Float64Array;
+    /**
+     * Measure principal curvatures at (u, v) on a face surface.
+     *
+     * Returns `[k1, k2, d1x, d1y, d1z, d2x, d2y, d2z]` where k1/k2 are
+     * principal curvatures and d1/d2 are the corresponding direction vectors.
+     */
+    measureCurvatureAtSurface(face: number, u: number, v: number): Float64Array;
+    /**
+     * 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;
+    /**
+     * Sample ALL edges of a solid (no smooth-edge filtering).
+     *
+     * Same as `meshEdges` but includes edges between co-surface faces.
+     * Useful for debugging topology.
+     */
+    meshEdgesAll(solid: number, deflection: number, angular_tolerance?: number | null): JsEdgeLines;
+    /**
+     * Sample edges of a solid into polylines for wireframe rendering.
+     *
+     * Returns a `JsEdgeLines` containing flattened positions and per-edge
+     * offset indices. The `deflection` parameter controls sampling density.
+     *
+     * Smooth edges (between faces on the same underlying surface) are
+     * automatically filtered out to reduce wireframe clutter. These edges
+     * arise from boolean face-splitting and don't represent visible creases.
+     */
+    meshEdges(solid: number, deflection: number, angular_tolerance?: number | null): JsEdgeLines;
+    /**
+     * How many boolean operations have degraded to the mesh (co-refinement)
+     * fallback since this page/tab started.
+     *
+     * A mesh fallback still returns a usable solid, but it destroys every
+     * analytic surface type in the result — planes become triangle soups,
+     * cylinders and tori disappear, and face counts jump by orders of
+     * magnitude. Read this before and after a batch of booleans: a non-zero
+     * delta means at least one operation silently lost precision.
+     *
+     * The counter is process-global (shared by every `BrepKernel` in the
+     * module), so read deltas rather than absolute values.
+     */
+    meshFallbackCount(): bigint;
+    /**
+     * Convex Minkowski sum of two solids (`A ⊕ B`).
+     *
+     * Returns the convex hull of all pairwise vertex sums — exact for convex
+     * polytopes (boxes, or a tessellated-sphere rolling tool), a convex
+     * over-approximation otherwise. Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if either handle is invalid, either solid is empty, or
+     * the summed points are degenerate so no hull can be built.
+     */
+    minkowskiSum(solid_a: number, solid_b: number): number;
+    /**
+     * 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;
+    /**
+     * Sweep through multiple section profiles along a spine, lofting the
+     * rotation-minimizing-frame-placed profiles.
+     *
+     * `face_handles` and `params` are parallel arrays: each planar profile and
+     * its parameter in `[0, 1]` along the spine (given as raw NURBS data).
+     * `ruled` selects ruled (planar bands) vs smooth (NURBS) lofted sides.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error for fewer than two sections, mismatched array lengths, a
+     * non-finite or out-of-range value, a non-planar profile, or loft failure.
+     */
+    multiSectionSweep(face_handles: Uint32Array, params: Float64Array, spine_degree: number, spine_knots: Float64Array, spine_control_points: Float64Array, spine_weights: Float64Array, ruled: boolean): 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 all faces of a solid outward or inward (V2 pipeline).
+     *
+     * Uses the new `brepkit-offset` engine with intersection-based joints.
+     *
+     * # Errors
+     *
+     * Returns an error if the distance is not finite or the solid is invalid.
+     */
+    offsetSolidV2(solid: number, distance: number): number;
+    /**
+     * 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 planar wire directly by a distance with a specific join type.
+     *
+     * Builds a planar face from the wire internally, then offsets it with
+     * the requested corner join. This is the wire-based counterpart to
+     * [`offset_wire_with_join_type`](Self::offset_wire_with_join_type),
+     * which requires a face handle. Consumers that only hold a wire (such
+     * as 2D sketch offsets) can route a join type through this entry point
+     * without first constructing a face.
+     *
+     * `join_type` must be one of `"intersection"`, `"arc"`, or `"chamfer"`.
+     * Returns a new wire handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the wire handle is invalid, the wire is not
+     * planar, the join type string is unrecognized, or the offset
+     * operation fails.
+     */
+    offsetWire2DWithJoin(wire: number, distance: number, join_type: string): number;
+    /**
+     * Offset a wire on a planar face with a specific join type.
+     *
+     * `join_type` must be one of `"intersection"`, `"arc"`, or `"chamfer"`.
+     * Returns a new wire handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid, the join type string
+     * is unrecognized, or the offset operation fails.
+     */
+    offsetWireWithJoinType(face: number, distance: number, join_type: string): 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;
+    /**
+     * Test if a 2D point is inside a closed polygon.
+     *
+     * `polygon_coords` is a flat array `[x,y, x,y, ...]`.
+     * Returns `true` if the point is inside the polygon (winding number test).
+     */
+    pointInPolygon2d(polygon_coords: Float64Array, px: number, py: number): boolean;
+    /**
+     * Compute minimum distance from a point to an edge.
+     *
+     * Returns `[distance, closest_x, closest_y, closest_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the edge handle is invalid.
+     */
+    pointToEdgeDistance(px: number, py: number, pz: number, edge: number): Float64Array;
+    /**
+     * Compute minimum distance from a point to a face.
+     *
+     * Returns `[distance, closest_x, closest_y, closest_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid.
+     */
+    pointToFaceDistance(px: number, py: number, pz: number, face: number): Float64Array;
+    /**
+     * 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;
+    /**
+     * Test if two 2D polygons intersect (overlap).
+     *
+     * Both polygons are flat arrays `[x,y, x,y, ...]`.
+     * Returns `true` if any vertex of one polygon is inside the other
+     * or if any edges cross.
+     */
+    polygonsIntersect2d(coords_a: Float64Array, coords_b: Float64Array): boolean;
+    /**
+     * Project a solid's edges onto a view plane with hidden-line removal.
+     *
+     * Viewed along `dir` (orthographic) through `origin`, with in-plane x-axis
+     * `x_axis`. Returns a JSON string `{"visible": [[x,y,…]], "hidden": [[…]]}`
+     * — flat 2D polylines in view coordinates. `hidden_lines = false` drops the
+     * hidden set. Occlusion is an exact point-in-solid test.
+     *
+     * # Errors
+     *
+     * Returns an error for an invalid handle, a non-positive `deflection`, or a
+     * degenerate `dir`/`x_axis`.
+     */
+    projectEdges(solid: number, origin_x: number, origin_y: number, origin_z: number, dir_x: number, dir_y: number, dir_z: number, x_axis_x: number, x_axis_y: number, x_axis_z: number, hidden_lines: boolean, deflection: number): any;
+    /**
+     * 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;
+    /**
+     * Remove all holes from a face, returning a new face with only the outer wire.
+     */
+    removeHolesFromFace(face: number): number;
+    /**
+     * Validate, heal, and re-validate a solid in one pass.
+     *
+     * Returns the number of remaining validation errors after repair.
+     * A return value of 0 means the solid is valid after repair.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    repairSolid(solid: number): number;
+    /**
+     * Restore the kernel to a previously saved checkpoint.
+     *
+     * All state created after the checkpoint is discarded. The checkpoint
+     * itself (and any earlier checkpoints) remain valid for future restores.
+     * Checkpoints created after this one are discarded.
+     *
+     * # Errors
+     *
+     * Returns an error if `checkpoint_id` does not refer to a valid checkpoint.
+     */
+    restore(checkpoint_id: number): void;
+    /**
+     * Reverse the orientation of a face or edge.
+     *
+     * For faces: creates a new face with negated plane normal.
+     * For edges: creates a new edge with swapped start/end vertices.
+     * Returns the handle of the new reversed shape.
+     *
+     * # Errors
+     *
+     * Returns an error if the handle is neither a valid face nor edge.
+     */
+    reverseShape(id: 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;
+    /**
+     * Serialize a solid's complete in-memory topology sub-arena to bytes.
+     *
+     * Captures every vertex, edge, wire, face, shell reachable from the
+     * solid with byte-exact f64 values (no geometry re-derivation or
+     * tolerance normalization). Unlike STEP/IGES export, this preserves the
+     * kernel's exact in-memory state — intended for capturing live operands
+     * and replaying them in a native Rust harness to reproduce
+     * sub-ULP-sensitive boolean behavior.
+     *
+     * Returns a `Uint8Array` consumable by `brepkit_io::arena_io::deserialize_solid`.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or serialization fails.
+     */
+    serializeSolid(solid: number): Uint8Array;
+    /**
+     * 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 an arc to a sketch (defined by center, start, end point indices).
+     * Returns the arc index.
+     */
+    sketchAddArc(sketch: number, center_idx: number, start_idx: number, end_idx: number): number;
+    /**
+     * Add a circle to a sketch.
+     *
+     * `center_idx` must be a valid point index. Returns the circle index
+     * (0-based) for use in circle-referencing constraints.
+     */
+    sketchAddCircle(sketch: number, center_idx: number, radius: number): number;
+    /**
+     * Add a constraint to a sketch from a JSON string.
+     *
+     * Supports all legacy constraint types plus arc-referencing constraints:
+     * `tangentLineArc`, `tangentArcArc`, `pointOnArc`, `equalRadiusArcArc`,
+     * `arcLength`, `concentricArcArc`.
+     */
+    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;
+    /**
+     * Compute degrees of freedom for a sketch.
+     *
+     * Returns a JSON string: `{"dof": n, "rank": n, "numParams": n, "numEquations": n}`.
+     */
+    sketchDof(sketch: number): string;
+    /**
+     * Create a new empty sketch. Returns a sketch index.
+     */
+    sketchNew(): number;
+    /**
+     * Solve the sketch constraints.
+     *
+     * Returns a JSON string with converged status, iteration count, point
+     * positions, and arc definitions.
+     */
+    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, point_a_x, point_a_y, point_a_z, point_b_x, point_b_y, point_b_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid.
+     */
+    solidToSolidDistance(a: number, b: number): Float64Array;
+    /**
+     * 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 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 path with smooth NURBS side surfaces.
+     *
+     * Like `sweep()`, but produces a single NURBS surface per edge strip
+     * instead of multiple flat quads, giving smooth geometry that
+     * tessellates to arbitrary quality.
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if the face or path is invalid, or surface fitting fails.
+     */
+    sweepSmooth(face: number, path_degree: number, path_knots: Float64Array, path_control_points: Float64Array, path_weights: Float64Array): 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.
+     * `corner_mode`: "smooth" (default), "miter", or "round"
+     * Returns a solid handle.
+     */
+    sweepWithOptions(profile: number, path_edge: number, contact_mode: string, scale_values: Float64Array, segments: number, corner_mode: string): 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;
+    /**
+     * 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, angular_tolerance?: number | null): JsMesh;
+    /**
+     * Tessellate a solid with per-face grouping, returned as packed binary
+     * buffers ([`JsGroupedMesh`]) instead of a JSON string.
+     *
+     * Identical geometry to [`tessellate_solid_grouped`](Self::tessellate_solid_grouped),
+     * but the mesh crosses the WASM boundary as `Float32Array`/`Uint32Array`
+     * bulk copies rather than a (potentially multi-megabyte) JSON string that
+     * the caller must `JSON.parse` and re-pack — far cheaper for large meshes.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    tessellateSolidGroupedBinary(solid: number, deflection: number, angular_tolerance?: number | null): JsGroupedMesh;
+    /**
+     * Tessellate a solid with per-face triangle grouping.
+     *
+     * Returns a JSON string containing `{ positions, normals, indices, faceOffsets }`.
+     * `faceOffsets` is an array where `faceOffsets[i]` is the start index into
+     * `indices` for face `i`, and the last element is `indices.length`.
+     *
+     * Uses the watertight shared-edge-pool tessellation: adjacent faces share
+     * identical boundary vertices, so the exported mesh has no T-junctions
+     * regardless of how the solid was constructed (booleans included).
+     */
+    tessellateSolidGrouped(solid: number, deflection: number, angular_tolerance?: number | null): any;
+    /**
+     * Tessellate a solid and include per-vertex UV coordinates.
+     *
+     * Returns a JSON string containing `{ positions, normals, indices, uvs }`.
+     * `uvs` is a flat array of `[u0, v0, u1, v1, ...]` values, two per vertex.
+     * For analytic and NURBS surfaces, these are the parametric (u, v) values.
+     * For planar faces, UVs are computed by projection onto the face plane.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    tessellateSolidUV(solid: number, deflection: number, angular_tolerance?: number | null): any;
+    /**
+     * 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, angular_tolerance?: number | null): JsMesh;
+    /**
+     * Thicken a face into a solid by offsetting it by the given distance.
+     *
+     * Creates a solid from a face by extruding it along its normal by
+     * `thickness`. Positive values offset outward, negative inward.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid or thickness is zero.
+     */
+    thicken(face: number, thickness: number): number;
+    /**
+     * Export a solid as a BREP string (STEP format).
+     *
+     * Returns a STEP-formatted string containing the solid's B-Rep data.
+     * Use `fromBREP` to reconstruct the solid from this string.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    toBREP(solid: number): any;
+    /**
+     * Export a solid as a JSON-encoded BREP representation.
+     *
+     * Returns a JSON string with vertices, edges (with curve parameters),
+     * and faces (with surface parameters). This is a brepkit-specific format
+     * that preserves all analytic geometry types.
+     */
+    toBrepJson(solid: number): any;
+    /**
+     * Apply a 4×4 affine transform to a face (in place).
+     *
+     * Transforms all vertices, edge curves, and the face surface geometry.
+     * The `matrix` must contain exactly 16 values in row-major order.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid, the matrix doesn't
+     * have 16 elements, or the matrix is singular.
+     */
+    transformFace(face: number, matrix: Float64Array): void;
+    /**
+     * 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;
+    /**
+     * Apply a 4×4 affine transform to a wire (in place).
+     *
+     * The `matrix` must contain exactly 16 values in row-major order.
+     *
+     * # Errors
+     *
+     * Returns an error if the wire handle is invalid, the matrix doesn't
+     * have 16 elements, or the matrix is singular.
+     */
+    transformWire(wire: number, matrix: Float64Array): void;
+    /**
+     * Unify adjacent faces that lie on the same geometric surface.
+     *
+     * Merges co-surface face fragments (produced by boolean operations)
+     * back into single faces, reducing face count and improving topology.
+     * Returns the number of faces removed.
+     */
+    unifyFaces(solid: number): number;
+    /**
+     * 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 with relaxed checks suitable for assembled geometry.
+     *
+     * Operations like boolean, fillet, and shell produce geometrically
+     * correct shapes that may not have fully manifold topology (faces
+     * from different operations may not share edges). This validation
+     * skips Euler characteristic, boundary edge, non-manifold edge, and
+     * shell connectivity checks.
+     *
+     * Returns 0 if the solid passes all structural checks.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    validateSolidRelaxed(solid: number): number;
+    /**
+     * Validate a solid with configurable tolerance scaling.
+     *
+     * `tolerance_scale` multiplies geometric tolerances used for the
+     * face-normal and face-area checks. Use `10.0` to reduce false
+     * positives on NURBS faces from fillet/shell operations.
+     *
+     * Returns 0 if the solid is valid.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    validateSolidWithOptions(solid: number, tolerance_scale: 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;
+    /**
+     * Weld shells and faces into a single solid by sewing.
+     *
+     * Accepts an array of face handles from potentially different shells.
+     * Sews all faces together into a single solid.
+     */
+    weldShellsAndFaces(face_handles: Uint32Array, tolerance: number): number;
+    /**
+     * Compute the total arc-length of a wire.
+     */
+    wireLength(wire: number): number;
+}
+
+/**
+ * Edge polylines for wireframe rendering, exposed to JavaScript.
+ *
+ * Positions are flattened to `[x, y, z, x, y, z, ...]` format.
+ * Offsets are float-array indices into `positions` (already multiplied by 3).
+ */
+export class JsEdgeLines {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Return all data in a single packed buffer for efficient FFI transfer.
+     *
+     * Layout: `[pos_bytes: u32 LE, off_bytes: u32 LE,
+     *          positions: f64 LE..., offsets: u32 LE...]`
+     */
+    packedBuffer(): Uint8Array;
+    /**
+     * Number of edges.
+     */
+    readonly edgeCount: number;
+    /**
+     * Start index into the flattened positions array for each edge polyline.
+     *
+     * The i-th edge's positions span from `positions[offsets[i]]` to
+     * `positions[offsets[i+1]]` (or to the end for the last edge).
+     * Each offset is already a float-array index (vertex index × 3).
+     */
+    readonly offsets: Uint32Array;
+    /**
+     * Flattened vertex positions as `[x, y, z, ...]`.
+     */
+    readonly positions: Float64Array;
+}
+
+/**
+ * A triangle mesh with per-face triangle grouping, exposed to JavaScript.
+ *
+ * The binary counterpart to the JSON `tessellateSolidGrouped`: positions and
+ * normals are packed `Float32Array`s and indices/`faceOffsets` are
+ * `Uint32Array`s, so the whole mesh crosses the WASM boundary as bulk memory
+ * copies instead of a JSON string round-trip. `f32` matches what mesh
+ * consumers (GPU vertex buffers) use, halving the transfer versus `f64`.
+ */
+export class JsGroupedMesh {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Per-face start offsets into `indices`: `faceOffsets[i]` is the start of
+     * face `i`, and the final element equals `indices.length`.
+     */
+    readonly faceOffsets: Uint32Array;
+    /**
+     * Triangle indices (groups of 3).
+     */
+    readonly indices: Uint32Array;
+    /**
+     * Flattened per-vertex normals as `[nx, ny, nz, ...]`.
+     */
+    readonly normals: Float32Array;
+    /**
+     * Flattened vertex positions as `[x, y, z, ...]`.
+     */
+    readonly positions: Float32Array;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Clears the stored panic message so later reads reflect only new panics.
+ */
+export function clearLastPanicMessage(): void;
+
+/**
+ * Returns the message and source location of the most recent panic inside
+ * the kernel, or `undefined` if none has occurred.
+ *
+ * After a panic the kernel object is unusable (every method throws
+ * "recursive use of an object"); this free function remains callable and
+ * carries the root-cause text for the failed call.
+ */
+export function lastPanicMessage(): string | undefined;
+
+/**
+ * Route brepkit's Rust `log::*` calls to JavaScript `console.{log, warn,
+ * error}`. Without this every `log::warn!` in the engine is silently
+ * dropped under wasm-pack.
+ *
+ * `level` is one of `"off"`, `"error"`, `"warn"`, `"info"`, `"debug"`,
+ * `"trace"` (case-insensitive). Default is `"off"` (no log calls reach
+ * the console). Idempotent — call as often as you like to change the
+ * filter.
+ *
+ * Throws a JS Error if `level` is not one of the recognised values so a
+ * typo surfaces immediately instead of producing the same observable
+ * behaviour as never calling `setLogLevel` at all.
+ *
+ * Recommended: call once at app start with `"warn"` to surface boolean /
+ * validation diagnostics without flooding the console.
+ */
+export function setLogLevel(level: string): void;