occt-wasm 0.1.7 → 1.0.2

package/dist/index.js

@@ -1,9 +1,9 @@
 /**
- * @occt-wasm/core — OCCT compiled to WASM with clean TypeScript bindings.
+ * occt-wasm — OCCT compiled to WASM with clean TypeScript bindings.
  *
  * @example
  * ```ts
- * import { OcctKernel } from '@occt-wasm/core';
+ * import { OcctKernel } from 'occt-wasm';
  *
  * const kernel = await OcctKernel.init();
  * const box = kernel.makeBox(10, 20, 30);
@@ -15,11 +15,12 @@
 export { OcctError, } from "./types.js";
 export { XCAFDocument } from "./xcaf-document.js";
 import { OcctError } from "./types.js";
-/** Cast a raw number to a branded ShapeHandle. */
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
 function handle(id) {
     return id;
 }
-/** Wrap an Embind call, catching errors and re-throwing as OcctError. */
 function wrap(operation, fn) {
     try {
         return fn();
@@ -31,12 +32,57 @@ function wrap(operation, fn) {
         throw new OcctError(operation, String(e));
     }
 }
+function vecToNumbers(vec) {
+    const result = [];
+    for (let i = 0; i < vec.size(); i++) {
+        result.push(vec.get(i));
+    }
+    return result;
+}
+/**
+ * Extract the first n elements from an Embind vector into an array,
+ * then delete the vector and return the result.
+ */
+function extractFromVector(vec, count) {
+    const result = [];
+    for (let i = 0; i < count; i++) {
+        result.push(vec.get(i));
+    }
+    vec.delete();
+    return result;
+}
+function vecToHandles(vec) {
+    const result = [];
+    for (let i = 0; i < vec.size(); i++) {
+        result.push(handle(vec.get(i)));
+    }
+    vec.delete();
+    return result;
+}
+/**
+ * Safety net: releases the raw Embind kernel if an OcctKernel instance is
+ * garbage-collected without being disposed. Prefer `using` or explicit
+ * `kernel[Symbol.dispose]()` — the FinalizationRegistry is a last resort.
+ */
+const kernelRegistry = new FinalizationRegistry((raw) => {
+    try {
+        raw.releaseAll();
+        raw.delete();
+    }
+    catch {
+        // Already disposed — ignore.
+    }
+});
+// ---------------------------------------------------------------------------
+// OcctKernel
+// ---------------------------------------------------------------------------
 /**
  * OCCT kernel compiled to WASM. Arena-based shape management
  * with branded handle types for type safety.
  *
  * Create via `OcctKernel.init()`. Dispose via `kernel[Symbol.dispose]()` or
- * the `using` keyword.
+ * the `using` keyword. A FinalizationRegistry safety net catches leaked
+ * instances, but deterministic disposal is strongly preferred.
  */
 export class OcctKernel {
     #raw;
@@ -44,6 +90,7 @@ export class OcctKernel {
     constructor(module) {
         this.#module = module;
         this.#raw = new module.OcctKernel();
+        kernelRegistry.register(this, this.#raw, this);
     }
     /**
      * Initialize the WASM module and create a kernel instance.
@@ -55,12 +102,11 @@ export class OcctKernel {
      *
      * // Node.js with explicit path:
      * const kernel = await OcctKernel.init({
-     *   wasmPath: './node_modules/@occt-wasm/core/dist/occt-wasm.wasm'
+     *   wasmPath: './node_modules/occt-wasm/dist/occt-wasm.wasm'
      * });
      * ```
      */
     static async init(options) {
-        // Dynamic import of the Emscripten-generated module.
         // @ts-expect-error -- occt-wasm.js is generated at build time, no .d.ts
         const imported = await import(/* webpackIgnore: true */ "./occt-wasm.js");
         const createModule = imported.default;
@@ -76,45 +122,146 @@ export class OcctKernel {
         const module = await createModule(moduleOpts);
         return new OcctKernel(module);
     }
-    // --- Primitives ---
+    // =======================================================================
+    // Primitives
+    // =======================================================================
+    /** Create an axis-aligned box solid with the given dimensions (BRepPrimAPI_MakeBox).
+     * @throws OcctError if dimensions are non-positive */
     makeBox(dx, dy, dz) {
         return wrap("makeBox", () => handle(this.#raw.makeBox(dx, dy, dz)));
     }
+    /** Create a box solid from two opposite corner points.
+     * @throws OcctError if corners are coincident */
+    makeBoxFromCorners(corner1, corner2) {
+        return wrap("makeBoxFromCorners", () => handle(this.#raw.makeBoxFromCorners(corner1.x, corner1.y, corner1.z, corner2.x, corner2.y, corner2.z)));
+    }
+    /** Create a cylinder solid centered on the Z axis (BRepPrimAPI_MakeCylinder).
+     * @throws OcctError */
     makeCylinder(radius, height) {
         return wrap("makeCylinder", () => handle(this.#raw.makeCylinder(radius, height)));
     }
+    /** Create a sphere solid at the origin (BRepPrimAPI_MakeSphere).
+     * @throws OcctError */
     makeSphere(radius) {
         return wrap("makeSphere", () => handle(this.#raw.makeSphere(radius)));
     }
+    /** Create a cone (or truncated cone) solid along the Z axis (BRepPrimAPI_MakeCone).
+     * @param r1 - bottom radius
+     * @param r2 - top radius (0 for a full cone)
+     * @throws OcctError */
     makeCone(r1, r2, height) {
         return wrap("makeCone", () => handle(this.#raw.makeCone(r1, r2, height)));
     }
+    /** Create a torus solid at the origin (BRepPrimAPI_MakeTorus).
+     * @throws OcctError */
     makeTorus(majorRadius, minorRadius) {
         return wrap("makeTorus", () => handle(this.#raw.makeTorus(majorRadius, minorRadius)));
     }
-    // --- Booleans ---
+    /** Create an ellipsoid solid at the origin by scaling a sphere.
+     * @param rx - radius along X
+     * @param ry - radius along Y
+     * @param rz - radius along Z
+     * @throws OcctError */
+    makeEllipsoid(rx, ry, rz) {
+        return wrap("makeEllipsoid", () => handle(this.#raw.makeEllipsoid(rx, ry, rz)));
+    }
+    /** Create a rectangular planar face on the XY plane at the origin.
+     * @throws OcctError */
+    makeRectangle(width, height) {
+        return wrap("makeRectangle", () => handle(this.#raw.makeRectangle(width, height)));
+    }
+    // =======================================================================
+    // Booleans
+    // =======================================================================
+    /** Boolean union (BRepAlgoAPI_Fuse). Combines two shapes into one.
+     * @throws OcctError */
     fuse(a, b) {
         return wrap("fuse", () => handle(this.#raw.fuse(a, b)));
     }
+    /** Boolean subtraction (BRepAlgoAPI_Cut). Removes b from a.
+     * @throws OcctError */
     cut(a, b) {
         return wrap("cut", () => handle(this.#raw.cut(a, b)));
     }
+    /** Boolean intersection (BRepAlgoAPI_Common). Keeps only the overlapping volume.
+     * @throws OcctError */
     common(a, b) {
         return wrap("common", () => handle(this.#raw.common(a, b)));
     }
+    /** Boolean intersection — alias for common (BRepAlgoAPI_Common).
+     * @throws OcctError */
+    intersect(a, b) {
+        return wrap("intersect", () => handle(this.#raw.intersect(a, b)));
+    }
+    /** Compute the intersection edges/vertices of two shapes (BRepAlgoAPI_Section).
+     * @returns A compound of edges/vertices at the intersection
+     * @throws OcctError */
     section(a, b) {
         return wrap("section", () => handle(this.#raw.section(a, b)));
     }
-    // --- Modeling ---
+    /** Fuse all shapes in the array into a single shape.
+     * @throws OcctError */
+    fuseAll(shapes) {
+        return wrap("fuseAll", () => {
+            const vec = this.#makeVectorU32(shapes);
+            try {
+                return handle(this.#raw.fuseAll(vec));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
+    /** Subtract all tool shapes from the base shape.
+     * @throws OcctError */
+    cutAll(shape, tools) {
+        return wrap("cutAll", () => {
+            const vec = this.#makeVectorU32(tools);
+            try {
+                return handle(this.#raw.cutAll(shape, vec));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
+    /** Split a shape using tool shapes as splitting surfaces (BOPAlgo_Splitter).
+     * @returns A compound of the split fragments
+     * @throws OcctError */
+    split(shape, tools) {
+        return wrap("split", () => {
+            const vec = this.#makeVectorU32(tools);
+            try {
+                return handle(this.#raw.split(shape, vec));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
+    // =======================================================================
+    // Modeling
+    // =======================================================================
+    /** Extrude a shape along a direction vector (BRepPrimAPI_MakePrism).
+     * @param dx - extrusion vector X component
+     * @param dy - extrusion vector Y component
+     * @param dz - extrusion vector Z component
+     * @throws OcctError */
     extrude(shape, dx, dy, dz) {
         return wrap("extrude", () => handle(this.#raw.extrude(shape, dx, dy, dz)));
     }
+    /** Revolve a shape around an axis (BRepPrimAPI_MakeRevol).
+     * @param axis - rotation axis defined by a point and direction
+     * @param angleRad - sweep angle in radians (2*PI for full revolution)
+     * @throws OcctError */
     revolve(shape, axis, angleRad) {
         return wrap("revolve", () => handle(this.#raw.revolve(shape, axis.point.x, axis.point.y, axis.point.z, axis.direction.x, axis.direction.y, axis.direction.z, angleRad)));
     }
+    /** Apply a constant-radius fillet to edges of a solid (BRepFilletAPI_MakeFillet).
+     * @throws OcctError */
     fillet(solid, edges, radius) {
         return wrap("fillet", () => {
-            const vec = this.#makeVector(edges);
+            const vec = this.#makeVectorU32(edges);
             try {
                 return handle(this.#raw.fillet(solid, vec, radius));
             }
@@ -125,7 +272,7 @@ export class OcctKernel {
     }
     chamfer(solid, edges, distance) {
         return wrap("chamfer", () => {
-            const vec = this.#makeVector(edges);
+            const vec = this.#makeVectorU32(edges);
             try {
                 return handle(this.#raw.chamfer(solid, vec, distance));
             }
@@ -134,9 +281,20 @@ export class OcctKernel {
             }
         });
     }
+    chamferDistAngle(solid, edges, distance, angleDeg) {
+        return wrap("chamferDistAngle", () => {
+            const vec = this.#makeVectorU32(edges);
+            try {
+                return handle(this.#raw.chamferDistAngle(solid, vec, distance, angleDeg));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
     shell(solid, facesToRemove, thickness) {
         return wrap("shell", () => {
-            const vec = this.#makeVector(facesToRemove);
+            const vec = this.#makeVectorU32(facesToRemove);
             try {
                 return handle(this.#raw.shell(solid, vec, thickness));
             }
@@ -148,13 +306,21 @@ export class OcctKernel {
     offset(solid, distance) {
         return wrap("offset", () => handle(this.#raw.offset(solid, distance)));
     }
-    // --- Sweeps ---
+    draft(shape, face, angleRad, direction) {
+        return wrap("draft", () => handle(this.#raw.draft(shape, face, angleRad, direction.x, direction.y, direction.z)));
+    }
+    // =======================================================================
+    // Sweeps
+    // =======================================================================
     pipe(profile, spine) {
         return wrap("pipe", () => handle(this.#raw.pipe(profile, spine)));
     }
+    simplePipe(profile, spine) {
+        return wrap("simplePipe", () => handle(this.#raw.simplePipe(profile, spine)));
+    }
     loft(wires, isSolid) {
         return wrap("loft", () => {
-            const vec = this.#makeVector(wires);
+            const vec = this.#makeVectorU32(wires);
             try {
                 return handle(this.#raw.loft(vec, isSolid));
             }
@@ -163,16 +329,73 @@ export class OcctKernel {
             }
         });
     }
-    // --- Construction ---
+    loftWithVertices(wires, isSolid, startVertex, endVertex) {
+        return wrap("loftWithVertices", () => {
+            const vec = this.#makeVectorU32(wires);
+            try {
+                return handle(this.#raw.loftWithVertices(vec, isSolid, startVertex, endVertex));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
+    sweep(wire, spine, transitionMode = 0) {
+        return wrap("sweep", () => handle(this.#raw.sweep(wire, spine, transitionMode)));
+    }
+    sweepPipeShell(profile, spine, freenet = false, smooth = true) {
+        return wrap("sweepPipeShell", () => handle(this.#raw.sweepPipeShell(profile, spine, freenet, smooth)));
+    }
+    draftPrism(shape, dx, dy, dz, angleDeg) {
+        return wrap("draftPrism", () => handle(this.#raw.draftPrism(shape, dx, dy, dz, angleDeg)));
+    }
+    // =======================================================================
+    // Construction
+    // =======================================================================
     makeVertex(x, y, z) {
         return wrap("makeVertex", () => handle(this.#raw.makeVertex(x, y, z)));
     }
     makeEdge(v1, v2) {
         return wrap("makeEdge", () => handle(this.#raw.makeEdge(v1, v2)));
     }
+    makeLineEdge(start, end) {
+        return wrap("makeLineEdge", () => handle(this.#raw.makeLineEdge(start.x, start.y, start.z, end.x, end.y, end.z)));
+    }
+    makeCircleEdge(center, normal, radius) {
+        return wrap("makeCircleEdge", () => handle(this.#raw.makeCircleEdge(center.x, center.y, center.z, normal.x, normal.y, normal.z, radius)));
+    }
+    makeCircleArc(center, normal, radius, startAngle, endAngle) {
+        return wrap("makeCircleArc", () => handle(this.#raw.makeCircleArc(center.x, center.y, center.z, normal.x, normal.y, normal.z, radius, startAngle, endAngle)));
+    }
+    makeArcEdge(start, mid, end) {
+        return wrap("makeArcEdge", () => handle(this.#raw.makeArcEdge(start.x, start.y, start.z, mid.x, mid.y, mid.z, end.x, end.y, end.z)));
+    }
+    makeEllipseEdge(center, normal, majorRadius, minorRadius) {
+        return wrap("makeEllipseEdge", () => handle(this.#raw.makeEllipseEdge(center.x, center.y, center.z, normal.x, normal.y, normal.z, majorRadius, minorRadius)));
+    }
+    makeEllipseArc(center, normal, majorRadius, minorRadius, startAngle, endAngle) {
+        return wrap("makeEllipseArc", () => handle(this.#raw.makeEllipseArc(center.x, center.y, center.z, normal.x, normal.y, normal.z, majorRadius, minorRadius, startAngle, endAngle)));
+    }
+    makeBezierEdge(controlPoints) {
+        return wrap("makeBezierEdge", () => {
+            const flat = this.#flattenPoints(controlPoints);
+            try {
+                return handle(this.#raw.makeBezierEdge(flat));
+            }
+            finally {
+                flat.delete();
+            }
+        });
+    }
+    makeTangentArc(start, tangent, end) {
+        return wrap("makeTangentArc", () => handle(this.#raw.makeTangentArc(start.x, start.y, start.z, tangent.x, tangent.y, tangent.z, end.x, end.y, end.z)));
+    }
+    makeHelixWire(origin, axis, pitch, height, radius) {
+        return wrap("makeHelixWire", () => handle(this.#raw.makeHelixWire(origin.x, origin.y, origin.z, axis.x, axis.y, axis.z, pitch, height, radius)));
+    }
     makeWire(edges) {
         return wrap("makeWire", () => {
-            const vec = this.#makeVector(edges);
+            const vec = this.#makeVectorU32(edges);
             try {
                 return handle(this.#raw.makeWire(vec));
             }
@@ -184,9 +407,70 @@ export class OcctKernel {
     makeFace(wire) {
         return wrap("makeFace", () => handle(this.#raw.makeFace(wire)));
     }
+    makeNonPlanarFace(wire) {
+        return wrap("makeNonPlanarFace", () => handle(this.#raw.makeNonPlanarFace(wire)));
+    }
+    addHolesInFace(face, holeWires) {
+        return wrap("addHolesInFace", () => {
+            const vec = this.#makeVectorU32(holeWires);
+            try {
+                return handle(this.#raw.addHolesInFace(face, vec));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
+    removeHolesFromFace(face, holeIndices) {
+        return wrap("removeHolesFromFace", () => {
+            const vec = this.#makeVectorI32(holeIndices);
+            try {
+                return handle(this.#raw.removeHolesFromFace(face, vec));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
+    makeSolid(shell) {
+        return wrap("makeSolid", () => handle(this.#raw.makeSolid(shell)));
+    }
+    sew(shapes, tolerance = 1e-6) {
+        return wrap("sew", () => {
+            const vec = this.#makeVectorU32(shapes);
+            try {
+                return handle(this.#raw.sew(vec, tolerance));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
+    sewAndSolidify(faces, tolerance = 1e-6) {
+        return wrap("sewAndSolidify", () => {
+            const vec = this.#makeVectorU32(faces);
+            try {
+                return handle(this.#raw.sewAndSolidify(vec, tolerance));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
+    buildSolidFromFaces(faces, tolerance = 1e-6) {
+        return wrap("buildSolidFromFaces", () => {
+            const vec = this.#makeVectorU32(faces);
+            try {
+                return handle(this.#raw.buildSolidFromFaces(vec, tolerance));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
     makeCompound(shapes) {
         return wrap("makeCompound", () => {
-            const vec = this.#makeVector(shapes);
+            const vec = this.#makeVectorU32(shapes);
             try {
                 return handle(this.#raw.makeCompound(vec));
             }
@@ -195,7 +479,18 @@ export class OcctKernel {
             }
         });
     }
-    // --- Transforms ---
+    buildTriFace(a, b, c) {
+        return wrap("buildTriFace", () => handle(this.#raw.buildTriFace(a.x, a.y, a.z, b.x, b.y, b.z, c.x, c.y, c.z)));
+    }
+    makeFaceOnSurface(face, wire) {
+        return wrap("makeFaceOnSurface", () => handle(this.#raw.makeFaceOnSurface(face, wire)));
+    }
+    makeNullShape() {
+        return wrap("makeNullShape", () => handle(this.#raw.makeNullShape()));
+    }
+    // =======================================================================
+    // Transforms
+    // =======================================================================
     translate(shape, dx, dy, dz) {
         return wrap("translate", () => handle(this.#raw.translate(shape, dx, dy, dz)));
     }
@@ -211,77 +506,232 @@ export class OcctKernel {
     copy(shape) {
         return wrap("copy", () => handle(this.#raw.copy(shape)));
     }
-    // --- Topology ---
-    getShapeType(shape) {
-        return this.#raw.getShapeType(shape);
+    /** Apply a 3x4 row-major affine transformation matrix (12 doubles: [r00,r01,r02,tx, r10,r11,r12,ty, r20,r21,r22,tz]). */
+    transform(shape, matrix) {
+        return wrap("transform", () => {
+            const vec = this.#makeVectorF64(matrix);
+            try {
+                return handle(this.#raw.transform(shape, vec));
+            }
+            finally {
+                vec.delete();
+            }
+        });
     }
-    getSubShapes(shape, type) {
-        return wrap("getSubShapes", () => {
-            const vec = this.#raw.getSubShapes(shape, type);
-            const result = [];
-            for (let i = 0; i < vec.size(); i++) {
-                result.push(handle(vec.get(i)));
+    /** Apply a general (possibly non-affine) 3x4 row-major transformation matrix (12 doubles). */
+    generalTransform(shape, matrix) {
+        return wrap("generalTransform", () => {
+            const vec = this.#makeVectorF64(matrix);
+            try {
+                return handle(this.#raw.generalTransform(shape, vec));
+            }
+            finally {
+                vec.delete();
             }
-            vec.delete();
-            return result;
         });
     }
+    linearPattern(shape, direction, spacing, count) {
+        return wrap("linearPattern", () => handle(this.#raw.linearPattern(shape, direction.x, direction.y, direction.z, spacing, count)));
+    }
+    circularPattern(shape, center, axis, angle, count) {
+        return wrap("circularPattern", () => handle(this.#raw.circularPattern(shape, center.x, center.y, center.z, axis.x, axis.y, axis.z, angle, count)));
+    }
+    /** Compose two 3x4 row-major transformation matrices. Returns a 12-element array. */
+    composeTransform(m1, m2) {
+        return wrap("composeTransform", () => {
+            const v1 = this.#makeVectorF64(m1);
+            const v2 = this.#makeVectorF64(m2);
+            try {
+                const result = this.#raw.composeTransform(v1, v2);
+                const out = vecToNumbers(result);
+                result.delete();
+                return out;
+            }
+            finally {
+                v1.delete();
+                v2.delete();
+            }
+        });
+    }
+    // =======================================================================
+    // Batch Operations
+    // =======================================================================
+    /** Translate multiple shapes by their respective offsets in a single WASM call. */
+    translateBatch(shapes, offsets) {
+        return wrap("translateBatch", () => {
+            const ids = this.#makeVectorU32(shapes);
+            const off = this.#makeVectorF64(offsets);
+            try {
+                const result = this.#raw.translateBatch(ids, off);
+                return vecToHandles(result);
+            }
+            finally {
+                ids.delete();
+                off.delete();
+            }
+        });
+    }
+    /** Chain boolean operations in a single WASM call. */
+    booleanPipeline(base, opCodes, tools) {
+        return wrap("booleanPipeline", () => {
+            const ops = this.#makeVectorI32(opCodes);
+            const ids = this.#makeVectorU32(tools);
+            try {
+                return handle(this.#raw.booleanPipeline(base, ops, ids));
+            }
+            finally {
+                ops.delete();
+                ids.delete();
+            }
+        });
+    }
+    // =======================================================================
+    // Topology
+    // =======================================================================
+    getShapeType(shape) {
+        return wrap("getShapeType", () => this.#raw.getShapeType(shape));
+    }
+    getSubShapes(shape, type) {
+        return wrap("getSubShapes", () => vecToHandles(this.#raw.getSubShapes(shape, type)));
+    }
+    downcast(shape, targetType) {
+        return wrap("downcast", () => handle(this.#raw.downcast(shape, targetType)));
+    }
     distanceBetween(a, b) {
         return wrap("distanceBetween", () => this.#raw.distanceBetween(a, b));
     }
-    // --- Tessellation ---
-    /**
-     * Tessellate a shape into a triangle mesh.
-     * Returns copied Float32Array/Uint32Array data (safe to keep).
-     */
+    isSame(a, b) {
+        return wrap("isSame", () => this.#raw.isSame(a, b));
+    }
+    isEqual(a, b) {
+        return wrap("isEqual", () => this.#raw.isEqual(a, b));
+    }
+    isNull(shape) {
+        return wrap("isNull", () => this.#raw.isNull(shape));
+    }
+    hashCode(shape, upperBound) {
+        return wrap("hashCode", () => this.#raw.hashCode(shape, upperBound));
+    }
+    shapeOrientation(shape) {
+        return wrap("shapeOrientation", () => this.#raw.shapeOrientation(shape));
+    }
+    sharedEdges(faceA, faceB) {
+        return wrap("sharedEdges", () => vecToHandles(this.#raw.sharedEdges(faceA, faceB)));
+    }
+    adjacentFaces(shape, face) {
+        return wrap("adjacentFaces", () => vecToHandles(this.#raw.adjacentFaces(shape, face)));
+    }
+    iterShapes(shape) {
+        return wrap("iterShapes", () => vecToHandles(this.#raw.iterShapes(shape)));
+    }
+    /** Returns a flat array mapping edge hashes to face hashes. */
+    edgeToFaceMap(shape, hashUpperBound) {
+        return wrap("edgeToFaceMap", () => {
+            const vec = this.#raw.edgeToFaceMap(shape, hashUpperBound);
+            const result = vecToNumbers(vec);
+            vec.delete();
+            return result;
+        });
+    }
+    // =======================================================================
+    // Tessellation
+    // =======================================================================
+    /** Tessellate a shape into a triangle mesh. Returns copied data (safe to keep). */
     tessellate(shape, options) {
         return wrap("tessellate", () => {
-            const linearDeflection = options?.linearDeflection ?? 0.1;
-            const angularDeflection = options?.angularDeflection ?? 0.5;
-            const raw = this.#raw.tessellate(shape, linearDeflection, angularDeflection);
-            try {
-                const vertexCount = raw.positionCount / 3;
-                const triangleCount = raw.indexCount / 3;
-                // Copy data out of WASM heap (safe — survives memory growth)
-                const positions = new Float32Array(this.#module.HEAPF32.buffer.slice(raw.getPositionsPtr(), raw.getPositionsPtr() + raw.positionCount * 4));
-                const normals = new Float32Array(this.#module.HEAPF32.buffer.slice(raw.getNormalsPtr(), raw.getNormalsPtr() + raw.normalCount * 4));
-                const indices = new Uint32Array(this.#module.HEAPU32.buffer.slice(raw.getIndicesPtr(), raw.getIndicesPtr() + raw.indexCount * 4));
-                return {
-                    positions,
-                    normals,
-                    indices,
-                    vertexCount,
-                    triangleCount,
-                };
+            const linDefl = options?.linearDeflection ?? 0.1;
+            const angDefl = options?.angularDeflection ?? 0.5;
+            return this.#extractMesh(this.#raw.tessellate(shape, linDefl, angDefl));
+        });
+    }
+    /** Sample edges as polylines for wireframe rendering. */
+    wireframe(shape, deflection = 0.1) {
+        return wrap("wireframe", () => {
+            const raw = this.#raw.wireframe(shape, deflection);
+            try {
+                const points = new Float32Array(this.#module.HEAPF32.buffer.slice(raw.getPointsPtr(), raw.getPointsPtr() + raw.pointCount * 4));
+                const edgeCount = raw.edgeGroupCount / 3;
+                const edgeGroups = new Int32Array(this.#module.HEAP32.buffer.slice(raw.getEdgeGroupsPtr(), raw.getEdgeGroupsPtr() + raw.edgeGroupCount * 4));
+                return { points, edgeGroups, pointCount: raw.pointCount, edgeCount };
             }
             finally {
                 raw.delete();
             }
         });
     }
-    // --- I/O ---
+    hasTriangulation(shape) {
+        return wrap("hasTriangulation", () => this.#raw.hasTriangulation(shape));
+    }
+    /** Tessellate with face group data (per-face triangle ranges + hashes). */
+    meshShape(shape, options) {
+        return wrap("meshShape", () => {
+            const linDefl = options?.linearDeflection ?? 0.1;
+            const angDefl = options?.angularDeflection ?? 0.5;
+            return this.#extractMeshWithFaceGroups(this.#raw.meshShape(shape, linDefl, angDefl));
+        });
+    }
+    /** Tessellate multiple shapes in a single WASM call. */
+    meshBatch(shapes, options) {
+        return wrap("meshBatch", () => {
+            const ids = this.#makeVectorU32(shapes);
+            const linDefl = options?.linearDeflection ?? 0.1;
+            const angDefl = options?.angularDeflection ?? 0.5;
+            try {
+                const raw = this.#raw.meshBatch(ids, linDefl, angDefl);
+                try {
+                    const positions = new Float32Array(this.#module.HEAPF32.buffer.slice(raw.getPositionsPtr(), raw.getPositionsPtr() + raw.positionCount * 4));
+                    const normals = new Float32Array(this.#module.HEAPF32.buffer.slice(raw.getNormalsPtr(), raw.getNormalsPtr() + raw.normalCount * 4));
+                    const indices = new Uint32Array(this.#module.HEAPU32.buffer.slice(raw.getIndicesPtr(), raw.getIndicesPtr() + raw.indexCount * 4));
+                    const shapeOffsets = new Int32Array(this.#module.HEAP32.buffer.slice(raw.getShapeOffsetsPtr(), raw.getShapeOffsetsPtr() + raw.shapeCount * 4 * 4));
+                    return {
+                        positions,
+                        normals,
+                        indices,
+                        shapeOffsets,
+                        shapeCount: raw.shapeCount,
+                        vertexCount: raw.positionCount / 3,
+                        triangleCount: raw.indexCount / 3,
+                    };
+                }
+                finally {
+                    raw.delete();
+                }
+            }
+            finally {
+                ids.delete();
+            }
+        });
+    }
+    // =======================================================================
+    // I/O
+    // =======================================================================
     importStep(data) {
         return wrap("importStep", () => {
-            const str = typeof data === "string"
-                ? data
-                : new TextDecoder().decode(data);
+            const str = typeof data === "string" ? data : new TextDecoder().decode(data);
             return handle(this.#raw.importStep(str));
         });
     }
     exportStep(shape) {
         return wrap("exportStep", () => this.#raw.exportStep(shape));
     }
-    exportStl(shape, linearDeflection = 0.1) {
-        return wrap("exportStl", () => this.#raw.exportStl(shape, linearDeflection));
+    importStl(data) {
+        return wrap("importStl", () => {
+            const str = typeof data === "string" ? data : new TextDecoder().decode(data);
+            return handle(this.#raw.importStl(str));
+        });
     }
-    // --- Healing ---
-    fixShape(shape) {
-        return wrap("fixShape", () => handle(this.#raw.fixShape(shape)));
+    exportStl(shape, linearDeflection = 0.1, ascii = false) {
+        return wrap("exportStl", () => this.#raw.exportStl(shape, linearDeflection, ascii));
     }
-    unifySameDomain(shape) {
-        return wrap("unifySameDomain", () => handle(this.#raw.unifySameDomain(shape)));
+    toBREP(shape) {
+        return wrap("toBREP", () => this.#raw.toBREP(shape));
     }
-    // --- Query ---
+    fromBREP(data) {
+        return wrap("fromBREP", () => handle(this.#raw.fromBREP(data)));
+    }
+    // =======================================================================
+    // Query / Measure
+    // =======================================================================
     getBoundingBox(shape) {
         return wrap("getBoundingBox", () => this.#raw.getBoundingBox(shape));
     }
@@ -291,7 +741,406 @@ export class OcctKernel {
     getSurfaceArea(shape) {
         return wrap("getSurfaceArea", () => this.#raw.getSurfaceArea(shape));
     }
-    // --- Memory ---
+    getLength(shape) {
+        return wrap("getLength", () => this.#raw.getLength(shape));
+    }
+    getCenterOfMass(shape) {
+        return wrap("getCenterOfMass", () => {
+            const v = this.#raw.getCenterOfMass(shape);
+            return this.#vec3FromEmbind(v);
+        });
+    }
+    getLinearCenterOfMass(shape) {
+        return wrap("getLinearCenterOfMass", () => {
+            const v = this.#raw.getLinearCenterOfMass(shape);
+            return this.#vec3FromEmbind(v);
+        });
+    }
+    surfaceCurvature(face, u, v) {
+        return wrap("surfaceCurvature", () => this.#curvatureDataFromEmbind(this.#raw.surfaceCurvature(face, u, v)));
+    }
+    // =======================================================================
+    // Surfaces
+    // =======================================================================
+    vertexPosition(vertex) {
+        return wrap("vertexPosition", () => {
+            const v = this.#raw.vertexPosition(vertex);
+            return this.#vec3FromEmbind(v);
+        });
+    }
+    surfaceType(face) {
+        return wrap("surfaceType", () => this.#raw.surfaceType(face));
+    }
+    surfaceNormal(face, u, v) {
+        return wrap("surfaceNormal", () => {
+            const vec = this.#raw.surfaceNormal(face, u, v);
+            return this.#vec3FromEmbind(vec);
+        });
+    }
+    pointOnSurface(face, u, v) {
+        return wrap("pointOnSurface", () => {
+            const vec = this.#raw.pointOnSurface(face, u, v);
+            return this.#vec3FromEmbind(vec);
+        });
+    }
+    outerWire(face) {
+        return wrap("outerWire", () => handle(this.#raw.outerWire(face)));
+    }
+    uvBounds(face) {
+        return wrap("uvBounds", () => this.#uvBoundsFromEmbind(this.#raw.uvBounds(face)));
+    }
+    /** Project a 3D point onto a face, returning [u, v]. */
+    uvFromPoint(face, point) {
+        return wrap("uvFromPoint", () => this.#vec2FromEmbind(this.#raw.uvFromPoint(face, point.x, point.y, point.z)));
+    }
+    /** Project a 3D point onto a face, returning the closest point as Vec3. */
+    projectPointOnFace(face, point) {
+        return wrap("projectPointOnFace", () => {
+            const vec = this.#raw.projectPointOnFace(face, point.x, point.y, point.z);
+            return this.#vec3FromEmbind(vec);
+        });
+    }
+    /** Classify a UV point relative to a face boundary. */
+    classifyPointOnFace(face, u, v) {
+        return wrap("classifyPointOnFace", () => this.#raw.classifyPointOnFace(face, u, v));
+    }
+    /** Create a BSpline surface from a grid of control points. */
+    bsplineSurface(controlPoints, rows, cols) {
+        return wrap("bsplineSurface", () => {
+            const flat = this.#flattenPoints(controlPoints);
+            try {
+                return handle(this.#raw.bsplineSurface(flat, rows, cols));
+            }
+            finally {
+                flat.delete();
+            }
+        });
+    }
+    // =======================================================================
+    // Curves
+    // =======================================================================
+    curveType(edge) {
+        return wrap("curveType", () => this.#raw.curveType(edge));
+    }
+    curvePointAtParam(edge, param) {
+        return wrap("curvePointAtParam", () => {
+            const vec = this.#raw.curvePointAtParam(edge, param);
+            return this.#vec3FromEmbind(vec);
+        });
+    }
+    curveTangent(edge, param) {
+        return wrap("curveTangent", () => {
+            const vec = this.#raw.curveTangent(edge, param);
+            return this.#vec3FromEmbind(vec);
+        });
+    }
+    /** Returns [firstParam, lastParam]. */
+    curveParameters(edge) {
+        return wrap("curveParameters", () => {
+            const { u: first, v: last } = this.#vec2FromEmbind(this.#raw.curveParameters(edge));
+            return { first, last };
+        });
+    }
+    curveIsClosed(edge) {
+        return wrap("curveIsClosed", () => this.#raw.curveIsClosed(edge));
+    }
+    curveIsPeriodic(edge) {
+        return wrap("curveIsPeriodic", () => this.#raw.curveIsPeriodic(edge));
+    }
+    curveLength(edge) {
+        return wrap("curveLength", () => this.#raw.curveLength(edge));
+    }
+    interpolatePoints(points, periodic = false) {
+        return wrap("interpolatePoints", () => {
+            const flat = this.#flattenPoints(points);
+            try {
+                return handle(this.#raw.interpolatePoints(flat, periodic));
+            }
+            finally {
+                flat.delete();
+            }
+        });
+    }
+    approximatePoints(points, tolerance = 1e-3) {
+        return wrap("approximatePoints", () => {
+            const flat = this.#flattenPoints(points);
+            try {
+                return handle(this.#raw.approximatePoints(flat, tolerance));
+            }
+            finally {
+                flat.delete();
+            }
+        });
+    }
+    getNurbsCurveData(edge) {
+        return wrap("getNurbsCurveData", () => {
+            const raw = this.#raw.getNurbsCurveData(edge);
+            const result = {
+                degree: raw.degree,
+                rational: raw.rational,
+                periodic: raw.periodic,
+                knots: extractFromVector(raw.knots, raw.knots.size()),
+                multiplicities: extractFromVector(raw.multiplicities, raw.multiplicities.size()),
+                poles: extractFromVector(raw.poles, raw.poles.size()),
+                weights: extractFromVector(raw.weights, raw.weights.size()),
+            };
+            return result;
+        });
+    }
+    liftCurve2dToPlane(points2d, planeOrigin, planeZ, planeX) {
+        return wrap("liftCurve2dToPlane", () => {
+            const flat = new this.#module.VectorDouble();
+            for (const p of points2d) {
+                flat.push_back(p.x);
+                flat.push_back(p.y);
+            }
+            try {
+                return handle(this.#raw.liftCurve2dToPlane(flat, planeOrigin.x, planeOrigin.y, planeOrigin.z, planeZ.x, planeZ.y, planeZ.z, planeX.x, planeX.y, planeX.z));
+            }
+            finally {
+                flat.delete();
+            }
+        });
+    }
+    // =======================================================================
+    // Projection (HLR)
+    // =======================================================================
+    projectEdges(shape, viewOrigin, viewDirection, xAxis) {
+        return wrap("projectEdges", () => {
+            const hasXAxis = xAxis !== undefined;
+            const xx = xAxis?.x ?? 0;
+            const xy = xAxis?.y ?? 0;
+            const xz = xAxis?.z ?? 0;
+            const raw = this.#raw.projectEdges(shape, viewOrigin.x, viewOrigin.y, viewOrigin.z, viewDirection.x, viewDirection.y, viewDirection.z, xx, xy, xz, hasXAxis);
+            return {
+                visibleOutline: handle(raw.visibleOutline),
+                visibleSmooth: handle(raw.visibleSmooth),
+                visibleSharp: handle(raw.visibleSharp),
+                hiddenOutline: handle(raw.hiddenOutline),
+                hiddenSmooth: handle(raw.hiddenSmooth),
+                hiddenSharp: handle(raw.hiddenSharp),
+            };
+        });
+    }
+    // =======================================================================
+    // Modifiers
+    // =======================================================================
+    thicken(shape, thickness) {
+        return wrap("thicken", () => handle(this.#raw.thicken(shape, thickness)));
+    }
+    defeature(shape, faces) {
+        return wrap("defeature", () => {
+            const vec = this.#makeVectorU32(faces);
+            try {
+                return handle(this.#raw.defeature(shape, vec));
+            }
+            finally {
+                vec.delete();
+            }
+        });
+    }
+    reverseShape(shape) {
+        return wrap("reverseShape", () => handle(this.#raw.reverseShape(shape)));
+    }
+    simplify(shape) {
+        return wrap("simplify", () => handle(this.#raw.simplify(shape)));
+    }
+    filletVariable(solid, edge, startRadius, endRadius) {
+        return wrap("filletVariable", () => handle(this.#raw.filletVariable(solid, edge, startRadius, endRadius)));
+    }
+    /** Offset a 2D wire. */
+    offsetWire2D(wire, offset, joinType = 0) {
+        return wrap("offsetWire2D", () => handle(this.#raw.offsetWire2D(wire, offset, joinType)));
+    }
+    // =======================================================================
+    // Evolution (operations with shape history)
+    // =======================================================================
+    translateWithHistory(shape, dx, dy, dz, inputFaceHashes, hashUpperBound) {
+        return wrap("translateWithHistory", () => {
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.translateWithHistory(shape, dx, dy, dz, hashes, hashUpperBound));
+            }
+            finally {
+                hashes.delete();
+            }
+        });
+    }
+    fuseWithHistory(a, b, inputFaceHashes, hashUpperBound) {
+        return wrap("fuseWithHistory", () => {
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.fuseWithHistory(a, b, hashes, hashUpperBound));
+            }
+            finally {
+                hashes.delete();
+            }
+        });
+    }
+    cutWithHistory(a, b, inputFaceHashes, hashUpperBound) {
+        return wrap("cutWithHistory", () => {
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.cutWithHistory(a, b, hashes, hashUpperBound));
+            }
+            finally {
+                hashes.delete();
+            }
+        });
+    }
+    filletWithHistory(solid, edges, radius, inputFaceHashes, hashUpperBound) {
+        return wrap("filletWithHistory", () => {
+            const edgeVec = this.#makeVectorU32(edges);
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.filletWithHistory(solid, edgeVec, radius, hashes, hashUpperBound));
+            }
+            finally {
+                edgeVec.delete();
+                hashes.delete();
+            }
+        });
+    }
+    rotateWithHistory(shape, axis, angleRad, inputFaceHashes, hashUpperBound) {
+        return wrap("rotateWithHistory", () => {
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.rotateWithHistory(shape, axis.point.x, axis.point.y, axis.point.z, axis.direction.x, axis.direction.y, axis.direction.z, angleRad, hashes, hashUpperBound));
+            }
+            finally {
+                hashes.delete();
+            }
+        });
+    }
+    mirrorWithHistory(shape, point, normal, inputFaceHashes, hashUpperBound) {
+        return wrap("mirrorWithHistory", () => {
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.mirrorWithHistory(shape, point.x, point.y, point.z, normal.x, normal.y, normal.z, hashes, hashUpperBound));
+            }
+            finally {
+                hashes.delete();
+            }
+        });
+    }
+    scaleWithHistory(shape, center, factor, inputFaceHashes, hashUpperBound) {
+        return wrap("scaleWithHistory", () => {
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.scaleWithHistory(shape, center.x, center.y, center.z, factor, hashes, hashUpperBound));
+            }
+            finally {
+                hashes.delete();
+            }
+        });
+    }
+    intersectWithHistory(a, b, inputFaceHashes, hashUpperBound) {
+        return wrap("intersectWithHistory", () => {
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.intersectWithHistory(a, b, hashes, hashUpperBound));
+            }
+            finally {
+                hashes.delete();
+            }
+        });
+    }
+    chamferWithHistory(solid, edges, distance, inputFaceHashes, hashUpperBound) {
+        return wrap("chamferWithHistory", () => {
+            const edgeVec = this.#makeVectorU32(edges);
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.chamferWithHistory(solid, edgeVec, distance, hashes, hashUpperBound));
+            }
+            finally {
+                edgeVec.delete();
+                hashes.delete();
+            }
+        });
+    }
+    shellWithHistory(solid, faces, thickness, inputFaceHashes, hashUpperBound) {
+        return wrap("shellWithHistory", () => {
+            const faceVec = this.#makeVectorU32(faces);
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.shellWithHistory(solid, faceVec, thickness, hashes, hashUpperBound));
+            }
+            finally {
+                faceVec.delete();
+                hashes.delete();
+            }
+        });
+    }
+    offsetWithHistory(solid, distance, inputFaceHashes, hashUpperBound) {
+        return wrap("offsetWithHistory", () => {
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.offsetWithHistory(solid, distance, hashes, hashUpperBound));
+            }
+            finally {
+                hashes.delete();
+            }
+        });
+    }
+    thickenWithHistory(shape, thickness, inputFaceHashes, hashUpperBound) {
+        return wrap("thickenWithHistory", () => {
+            const hashes = this.#makeVectorI32(inputFaceHashes);
+            try {
+                return this.#extractEvolution(this.#raw.thickenWithHistory(shape, thickness, hashes, hashUpperBound));
+            }
+            finally {
+                hashes.delete();
+            }
+        });
+    }
+    // =======================================================================
+    // Extrusion Law
+    // =======================================================================
+    buildExtrusionLaw(profile, length, endFactor) {
+        return wrap("buildExtrusionLaw", () => handle(this.#raw.buildExtrusionLaw(profile, length, endFactor)));
+    }
+    trimLaw(law, first, last) {
+        return wrap("trimLaw", () => handle(this.#raw.trimLaw(law, first, last)));
+    }
+    sweepWithLaw(profile, spine, law) {
+        return wrap("sweepWithLaw", () => handle(this.#raw.sweepWithLaw(profile, spine, law)));
+    }
+    // =======================================================================
+    // Healing / Repair
+    // =======================================================================
+    fixShape(shape) {
+        return wrap("fixShape", () => handle(this.#raw.fixShape(shape)));
+    }
+    unifySameDomain(shape) {
+        return wrap("unifySameDomain", () => handle(this.#raw.unifySameDomain(shape)));
+    }
+    isValid(shape) {
+        return wrap("isValid", () => this.#raw.isValid(shape));
+    }
+    healSolid(shape, tolerance = 1e-6) {
+        return wrap("healSolid", () => handle(this.#raw.healSolid(shape, tolerance)));
+    }
+    healFace(shape, tolerance = 1e-6) {
+        return wrap("healFace", () => handle(this.#raw.healFace(shape, tolerance)));
+    }
+    healWire(shape, tolerance = 1e-6) {
+        return wrap("healWire", () => handle(this.#raw.healWire(shape, tolerance)));
+    }
+    fixFaceOrientations(shape) {
+        return wrap("fixFaceOrientations", () => handle(this.#raw.fixFaceOrientations(shape)));
+    }
+    removeDegenerateEdges(shape) {
+        return wrap("removeDegenerateEdges", () => handle(this.#raw.removeDegenerateEdges(shape)));
+    }
+    buildCurves3d(wire) {
+        wrap("buildCurves3d", () => this.#raw.buildCurves3d(wire));
+    }
+    fixWireOnFace(wire, face, tolerance = 1e-6) {
+        return wrap("fixWireOnFace", () => handle(this.#raw.fixWireOnFace(wire, face, tolerance)));
+    }
+    // =======================================================================
+    // Memory
+    // =======================================================================
     release(shape) {
         this.#raw.release(shape);
     }
@@ -301,17 +1150,133 @@ export class OcctKernel {
     get shapeCount() {
         return this.#raw.getShapeCount();
     }
+    // =======================================================================
+    // Debugging
+    // =======================================================================
+    /** Return a human-readable summary of a shape for debugging. */
+    describe(shape) {
+        const type = this.getShapeType(shape);
+        const bbox = this.getBoundingBox(shape);
+        const dims = `[${(bbox.xmax - bbox.xmin).toFixed(2)} x ${(bbox.ymax - bbox.ymin).toFixed(2)} x ${(bbox.zmax - bbox.zmin).toFixed(2)}]`;
+        const parts = [`${type} ${dims}`];
+        if (type === "solid" || type === "compound" || type === "compsolid") {
+            parts.push(`vol=${this.getVolume(shape).toFixed(3)}`);
+            parts.push(`area=${this.getSurfaceArea(shape).toFixed(3)}`);
+        }
+        const faces = this.getSubShapes(shape, "face");
+        const edges = this.getSubShapes(shape, "edge");
+        const verts = this.getSubShapes(shape, "vertex");
+        parts.push(`F:${faces.length} E:${edges.length} V:${verts.length}`);
+        return parts.join(" | ");
+    }
     [Symbol.dispose]() {
+        kernelRegistry.unregister(this);
         this.#raw.releaseAll();
         this.#raw.delete();
     }
-    /** Create an Embind VectorUint32 from a JS array of ShapeHandles. */
-    #makeVector(ids) {
-        const vec = new this.#module.VectorUint32();
-        for (const id of ids) {
-            vec.push_back(id);
+    // =======================================================================
+    // Private helpers
+    // =======================================================================
+    #makeVector(ctor, values) {
+        const vec = new ctor();
+        for (const v of values) {
+            vec.push_back(v);
         }
         return vec;
     }
+    #makeVectorU32(ids) {
+        return this.#makeVector(this.#module.VectorUint32, ids);
+    }
+    #makeVectorF64(values) {
+        return this.#makeVector(this.#module.VectorDouble, values);
+    }
+    #makeVectorI32(values) {
+        return this.#makeVector(this.#module.VectorInt, values);
+    }
+    #flattenPoints(points) {
+        const vec = new this.#module.VectorDouble();
+        for (const p of points) {
+            vec.push_back(p.x);
+            vec.push_back(p.y);
+            vec.push_back(p.z);
+        }
+        return vec;
+    }
+    #vec2FromEmbind(vec) {
+        const u = vec.get(0);
+        const v = vec.get(1);
+        vec.delete();
+        return { u, v };
+    }
+    #uvBoundsFromEmbind(vec) {
+        const result = {
+            uMin: vec.get(0),
+            uMax: vec.get(1),
+            vMin: vec.get(2),
+            vMax: vec.get(3),
+        };
+        vec.delete();
+        return result;
+    }
+    #curvatureDataFromEmbind(vec) {
+        const result = {
+            min: vec.get(0),
+            max: vec.get(1),
+            gaussian: vec.get(2),
+            mean: vec.get(3),
+        };
+        vec.delete();
+        return result;
+    }
+    #vec3FromEmbind(vec) {
+        const x = vec.get(0);
+        const y = vec.get(1);
+        const z = vec.get(2);
+        vec.delete();
+        return { x, y, z };
+    }
+    #extractMesh(raw) {
+        try {
+            return this.#extractMeshFromRaw(raw);
+        }
+        finally {
+            raw.delete();
+        }
+    }
+    #extractMeshFromRaw(raw) {
+        const vertexCount = raw.positionCount / 3;
+        const triangleCount = raw.indexCount / 3;
+        const positions = new Float32Array(this.#module.HEAPF32.buffer.slice(raw.getPositionsPtr(), raw.getPositionsPtr() + raw.positionCount * 4));
+        const normals = new Float32Array(this.#module.HEAPF32.buffer.slice(raw.getNormalsPtr(), raw.getNormalsPtr() + raw.normalCount * 4));
+        const indices = new Uint32Array(this.#module.HEAPU32.buffer.slice(raw.getIndicesPtr(), raw.getIndicesPtr() + raw.indexCount * 4));
+        return { positions, normals, indices, vertexCount, triangleCount };
+    }
+    #extractMeshWithFaceGroups(raw) {
+        try {
+            const mesh = this.#extractMeshFromRaw(raw);
+            if (raw.faceGroupCount > 0) {
+                mesh.faceGroups = new Int32Array(this.#module.HEAP32.buffer.slice(raw.getFaceGroupsPtr(), raw.getFaceGroupsPtr() + raw.faceGroupCount * 4));
+                mesh.faceCount = raw.faceGroupCount / 3;
+            }
+            return mesh;
+        }
+        finally {
+            raw.delete();
+        }
+    }
+    #extractEvolution(raw) {
+        const modified = vecToNumbers(raw.modified);
+        raw.modified.delete();
+        const generated = vecToNumbers(raw.generated);
+        raw.generated.delete();
+        const deleted = vecToNumbers(raw.deleted);
+        raw.deleted.delete();
+        return {
+            result: handle(raw.resultId),
+            modified,
+            generated,
+            deleted,
+        };
+    }
 }
 //# sourceMappingURL=index.js.map