@faicad/faijs 0.31.1 → 0.32.2

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

@@ -1,1016 +0,0 @@
-/**
- * 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