@faicad/faijs 0.13.0

package/dist/vendored/brepjs/kernel/occtWasm/occtWasmAdapter.js

@@ -0,0 +1,1016 @@
+/**
+ * OcctWasmAdapter -- KernelAdapter implementation backed by occt-wasm's WASM kernel.
+ *
+ * occt-wasm is an arena-based OCCT V8 kernel compiled to WASM via Emscripten/Embind.
+ * All geometry is identified by u32 handles into the arena. This adapter wraps
+ * those handles in {@link OcctWasmHandle} objects so they can flow through
+ * brepjs's kernel-agnostic API as opaque `KernelShape` / `KernelType` values.
+ *
+ * ## Lifecycle
+ *
+ * occt-wasm's high-level `OcctKernel` wrapper is the recommended owner. Build
+ * the adapter from it with {@link OcctWasmAdapter.fromKernel} so the adapter
+ * pins the wrapper for its own lifetime:
+ *
+ * ```ts
+ * import { OcctKernel } from 'occt-wasm';
+ * import { OcctWasmAdapter } from './occtWasmAdapter.js';
+ * import { registerKernel } from '../index.js';
+ *
+ * const kernel = await OcctKernel.init();
+ * registerKernel('occt-wasm', OcctWasmAdapter.fromKernel(kernel));
+ * ```
+ *
+ * The raw `(module, kernel)` constructor remains for callers that own the raw
+ * Embind kernel directly (e.g. `new Module.OcctKernel()`):
+ *
+ * ```ts
+ * import createOcctWasm from 'occt-wasm';
+ *
+ * const Module = await createOcctWasm();
+ * const kernel = new Module.OcctKernel();
+ * registerKernel('occt-wasm', new OcctWasmAdapter(Module, kernel));
+ * ```
+ *
+ * ## Memory model
+ *
+ * occt-wasm uses arena allocation -- entities are freed via `release(id)`
+ * or `releaseAll()`. `dispose()` calls `release()` on the underlying handle.
+ *
+ * @module
+ */
+import { EXACT_BREP_CAPABILITIES } from '../../kernel/capabilities.js';
+import { UnsupportedKernelOperationError } from '../../kernel/unsupported.js';
+import { BrepBugError } from '../../utils/bug.js';
+import { isOcctWasmHandle } from './helpers.js';
+import { buildOcShim, wrapKernelExceptions } from './adapterShims.js';
+import * as boolOps from './booleanOps.js';
+import * as primOps from './primitiveOps.js';
+import * as topoOps from './topologyOps.js';
+import * as repairOps from './repairOps.js';
+import * as meshOps from './meshOps.js';
+import * as curveOps from './curveOps.js';
+import * as surfaceOps from './surfaceOps.js';
+import * as measureOps from './measureOps.js';
+import * as modifierOps from './modifierOps.js';
+import * as sweepOps from './sweepOps.js';
+import * as transformOps from './transformOps.js';
+import * as ioOps from './ioOps.js';
+import * as constructionOps from './constructionOps.js';
+import * as kernel2dOps from './kernel2dOps.js';
+import * as evolutionOps from './evolutionOps.js';
+import * as hullOps from './hullOps.js';
+// Helpers (handle wrapping, vector marshalling) live in ./helpers.ts so
+// per-section files like ./booleanOps.ts can share them without depending
+// on the adapter class.
+// Currently unused but will be needed for batch operations
+// function readVecDouble(vec: EmVectorDouble): number[] {
+//   const result: number[] = [];
+//   const n = vec.size();
+//   for (let i = 0; i < n; i++) result.push(vec.get(i));
+//   return result;
+// }
+// ---------------------------------------------------------------------------
+// Evolution parsing
+// ---------------------------------------------------------------------------
+/**
+ * Parse an EvolutionData result from the WASM kernel into a ShapeEvolution.
+ *
+ * The C++ facade returns flat vectors of [inputHash, outputHash, inputHash, outputHash, ...]
+ * for modified and generated, and a flat vector of deleted input hashes.
+ */
+// parseEvolution moved to evolutionOps.ts
+function notImplemented(method) {
+    throw new UnsupportedKernelOperationError(`occt-wasm: ${method} is not yet implemented`);
+}
+export class OcctWasmAdapter {
+    oc;
+    kernelId = 'occt-wasm';
+    capabilities = EXACT_BREP_CAPABILITIES;
+    Module;
+    k;
+    // Pins the owning OcctKernel wrapper so its FinalizationRegistry can't reclaim
+    // the borrowed raw kernel while this adapter is still live.
+    owner;
+    constructor(module, kernel, owner) {
+        this.Module = module;
+        this.k = wrapKernelExceptions(kernel, module);
+        this.oc = buildOcShim(module, this.k);
+        this.owner = owner;
+    }
+    /**
+     * Build an adapter from occt-wasm's `OcctKernel` wrapper, retaining it for the
+     * adapter's lifetime. Prefer this over the raw `(module, kernel)` constructor:
+     * the wrapper deletes its raw kernel when garbage-collected, so an adapter that
+     * only borrows the raw kernel can be left pointing at freed memory.
+     */
+    static fromKernel(kernel) {
+        // WASM type gap: occt-wasm under-declares its raw module/kernel surface; the
+        // runtime objects expose the full Embind API this adapter needs.
+        const module = kernel.getRawModule();
+        const rawKernel = kernel.getRawKernel();
+        return new OcctWasmAdapter(module, rawKernel, kernel);
+    }
+    /** The owner retained to keep the borrowed raw kernel alive, or `undefined` when built from a raw kernel. */
+    get retainedKernelOwner() {
+        return this.owner;
+    }
+    // =========================================================================
+    // Core
+    // =========================================================================
+    dispose(h) {
+        if (isOcctWasmHandle(h)) {
+            this.k.release(h.id);
+        }
+        else if (typeof h.delete === 'function') {
+            h.delete();
+        }
+    }
+    executeBatch(_json) {
+        notImplemented('executeBatch');
+    }
+    // occt-wasm >= 3.7.0 exposes stateless arena marks (checkpoint/releaseSince);
+    // brepjs's interface also reports checkpointCount, so track open marks JS-side.
+    // Bulk-free contract: every handle allocated after a checkpoint is invalidated
+    // by restoreCheckpoint — copy out (as mesh/data) or allocate before the mark
+    // anything that must survive; a live handle used afterward is a use-after-free.
+    openCheckpoints = [];
+    checkpoint() {
+        const mark = this.k.checkpoint();
+        this.openCheckpoints.push(mark);
+        return mark;
+    }
+    checkpointCount() {
+        return this.openCheckpoints.length;
+    }
+    restoreCheckpoint(cp) {
+        // Validate BEFORE releaseSince: a stale/bogus mark would otherwise erase
+        // every live handle above that arena position, not just this scope's.
+        const idx = this.openCheckpoints.lastIndexOf(cp);
+        if (idx === -1) {
+            throw new BrepBugError('occtWasmAdapter.restoreCheckpoint', `checkpoint ${cp} is not open — releaseSince would erase unrelated live handles`);
+        }
+        this.k.releaseSince(cp);
+        this.openCheckpoints.length = idx;
+    }
+    discardCheckpoint(cp) {
+        // Keep every handle; just forget the mark (occt-wasm marks hold no state).
+        // Tolerant of an unknown cp — discarding frees nothing, so there's no risk.
+        this.closeCheckpoint(cp);
+    }
+    /** Drop `cp` and any marks nested inside it (LIFO), so the depth stays honest. */
+    closeCheckpoint(cp) {
+        const idx = this.openCheckpoints.lastIndexOf(cp);
+        if (idx !== -1)
+            this.openCheckpoints.length = idx;
+    }
+    // =========================================================================
+    // Primitives
+    // =========================================================================
+    makeBox(width, height, depth) {
+        return primOps.makeBox(this.k, width, height, depth);
+    }
+    makeCylinder(radius, height, center, direction) {
+        return primOps.makeCylinder(this.k, radius, height, center, direction);
+    }
+    makeSphere(radius, center) {
+        return primOps.makeSphere(this.k, radius, center);
+    }
+    makeCone(radius1, radius2, height, center, direction) {
+        return primOps.makeCone(this.k, radius1, radius2, height, center, direction);
+    }
+    makeTorus(majorRadius, minorRadius, center, direction) {
+        return primOps.makeTorus(this.k, majorRadius, minorRadius, center, direction);
+    }
+    makeEllipsoid(aLength, bLength, cLength) {
+        return primOps.makeEllipsoid(this.k, aLength, bLength, cLength);
+    }
+    makeBoxFromCorners(p1, p2) {
+        return primOps.makeBoxFromCorners(this.k, p1, p2);
+    }
+    makeRectangle(width, height) {
+        return primOps.makeRectangle(this.k, width, height);
+    }
+    // =========================================================================
+    // Booleans
+    // =========================================================================
+    fuse(shape, tool, options) {
+        return boolOps.fuse(this.k, shape, tool, options);
+    }
+    cut(shape, tool, options) {
+        return boolOps.cut(this.k, shape, tool, options);
+    }
+    intersect(shape, tool, options) {
+        return boolOps.intersect(this.k, shape, tool, options);
+    }
+    section(shape, plane, approximation) {
+        return boolOps.section(this.k, shape, plane, approximation);
+    }
+    fuseAll(shapes, options) {
+        return boolOps.fuseAll(this.k, this.Module, shapes, options);
+    }
+    cutAll(shape, tools, options) {
+        return boolOps.cutAll(this.k, this.Module, shape, tools, options);
+    }
+    split(shape, tools) {
+        return boolOps.split(this.k, this.Module, shape, tools);
+    }
+    checkBoolean(shape, tool, op) {
+        return boolOps.checkBoolean(this.k, shape, tool, op);
+    }
+    meshBoolean(positionsA, indicesA, positionsB, indicesB, op, tolerance) {
+        return boolOps.meshBoolean(positionsA, indicesA, positionsB, indicesB, op, tolerance);
+    }
+    // =========================================================================
+    // Shape construction (builder ops)
+    // =========================================================================
+    makeVertex(x, y, z) {
+        return constructionOps.makeVertex(this.k, x, y, z);
+    }
+    makeEdge(curve, _start, _end) {
+        return constructionOps.makeEdge(this.k, curve);
+    }
+    makeWire(edges) {
+        return constructionOps.makeWire(this.k, this.Module, edges);
+    }
+    makeFace(wire, planar) {
+        return constructionOps.makeFace(this.k, wire, planar);
+    }
+    makeLineEdge(p1, p2) {
+        return constructionOps.makeLineEdge(this.k, p1, p2);
+    }
+    makeCircleEdge(center, normal, radius) {
+        return constructionOps.makeCircleEdge(this.k, center, normal, radius);
+    }
+    makeCircleArc(center, normal, radius, startAngle, endAngle) {
+        return constructionOps.makeCircleArc(this.k, center, normal, radius, startAngle, endAngle);
+    }
+    makeArcEdge(p1, p2, p3) {
+        return constructionOps.makeArcEdge(this.k, p1, p2, p3);
+    }
+    makeEllipseEdge(center, normal, majorRadius, minorRadius, _xDir) {
+        return constructionOps.makeEllipseEdge(this.k, center, normal, majorRadius, minorRadius);
+    }
+    makeEllipseArc(center, normal, majorRadius, minorRadius, startAngle, endAngle, _xDir) {
+        return constructionOps.makeEllipseArc(this.k, center, normal, majorRadius, minorRadius, startAngle, endAngle);
+    }
+    makeBezierEdge(points) {
+        return constructionOps.makeBezierEdge(this.k, this.Module, points);
+    }
+    makeTangentArc(startPoint, startTangent, endPoint) {
+        return constructionOps.makeTangentArc(this.k, startPoint, startTangent, endPoint);
+    }
+    makeHelixWire(pitch, height, radius, center, direction, _leftHanded) {
+        return constructionOps.makeHelixWire(this.k, pitch, height, radius, center, direction);
+    }
+    makeWireFromMixed(items) {
+        return constructionOps.makeWireFromMixed(this.k, this.Module, items);
+    }
+    makeCompound(shapes) {
+        return constructionOps.makeCompound(this.k, this.Module, shapes);
+    }
+    solidFromShell(shell) {
+        return constructionOps.solidFromShell(this.k, shell);
+    }
+    hull(shapes, tolerance) {
+        return hullOps.hull(this.k, this.Module, shapes, tolerance);
+    }
+    hullFromPoints(points, tolerance) {
+        return hullOps.hullFromPoints(this.k, this.Module, points, tolerance);
+    }
+    buildSolidFromFaces(points, faces, tolerance) {
+        return constructionOps.buildSolidFromFaces(this.k, this.Module, points, faces, tolerance);
+    }
+    makeNonPlanarFace(wire) {
+        return constructionOps.makeNonPlanarFace(this.k, wire);
+    }
+    addHolesInFace(face, holeWires) {
+        return constructionOps.addHolesInFace(this.k, this.Module, face, holeWires);
+    }
+    removeHolesFromFace(face) {
+        return constructionOps.removeHolesFromFace(this.k, this.Module, face);
+    }
+    makeFaceOnSurface(surface, wire) {
+        return constructionOps.makeFaceOnSurface(this.k, surface, wire);
+    }
+    bsplineSurface(points, rows, cols) {
+        return constructionOps.bsplineSurface(this.k, this.Module, points, rows, cols);
+    }
+    triangulatedSurface(points, rows, cols) {
+        return constructionOps.triangulatedSurface(this.k, this.Module, points, rows, cols);
+    }
+    buildTriFace(a, b, c) {
+        return constructionOps.buildTriFace(this.k, a, b, c);
+    }
+    sewAndSolidify(faces, tolerance) {
+        return constructionOps.sewAndSolidify(this.k, this.Module, faces, tolerance);
+    }
+    createPoint3d(x, y, z) {
+        return constructionOps.createPoint3d(x, y, z);
+    }
+    createDirection3d(x, y, z) {
+        return constructionOps.createDirection3d(x, y, z);
+    }
+    createVector3d(x, y, z) {
+        return constructionOps.createVector3d(x, y, z);
+    }
+    createAxis1(cx, cy, cz, dx, dy, dz) {
+        return constructionOps.createAxis1(cx, cy, cz, dx, dy, dz);
+    }
+    createAxis2(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
+        return constructionOps.createAxis2(ox, oy, oz, zx, zy, zz, xx, xy, xz);
+    }
+    createAxis3(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
+        return constructionOps.createAxis3(ox, oy, oz, zx, zy, zz, xx, xy, xz);
+    }
+    // =========================================================================
+    // Sweep operations
+    // =========================================================================
+    extrude(face, direction, length) {
+        return sweepOps.extrude(this.k, face, direction, length);
+    }
+    revolve(shape, axis, angle) {
+        return sweepOps.revolve(this.k, shape, axis, angle);
+    }
+    loft(wires, ruled, startShape, endShape) {
+        return sweepOps.loft(this.k, this.Module, wires, ruled, startShape, endShape);
+    }
+    sweep(wire, spine, options) {
+        return sweepOps.sweep(this.k, wire, spine, options);
+    }
+    simplePipe(profile, spine) {
+        return sweepOps.simplePipe(this.k, profile, spine);
+    }
+    helicalSweep(_profile, _axisOrigin, _axisDirection, _radius, _pitch, _turns) {
+        // Primitive composition via makeHelixWire + sweep/sweepPipeShell runs
+        // into OCCT's BRepOffsetAPI_MakePipe{Shell} requirement that the profile
+        // be positioned at the spine's first vertex and oriented perpendicular
+        // to the spine tangent there. Replicating that positioning+orientation
+        // step in TS is real geometric work (extract helix start point and
+        // tangent, transform the profile into that frame) — not a trivial
+        // composition. brepkit exposes a dedicated C++ helicalSweep that
+        // handles this internally; OCCT's defaultAdapter declines with
+        // "only available with the brepkit kernel". Matching that posture
+        // until the composition is fleshed out or a C++ facade method lands.
+        throw new Error('helicalSweep on occt-wasm requires profile positioning+orientation logic not yet implemented; brepkit has a native implementation');
+    }
+    sweepWithOptions(_profile, _pathEdge, _contactMode, _scaleValues, _segments) {
+        notImplemented('sweepWithOptions');
+    }
+    sweepPipeShell(profile, spine, options) {
+        return sweepOps.sweepPipeShell(this.k, profile, spine, options);
+    }
+    loftAdvanced(wires, options) {
+        return sweepOps.loftAdvanced(this.k, this.Module, wires, options);
+    }
+    buildExtrusionLaw(profile, length, endFactor) {
+        return sweepOps.buildExtrusionLaw(this.k, profile, length, endFactor);
+    }
+    revolveVec(shape, center, direction, angle) {
+        return sweepOps.revolveVec(this.k, shape, center, direction, angle);
+    }
+    draftPrism(shape, face, baseFace, height, angleDeg, fuse) {
+        return sweepOps.draftPrism(this.k, shape, face, baseFace, height, angleDeg, fuse);
+    }
+    // =========================================================================
+    // Modifiers
+    // =========================================================================
+    fillet(shape, edges, radius) {
+        return modifierOps.fillet(this.k, this.Module, shape, edges, radius);
+    }
+    chamfer(shape, edges, distance) {
+        return modifierOps.chamfer(this.k, this.Module, shape, edges, distance);
+    }
+    chamferDistAngle(shape, edges, distance, angleDeg) {
+        return modifierOps.chamferDistAngle(this.k, this.Module, shape, edges, distance, angleDeg);
+    }
+    shell(shape, faces, thickness, tolerance) {
+        return modifierOps.shell(this.k, this.Module, shape, faces, thickness, tolerance);
+    }
+    thicken(shape, thickness) {
+        return modifierOps.thicken(this.k, shape, thickness);
+    }
+    offset(shape, distance, tolerance) {
+        return modifierOps.offset(this.k, shape, distance, tolerance);
+    }
+    filletVariable(shape, spec) {
+        return modifierOps.filletVariable(this.k, shape, spec);
+    }
+    draft(shape, faces, pullDirection, neutralPlane, angleDeg) {
+        return modifierOps.draft(this.k, shape, faces, pullDirection, neutralPlane, angleDeg);
+    }
+    defeature(shape, faces) {
+        return modifierOps.defeature(this.k, this.Module, shape, faces);
+    }
+    offsetWire2D(wire, offset, joinType) {
+        return modifierOps.offsetWire2D(this.k, wire, offset, joinType);
+    }
+    simplify(shape) {
+        return modifierOps.simplify(this.k, shape);
+    }
+    reverseShape(shape) {
+        return modifierOps.reverseShape(this.k, shape);
+    }
+    // =========================================================================
+    // Transforms
+    // =========================================================================
+    composeTransform(ops) {
+        return transformOps.composeTransform(ops);
+    }
+    transform(shape, trsf) {
+        return transformOps.transform(this.k, this.Module, shape, trsf);
+    }
+    locate(shape, trsf) {
+        return transformOps.locate(this.k, this.Module, shape, trsf);
+    }
+    translate(shape, x, y, z) {
+        return transformOps.translate(this.k, shape, x, y, z);
+    }
+    rotate(shape, angle, axis, center) {
+        return transformOps.rotate(this.k, shape, angle, axis, center);
+    }
+    mirror(shape, origin, normal) {
+        return transformOps.mirror(this.k, shape, origin, normal);
+    }
+    scale(shape, center, factor) {
+        return transformOps.scale(this.k, shape, center, factor);
+    }
+    generalTransform(shape, linear, translation, isOrthogonal) {
+        return transformOps.generalTransform(this.k, this.Module, shape, linear, translation, isOrthogonal);
+    }
+    generalTransformNonOrthogonal(shape, linear, translation) {
+        return transformOps.generalTransform(this.k, this.Module, shape, linear, translation, false);
+    }
+    positionOnCurve(shape, spine, param) {
+        return transformOps.positionOnCurve(this.k, this.Module, shape, spine, param);
+    }
+    linearPattern(shape, direction, spacing, count) {
+        return transformOps.linearPattern(this.k, shape, direction, spacing, count);
+    }
+    circularPattern(shape, center, axis, angleStep, count) {
+        return transformOps.circularPattern(this.k, shape, center, axis, angleStep, count);
+    }
+    transformBatch(entries) {
+        return transformOps.transformBatch(this.k, entries);
+    }
+    // =========================================================================
+    // Evolution (operations with shape history)
+    // =========================================================================
+    translateWithHistory(shape, x, y, z, inputFaceHashes, hashUpperBound) {
+        return evolutionOps.translateWithHistory(this.k, this.Module, shape, x, y, z, inputFaceHashes, hashUpperBound);
+    }
+    rotateWithHistory(shape, angle, inputFaceHashes, hashUpperBound, axis, center) {
+        return evolutionOps.rotateWithHistory(this.k, this.Module, shape, angle, inputFaceHashes, hashUpperBound, axis, center);
+    }
+    mirrorWithHistory(shape, origin, normal, inputFaceHashes, hashUpperBound) {
+        return evolutionOps.mirrorWithHistory(this.k, this.Module, shape, origin, normal, inputFaceHashes, hashUpperBound);
+    }
+    scaleWithHistory(shape, center, factor, inputFaceHashes, hashUpperBound) {
+        return evolutionOps.scaleWithHistory(this.k, this.Module, shape, center, factor, inputFaceHashes, hashUpperBound);
+    }
+    generalTransformWithHistory(shape, linear, translation, isOrthogonal, inputFaceHashes, _hashUpperBound) {
+        return evolutionOps.generalTransformWithHistory((s, l, t, o) => this.generalTransform(s, l, t, o), shape, linear, translation, isOrthogonal, inputFaceHashes);
+    }
+    fuseWithHistory(shape, tool, inputFaceHashes, hashUpperBound, options) {
+        return evolutionOps.fuseWithHistory(this.k, this.Module, shape, tool, inputFaceHashes, hashUpperBound, options);
+    }
+    cutWithHistory(shape, tool, inputFaceHashes, hashUpperBound, options) {
+        return evolutionOps.cutWithHistory(this.k, this.Module, shape, tool, inputFaceHashes, hashUpperBound, options);
+    }
+    intersectWithHistory(shape, tool, inputFaceHashes, hashUpperBound, options) {
+        return evolutionOps.intersectWithHistory(this.k, this.Module, shape, tool, inputFaceHashes, hashUpperBound, options);
+    }
+    filletWithHistory(shape, edges, radius, inputFaceHashes, hashUpperBound) {
+        return evolutionOps.filletWithHistory(this.k, this.Module, shape, edges, radius, inputFaceHashes, hashUpperBound);
+    }
+    chamferWithHistory(shape, edges, distance, inputFaceHashes, hashUpperBound) {
+        return evolutionOps.chamferWithHistory(this.k, this.Module, shape, edges, distance, inputFaceHashes, hashUpperBound);
+    }
+    shellWithHistory(shape, faces, thickness, inputFaceHashes, hashUpperBound, tolerance) {
+        return evolutionOps.shellWithHistory(this.k, this.Module, shape, faces, thickness, inputFaceHashes, hashUpperBound, tolerance);
+    }
+    thickenWithHistory(shape, thickness, inputFaceHashes, hashUpperBound) {
+        return evolutionOps.thickenWithHistory(this.k, this.Module, shape, thickness, inputFaceHashes, hashUpperBound);
+    }
+    offsetWithHistory(shape, distance, inputFaceHashes, hashUpperBound, tolerance) {
+        return evolutionOps.offsetWithHistory(this.k, this.Module, shape, distance, inputFaceHashes, hashUpperBound, tolerance);
+    }
+    draftWithHistory(shape, faces, pullDirection, _neutralPlane, angleDeg, _inputFaceHashes, _hashUpperBound) {
+        return evolutionOps.draftWithHistory(this.k, shape, faces, pullDirection, angleDeg);
+    }
+    applyComposedTransformWithHistory(shape, transformHandle, inputFaceHashes, hashUpperBound) {
+        return evolutionOps.applyComposedTransformWithHistory((s, t) => this.transform(s, t), (s, t) => this.iterShapes(s, t), (s, ub) => this.hashCode(s, ub), shape, transformHandle, inputFaceHashes, hashUpperBound);
+    }
+    // =========================================================================
+    // Mesh operations
+    // =========================================================================
+    mesh(shape, options) {
+        return meshOps.mesh(this.k, this.Module, shape, options);
+    }
+    meshEdges(shape, tolerance, angularTolerance) {
+        return meshOps.meshEdges(this.k, this.Module, shape, tolerance, angularTolerance);
+    }
+    hasTriangulation(shape) {
+        return meshOps.hasTriangulation(this.k, shape);
+    }
+    meshShape(shape, tolerance, angularTolerance) {
+        meshOps.meshShape(this.k, shape, tolerance, angularTolerance);
+    }
+    // =========================================================================
+    // I/O
+    // =========================================================================
+    exportSTEP(shapes) {
+        return ioOps.exportSTEP(this.k, this.makeCompound.bind(this), shapes);
+    }
+    exportSTL(shape, binary, tolerance, angularTolerance) {
+        return ioOps.exportSTL(this.mesh.bind(this), shape, binary, tolerance, angularTolerance);
+    }
+    importSTEP(data) {
+        return ioOps.importSTEP(this.k, data);
+    }
+    importSTL(data) {
+        return ioOps.importSTL(this.k, this.Module, data);
+    }
+    exportIGES(shapes) {
+        return ioOps.exportIGES(this.k, this.makeCompound.bind(this), shapes);
+    }
+    importIGES(data) {
+        return ioOps.importIGES(this.k, data);
+    }
+    exportSTEPAssembly(parts, options) {
+        return ioOps.exportSTEPAssembly(this.k, this.Module, parts, options);
+    }
+    export3MF(_shape, _tolerance) {
+        throw new Error('export3MF is only available with the brepkit kernel');
+    }
+    exportGLB(shape, tolerance) {
+        return ioOps.exportGLB(this.mesh.bind(this), shape, tolerance);
+    }
+    exportOBJ(shape, tolerance) {
+        return ioOps.exportOBJ(this.mesh.bind(this), shape, tolerance);
+    }
+    exportPLY(shape, tolerance) {
+        return ioOps.exportPLY(this.mesh.bind(this), shape, tolerance);
+    }
+    import3MF(_data) {
+        throw new Error('import3MF is only available with the brepkit kernel');
+    }
+    importOBJ(_data) {
+        throw new Error('importOBJ is only available with the brepkit kernel');
+    }
+    importGLB(_data) {
+        throw new Error('importGLB is only available with the brepkit kernel');
+    }
+    toBREP(shape) {
+        return ioOps.toBREP(this.k, shape);
+    }
+    fromBREP(data) {
+        return ioOps.fromBREP(this.k, data);
+    }
+    createXCAFDocument(shapes) {
+        return ioOps.createXCAFDocument(this.k, this.Module, shapes);
+    }
+    writeXCAFToSTEP(doc, options) {
+        return ioOps.writeXCAFToSTEP(this.k, doc, options);
+    }
+    exportSTEPConfigured(shapes, options) {
+        return ioOps.exportSTEPConfigured(this.k, this.Module, shapes, options);
+    }
+    // =========================================================================
+    // Measure
+    // =========================================================================
+    volume(shape) {
+        return measureOps.volume(this.k, shape);
+    }
+    area(shape) {
+        return measureOps.area(this.k, shape);
+    }
+    length(shape) {
+        return measureOps.length(this.k, shape);
+    }
+    centerOfMass(shape) {
+        return measureOps.centerOfMass(this.k, shape);
+    }
+    linearCenterOfMass(shape) {
+        return measureOps.linearCenterOfMass(this.k, shape);
+    }
+    boundingBox(shape) {
+        return measureOps.boundingBox(this.k, shape);
+    }
+    distance(shape1, shape2) {
+        return measureOps.distance(this.k, this.Module, shape1, shape2);
+    }
+    surfaceCurvature(face, u, v) {
+        return measureOps.surfaceCurvature(this.k, face, u, v);
+    }
+    surfaceCenterOfMass(face) {
+        return measureOps.surfaceCenterOfMass(this.k, face);
+    }
+    measureBulk(shape, includeLinear) {
+        return measureOps.measureBulk(this.k, shape, includeLinear);
+    }
+    createDistanceQuery(referenceShape) {
+        return measureOps.createDistanceQuery(this.k, referenceShape);
+    }
+    // =========================================================================
+    // Topology
+    // =========================================================================
+    iterShapes(shape, type) {
+        return topoOps.iterShapes(this.k, shape, type);
+    }
+    iterShapeList(_list, _callback) {
+        // occt-wasm's arena model has no TopTools_ListOfShape equivalent — the
+        // kernel only yields individual u32 shape IDs, not list handles. Layer 2+
+        // code never calls this directly (evolution data comes from the C++
+        // facade's EvolutionExtractor, not the JS fallback path).
+        throw new Error('iterShapeList is not applicable to occt-wasm: the arena model has no TopTools_ListOfShape handles');
+    }
+    shapeType(shape) {
+        return topoOps.shapeType(this.k, shape);
+    }
+    isSame(a, b) {
+        return topoOps.isSame(this.k, a, b);
+    }
+    isEqual(a, b) {
+        return topoOps.isEqual(this.k, a, b);
+    }
+    downcast(shape, type) {
+        return topoOps.downcast(this.k, shape, type);
+    }
+    copyShape(shape) {
+        return topoOps.copyShape(this.k, shape);
+    }
+    hashCode(shape, upperBound) {
+        return topoOps.hashCode(this.k, shape, upperBound);
+    }
+    subShapeCount(shape, type) {
+        return topoOps.subShapeCount(this.k, shape, type);
+    }
+    subShapeHashes(shape, type, hashUpperBound) {
+        return topoOps.subShapeHashes(this.k, shape, type, hashUpperBound);
+    }
+    isNull(shape) {
+        return topoOps.isNull(this.k, shape);
+    }
+    shapeOrientation(shape) {
+        return topoOps.shapeOrientation(this.k, shape);
+    }
+    edgeToFaceMap(shape) {
+        return topoOps.edgeToFaceMap(this.k, shape);
+    }
+    sharedEdges(faceA, faceB) {
+        return topoOps.sharedEdges(this.k, faceA, faceB);
+    }
+    adjacentFaces(shape, face) {
+        return topoOps.adjacentFaces(this.k, shape, face);
+    }
+    sew(shapes, tolerance) {
+        return topoOps.sew(this.k, this.Module, shapes, tolerance);
+    }
+    // =========================================================================
+    // Curve operations
+    // =========================================================================
+    curveType(shape) {
+        return curveOps.curveType(this.k, shape);
+    }
+    curveParameters(shape) {
+        return curveOps.curveParameters(this.k, shape);
+    }
+    curvePointAtParam(shape, param) {
+        return curveOps.curvePointAtParam(this.k, shape, param);
+    }
+    curveTangent(shape, param) {
+        return curveOps.curveTangent(this.k, shape, param);
+    }
+    curveIsClosed(shape) {
+        return curveOps.curveIsClosed(this.k, shape);
+    }
+    curveIsPeriodic(shape) {
+        return curveOps.curveIsPeriodic(this.k, shape);
+    }
+    curvePeriod(shape) {
+        return curveOps.curvePeriod(this.k, shape);
+    }
+    interpolatePoints(points, options) {
+        return curveOps.interpolatePoints(this.k, this.Module, points, options);
+    }
+    approximatePoints(points, options) {
+        return curveOps.approximatePoints(this.k, this.Module, points, options);
+    }
+    // NURBS edit/construct + Bézier pole read, backed by the curve bindings added
+    // in occt-wasm 3.4.0 (andymai/occt-wasm#172). The edits copy the source curve
+    // C++-side, so the input edge is untouched.
+    curveDegreeElevate(edge, elevateBy) {
+        return curveOps.curveDegreeElevate(this.k, edge, elevateBy);
+    }
+    curveKnotInsert(edge, knot, times) {
+        return curveOps.curveKnotInsert(this.k, edge, knot, times);
+    }
+    curveKnotRemove(edge, knot, tolerance) {
+        return curveOps.curveKnotRemove(this.k, edge, knot, tolerance);
+    }
+    curveSplit(edge, param) {
+        return curveOps.curveSplit(this.k, edge, param);
+    }
+    getBezierPenultimatePole(edge) {
+        return curveOps.getBezierPenultimatePole(this.k, edge);
+    }
+    // N/A for the id-based API: callers evaluate curves via curvePointAtParam /
+    // curveTangent / curveParameters, so no raw BRepAdaptor object is needed.
+    createCurveAdaptor(_shape) {
+        notImplemented('createCurveAdaptor');
+    }
+    // =========================================================================
+    // Surface operations
+    // =========================================================================
+    vertexPosition(vertex) {
+        return surfaceOps.vertexPosition(this.k, vertex);
+    }
+    surfaceType(face) {
+        return surfaceOps.surfaceType(this.k, face);
+    }
+    uvBounds(face) {
+        return surfaceOps.uvBounds(this.k, face);
+    }
+    outerWire(face) {
+        return surfaceOps.outerWire(this.k, face);
+    }
+    surfaceNormal(face, u, v) {
+        return surfaceOps.surfaceNormal(this.k, face, u, v);
+    }
+    pointOnSurface(face, u, v) {
+        return surfaceOps.pointOnSurface(this.k, face, u, v);
+    }
+    uvFromPoint(face, point) {
+        return surfaceOps.uvFromPoint(this.k, face, point);
+    }
+    projectPointOnFace(face, point) {
+        return surfaceOps.projectPointOnFace(this.k, face, point);
+    }
+    classifyPointOnFace(face, u, v, tolerance) {
+        return surfaceOps.classifyPointOnFace(this.k, face, u, v, tolerance);
+    }
+    classifyPointRobust(_shape, _point, _tolerance) {
+        notImplemented('classifyPointRobust');
+    }
+    classifyPointWinding(_shape, _point, _tolerance) {
+        notImplemented('classifyPointWinding');
+    }
+    approximateSurfaceLspia(_coords, _rows, _cols, _degreeU, _degreeV, _numCpsU, _numCpsV, _tolerance, _maxIterations) {
+        notImplemented('approximateSurfaceLspia');
+    }
+    untrimFace(_face, _samplesPerCurve, _interiorSamples) {
+        notImplemented('untrimFace');
+    }
+    getSurfaceCylinderData(surface) {
+        // occt-wasm uses faces as surface proxies (see extractSurfaceFromFace).
+        return surfaceOps.getSurfaceCylinderData(this.k, surface);
+    }
+    getSurfaceAxis(face) {
+        return surfaceOps.getSurfaceAxis(this.k, face);
+    }
+    reverseSurfaceU(surface) {
+        return surfaceOps.reverseSurfaceU(this.k, surface);
+    }
+    detectSmallFeatures(_shape, _areaThreshold, _tolerance) {
+        notImplemented('detectSmallFeatures');
+    }
+    recognizeFeatures(_shape, _tolerance) {
+        notImplemented('recognizeFeatures');
+    }
+    projectEdges(shape, cameraOrigin, cameraDirection, cameraXAxis) {
+        return surfaceOps.projectEdges(this.k, this.Module, shape, cameraOrigin, cameraDirection, cameraXAxis);
+    }
+    // =========================================================================
+    // Repair
+    // =========================================================================
+    isValid(shape) {
+        return repairOps.isValid(this.k, shape);
+    }
+    healSolid(shape) {
+        return repairOps.healSolid(this.k, shape);
+    }
+    healFace(shape) {
+        return repairOps.healFace(this.k, shape);
+    }
+    healWire(wire, face) {
+        return repairOps.healWire(this.k, wire, face);
+    }
+    mergeCoincidentVertices(shape, tolerance) {
+        return repairOps.mergeCoincidentVertices(this.k, shape, tolerance);
+    }
+    removeDegenerateEdges(shape, tolerance) {
+        return repairOps.removeDegenerateEdges(this.k, shape, tolerance);
+    }
+    fixFaceOrientations(shape) {
+        return repairOps.fixFaceOrientations(this.k, shape);
+    }
+    fixShape(shape) {
+        return repairOps.fixShape(this.k, shape);
+    }
+    fixSelfIntersection(wire) {
+        // occt-wasm exposes no standalone ShapeFix_Wire::FixSelfIntersection; healWire
+        // runs the ShapeFix_Wire heal (which includes self-intersection repair).
+        return repairOps.healWire(this.k, wire);
+    }
+    // =========================================================================
+    // 2D operations (not implemented -- occt-wasm doesn't expose 2D API)
+    // =========================================================================
+    createPoint2d(x, y) {
+        return kernel2dOps.createPoint2d(x, y);
+    }
+    createDirection2d(x, y) {
+        return kernel2dOps.createDirection2d(x, y);
+    }
+    createVector2d(x, y) {
+        return kernel2dOps.createVector2d(x, y);
+    }
+    createAxis2d(px, py, dx, dy) {
+        return kernel2dOps.createAxis2d(px, py, dx, dy);
+    }
+    wrapCurve2dHandle(h) {
+        return kernel2dOps.wrapCurve2dHandle(h);
+    }
+    createCurve2dAdaptor(_handle) {
+        notImplemented('createCurve2dAdaptor');
+    }
+    makeLine2d(x1, y1, x2, y2) {
+        return kernel2dOps.makeLine2d(x1, y1, x2, y2);
+    }
+    makeCircle2d(cx, cy, radius, sense) {
+        return kernel2dOps.makeCircle2d(cx, cy, radius, sense);
+    }
+    makeArc2dThreePoints(x1, y1, xm, ym, x2, y2) {
+        return kernel2dOps.makeArc2dThreePoints(x1, y1, xm, ym, x2, y2);
+    }
+    makeArc2dTangent(startX, startY, tangentX, tangentY, endX, endY) {
+        return kernel2dOps.makeArc2dTangent(startX, startY, tangentX, tangentY, endX, endY);
+    }
+    makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense) {
+        return kernel2dOps.makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense);
+    }
+    makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense) {
+        return kernel2dOps.makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense);
+    }
+    makeBezier2d(points) {
+        return kernel2dOps.makeBezier2d(points);
+    }
+    makeBSpline2d(points, _options) {
+        return kernel2dOps.makeBSpline2d(points);
+    }
+    evaluateCurve2d(curve, param) {
+        return kernel2dOps.evaluateCurve2d(curve, param);
+    }
+    evaluateCurve2dD1(curve, param) {
+        return kernel2dOps.evaluateCurve2dD1(curve, param);
+    }
+    getCurve2dBounds(curve) {
+        return kernel2dOps.getCurve2dBounds(curve);
+    }
+    getCurve2dType(curve) {
+        return kernel2dOps.getCurve2dType(curve);
+    }
+    trimCurve2d(curve, start, end) {
+        return kernel2dOps.trimCurve2d(curve, start, end);
+    }
+    reverseCurve2d(curve) {
+        kernel2dOps.reverseCurve2d(curve);
+    }
+    copyCurve2d(curve) {
+        return kernel2dOps.copyCurve2d(curve);
+    }
+    offsetCurve2d(curve, offset) {
+        return kernel2dOps.offsetCurve2d(curve, offset);
+    }
+    translateCurve2d(curve, dx, dy) {
+        return kernel2dOps.translateCurve2d(curve, dx, dy);
+    }
+    rotateCurve2d(curve, angle, cx, cy) {
+        return kernel2dOps.rotateCurve2d(curve, angle, cx, cy);
+    }
+    scaleCurve2d(curve, factor, cx, cy) {
+        return kernel2dOps.scaleCurve2d(curve, factor, cx, cy);
+    }
+    mirrorCurve2dAtPoint(curve, cx, cy) {
+        return kernel2dOps.mirrorCurve2dAtPoint(curve, cx, cy);
+    }
+    mirrorCurve2dAcrossAxis(curve, originX, originY, dirX, dirY) {
+        return kernel2dOps.mirrorCurve2dAcrossAxis(curve, originX, originY, dirX, dirY);
+    }
+    affinityTransform2d(curve, axisOriginX, axisOriginY, axisDirX, axisDirY, ratio) {
+        return kernel2dOps.affinityTransform2d(curve, axisOriginX, axisOriginY, axisDirX, axisDirY, ratio);
+    }
+    createIdentityGTrsf2d() {
+        return kernel2dOps.createIdentityGTrsf2d();
+    }
+    createAffinityGTrsf2d(originX, originY, dirX, dirY, ratio) {
+        return kernel2dOps.createAffinityGTrsf2d(originX, originY, dirX, dirY, ratio);
+    }
+    createTranslationGTrsf2d(dx, dy) {
+        return kernel2dOps.createTranslationGTrsf2d(dx, dy);
+    }
+    createMirrorGTrsf2d(cx, cy, mode, originX, originY, dirX, dirY) {
+        return kernel2dOps.createMirrorGTrsf2d(cx, cy, mode, originX, originY, dirX, dirY);
+    }
+    createRotationGTrsf2d(angle, cx, cy) {
+        return kernel2dOps.createRotationGTrsf2d(angle, cx, cy);
+    }
+    createScaleGTrsf2d(factor, cx, cy) {
+        return kernel2dOps.createScaleGTrsf2d(factor, cx, cy);
+    }
+    setGTrsf2dTranslationPart(gtrsf, dx, dy) {
+        kernel2dOps.setGTrsf2dTranslationPart(gtrsf, dx, dy);
+    }
+    multiplyGTrsf2d(base, other) {
+        kernel2dOps.multiplyGTrsf2d(base, other);
+    }
+    transformCurve2dGeneral(curve, gtrsf) {
+        return kernel2dOps.transformCurve2dGeneral(curve, gtrsf);
+    }
+    intersectCurves2d(c1, c2, tolerance) {
+        return kernel2dOps.intersectCurves2d(c1, c2, tolerance);
+    }
+    projectPointOnCurve2d(curve, x, y) {
+        return kernel2dOps.projectPointOnCurve2d(curve, x, y);
+    }
+    distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End) {
+        return kernel2dOps.distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End);
+    }
+    approximateCurve2dAsBSpline(curve, _tolerance, _continuity, maxSegments) {
+        return kernel2dOps.approximateCurve2dAsBSpline(curve, maxSegments);
+    }
+    decomposeBSpline2dToBeziers(curve) {
+        return kernel2dOps.decomposeBSpline2dToBeziers(curve);
+    }
+    createBoundingBox2d() {
+        return kernel2dOps.createBoundingBox2d();
+    }
+    addCurveToBBox2d(bbox, curve, tolerance) {
+        kernel2dOps.addCurveToBBox2d(bbox, curve, tolerance);
+    }
+    getBBox2dBounds(bbox) {
+        return kernel2dOps.getBBox2dBounds(bbox);
+    }
+    mergeBBox2d(target, other) {
+        kernel2dOps.mergeBBox2d(target, other);
+    }
+    isBBox2dOut(a, b) {
+        return kernel2dOps.isBBox2dOut(a, b);
+    }
+    isBBox2dOutPoint(bbox, x, y) {
+        return kernel2dOps.isBBox2dOutPoint(bbox, x, y);
+    }
+    getCurve2dCircleData(curve) {
+        return kernel2dOps.getCurve2dCircleData(curve);
+    }
+    getCurve2dEllipseData(curve) {
+        return kernel2dOps.getCurve2dEllipseData(curve);
+    }
+    getCurve2dBezierPoles(curve) {
+        return kernel2dOps.getCurve2dBezierPoles(curve);
+    }
+    getCurve2dBezierDegree(curve) {
+        return kernel2dOps.getCurve2dBezierDegree(curve);
+    }
+    getCurve2dBSplineData(_curve) {
+        notImplemented('getCurve2dBSplineData');
+    }
+    serializeCurve2d(curve) {
+        return kernel2dOps.serializeCurve2d(curve);
+    }
+    deserializeCurve2d(data) {
+        return kernel2dOps.deserializeCurve2d(data);
+    }
+    splitCurve2d(curve, params) {
+        return kernel2dOps.splitCurve2d(curve, params);
+    }
+    liftCurve2dToPlane(curve, planeOrigin, planeZ, planeX) {
+        return kernel2dOps.liftCurve2dToPlane(this.k, this.Module, curve, planeOrigin, planeZ, planeX);
+    }
+    buildEdgeOnSurface(curve, surface) {
+        return kernel2dOps.buildEdgeOnSurface(this.k, this.Module, curve, surface);
+    }
+    extractSurfaceFromFace(face) {
+        return kernel2dOps.extractSurfaceFromFace(face);
+    }
+    extractCurve2dFromEdge(edge, face) {
+        return kernel2dOps.extractCurve2dFromEdge(this.k, edge, face);
+    }
+    buildCurves3d(wire) {
+        kernel2dOps.buildCurves3d(this.k, wire);
+    }
+    fixWireOnFace(wire, face, tolerance) {
+        return kernel2dOps.fixWireOnFace(this.k, wire, face, tolerance);
+    }
+    fillSurface(_wires, _options) {
+        notImplemented('fillSurface');
+    }
+    // =========================================================================
+    // Optional interfaces (return undefined to signal not supported)
+    // =========================================================================
+    // KernelRepairOps.validationDetails is not on the interface but brepkit has it
+    getNurbsCurveData(edge) {
+        return curveOps.getNurbsCurveData(this.k, edge);
+    }
+}
+//# sourceMappingURL=occtWasmAdapter.js.map