occt-wasm 3.3.1 → 3.4.0

package/dist/index.js

@@ -18,23 +18,31 @@ export { XCAFDocument } from "./xcaf-document.js";
 import { XCAFDocument as XCAFDocumentImpl } from "./xcaf-document.js";
 export { renderMultiviewSVG, renderShapeSVG, } from "./svg.js";
 import { renderMultiviewSVG as renderMultiviewSVGImpl, renderShapeSVG as renderShapeSVGImpl, } from "./svg.js";
-import { JoinType, OcctError, SweepMode, TransitionMode } from "./types.js";
+import { JoinType, SweepMode, TransitionMode, wrap } from "./types.js";
+import { SHAPE_TYPES, SHAPE_ORIENTATIONS, POINT_CLASSIFICATIONS } from "./types.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 function handle(id) {
     return id;
 }
-function wrap(operation, fn) {
-    try {
-        return fn();
-    }
-    catch (e) {
-        if (e instanceof Error) {
-            throw new OcctError(operation, e.message);
-        }
-        throw new OcctError(operation, String(e));
+// Allowed values for the closed string-union enums returned by the kernel,
+// derived from the single source of truth in types.ts so they can't drift.
+// (SurfaceKind/CurveKind are open unions — `string & {}` — so any string is
+// valid by design and needs no check.)
+const SHAPE_TYPE_VALUES = new Set(SHAPE_TYPES);
+const SHAPE_ORIENTATION_VALUES = new Set(SHAPE_ORIENTATIONS);
+const POINT_CLASSIFICATION_VALUES = new Set(POINT_CLASSIFICATIONS);
+/**
+ * Coerce a raw kernel string into a closed union, throwing if the kernel ever
+ * returns an unexpected value instead of silently casting it into a lie. Called
+ * inside `wrap(...)`, so the throw surfaces as a classified `OcctError`.
+ */
+function asEnum(value, allowed, label) {
+    if (!allowed.has(value)) {
+        throw new Error(`unexpected ${label} from kernel: "${value}"`);
     }
+    return value;
 }
 /**
  * Safety net: releases the raw Embind kernel if an OcctKernel instance is
@@ -203,26 +211,14 @@ export class OcctKernel {
      * @throws OcctError */
     fuseAll(shapes) {
         return wrap("fuseAll", () => {
-            const vec = this.#makeVectorU32(shapes);
-            try {
-                return handle(this.#raw.fuseAll(vec));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(shapes, (vec) => handle(this.#raw.fuseAll(vec)));
         });
     }
     /** 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();
-            }
+            return this.#withU32(tools, (vec) => handle(this.#raw.cutAll(shape, vec)));
         });
     }
     /** Split a shape using tool shapes as splitting surfaces (BOPAlgo_Splitter).
@@ -230,13 +226,7 @@ export class OcctKernel {
      * @throws OcctError */
     split(shape, tools) {
         return wrap("split", () => {
-            const vec = this.#makeVectorU32(tools);
-            try {
-                return handle(this.#raw.split(shape, vec));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(tools, (vec) => handle(this.#raw.split(shape, vec)));
         });
     }
     /**
@@ -246,13 +236,7 @@ export class OcctKernel {
      */
     intersectionCells(shapes) {
         return wrap("intersectionCells", () => {
-            const vec = this.#makeVectorU32(shapes);
-            try {
-                return handle(this.#raw.intersectionCells(vec));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(shapes, (vec) => handle(this.#raw.intersectionCells(vec)));
         });
     }
     // =======================================================================
@@ -277,35 +261,17 @@ export class OcctKernel {
      * @throws OcctError */
     fillet(solid, edges, radius) {
         return wrap("fillet", () => {
-            const vec = this.#makeVectorU32(edges);
-            try {
-                return handle(this.#raw.fillet(solid, vec, radius));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(edges, (vec) => handle(this.#raw.fillet(solid, vec, radius)));
         });
     }
     chamfer(solid, edges, distance) {
         return wrap("chamfer", () => {
-            const vec = this.#makeVectorU32(edges);
-            try {
-                return handle(this.#raw.chamfer(solid, vec, distance));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(edges, (vec) => handle(this.#raw.chamfer(solid, vec, distance)));
         });
     }
     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();
-            }
+            return this.#withU32(edges, (vec) => handle(this.#raw.chamferDistAngle(solid, vec, distance, angleDeg)));
         });
     }
     /**
@@ -319,13 +285,7 @@ export class OcctKernel {
      */
     shell(solid, facesToRemove, thickness, tolerance) {
         return wrap("shell", () => {
-            const vec = this.#makeVectorU32(facesToRemove);
-            try {
-                return handle(this.#raw.shell(solid, vec, thickness, tolerance));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(facesToRemove, (vec) => handle(this.#raw.shell(solid, vec, thickness, tolerance)));
         });
     }
     /**
@@ -359,24 +319,12 @@ export class OcctKernel {
      */
     loft(wires, isSolid, ruled) {
         return wrap("loft", () => {
-            const vec = this.#makeVectorU32(wires);
-            try {
-                return handle(this.#raw.loft(vec, isSolid, ruled));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(wires, (vec) => handle(this.#raw.loft(vec, isSolid, ruled)));
         });
     }
     loftWithVertices(wires, isSolid, ruled, startVertex, endVertex) {
         return wrap("loftWithVertices", () => {
-            const vec = this.#makeVectorU32(wires);
-            try {
-                return handle(this.#raw.loftWithVertices(vec, isSolid, ruled, startVertex, endVertex));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(wires, (vec) => handle(this.#raw.loftWithVertices(vec, isSolid, ruled, startVertex, endVertex)));
         });
     }
     sweep(wire, spine, transitionMode = TransitionMode.Transformed) {
@@ -435,6 +383,9 @@ export class OcctKernel {
             }
         });
     }
+    makeBSplineEdge(poles, weights, knots, multiplicities, degree, periodic = false) {
+        return wrap("makeBSplineEdge", () => this.#withF64(poles, (polesVec) => this.#withF64(weights, (weightsVec) => this.#withF64(knots, (knotsVec) => this.#withI32(multiplicities, (multsVec) => handle(this.#raw.makeBSplineEdge(polesVec, weightsVec, knotsVec, multsVec, degree, periodic)))))));
+    }
     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)));
     }
@@ -443,13 +394,7 @@ export class OcctKernel {
     }
     makeWire(edges) {
         return wrap("makeWire", () => {
-            const vec = this.#makeVectorU32(edges);
-            try {
-                return handle(this.#raw.makeWire(vec));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(edges, (vec) => handle(this.#raw.makeWire(vec)));
         });
     }
     makeFace(wire) {
@@ -460,24 +405,12 @@ export class OcctKernel {
     }
     addHolesInFace(face, holeWires) {
         return wrap("addHolesInFace", () => {
-            const vec = this.#makeVectorU32(holeWires);
-            try {
-                return handle(this.#raw.addHolesInFace(face, vec));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(holeWires, (vec) => handle(this.#raw.addHolesInFace(face, vec)));
         });
     }
     removeHolesFromFace(face, holeIndices) {
         return wrap("removeHolesFromFace", () => {
-            const vec = this.#makeVectorI32(holeIndices);
-            try {
-                return handle(this.#raw.removeHolesFromFace(face, vec));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withI32(holeIndices, (vec) => handle(this.#raw.removeHolesFromFace(face, vec)));
         });
     }
     makeSolid(shell) {
@@ -485,46 +418,22 @@ export class OcctKernel {
     }
     sew(shapes, tolerance = 1e-6) {
         return wrap("sew", () => {
-            const vec = this.#makeVectorU32(shapes);
-            try {
-                return handle(this.#raw.sew(vec, tolerance));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(shapes, (vec) => handle(this.#raw.sew(vec, tolerance)));
         });
     }
     sewAndSolidify(faces, tolerance = 1e-6) {
         return wrap("sewAndSolidify", () => {
-            const vec = this.#makeVectorU32(faces);
-            try {
-                return handle(this.#raw.sewAndSolidify(vec, tolerance));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(faces, (vec) => handle(this.#raw.sewAndSolidify(vec, tolerance)));
         });
     }
     buildSolidFromFaces(faces, tolerance = 1e-6) {
         return wrap("buildSolidFromFaces", () => {
-            const vec = this.#makeVectorU32(faces);
-            try {
-                return handle(this.#raw.buildSolidFromFaces(vec, tolerance));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(faces, (vec) => handle(this.#raw.buildSolidFromFaces(vec, tolerance)));
         });
     }
     makeCompound(shapes) {
         return wrap("makeCompound", () => {
-            const vec = this.#makeVectorU32(shapes);
-            try {
-                return handle(this.#raw.makeCompound(vec));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(shapes, (vec) => handle(this.#raw.makeCompound(vec)));
         });
     }
     buildTriFace(a, b, c) {
@@ -584,25 +493,13 @@ export class OcctKernel {
     /** 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();
-            }
+            return this.#withF64(matrix, (vec) => handle(this.#raw.transform(shape, vec)));
         });
     }
     /** 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();
-            }
+            return this.#withF64(matrix, (vec) => handle(this.#raw.generalTransform(shape, vec)));
         });
     }
     linearPattern(shape, direction, spacing, count) {
@@ -613,158 +510,64 @@ export class OcctKernel {
     }
     /** 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);
-                return this.#drainVector(result, Float64Array);
-            }
-            finally {
-                v1.delete();
-                v2.delete();
-            }
-        });
+        return wrap("composeTransform", () => this.#withF64(m1, (v1) => this.#withF64(m2, (v2) => this.#drainVector(this.#raw.composeTransform(v1, v2), Float64Array))));
     }
     // =======================================================================
     // 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 this.#vecToHandles(result);
-            }
-            finally {
-                ids.delete();
-                off.delete();
-            }
-        });
+        return wrap("translateBatch", () => this.#withU32(shapes, (ids) => this.#withF64(offsets, (off) => this.#vecToHandles(this.#raw.translateBatch(ids, off)))));
     }
     /** 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();
-            }
-        });
+        return wrap("booleanPipeline", () => this.#withI32(opCodes, (ops) => this.#withU32(tools, (ids) => handle(this.#raw.booleanPipeline(base, ops, ids)))));
     }
     /** Query multiple shapes in a single WASM call: bbox, volume, area, center of mass, type, validity. */
     queryBatch(shapes) {
-        return wrap("queryBatch", () => {
-            const ids = this.#makeVectorU32(shapes);
-            try {
-                const raw = this.#raw.queryBatch(ids);
-                const arr = this.#drainVector(raw, Float64Array);
-                const STRIDE = 14;
-                const SHAPE_TYPES = ["compound", "compsolid", "solid", "shell", "face", "wire", "edge", "vertex", "shape"];
-                const results = [];
-                for (let i = 0; i < shapes.length; i++) {
-                    const o = i * STRIDE;
-                    results.push({
-                        volume: arr[o],
-                        area: arr[o + 1],
-                        bbox: { xmin: arr[o + 2], ymin: arr[o + 3], zmin: arr[o + 4], xmax: arr[o + 5], ymax: arr[o + 6], zmax: arr[o + 7] },
-                        centerOfMass: { x: arr[o + 8], y: arr[o + 9], z: arr[o + 10] },
-                        shapeType: SHAPE_TYPES[arr[o + 11]] ?? "shape",
-                        isValid: arr[o + 12] === 1.0,
-                    });
-                }
-                return results;
-            }
-            finally {
-                ids.delete();
-            }
-        });
+        return wrap("queryBatch", () => this.#withU32(shapes, (ids) => {
+            const arr = this.#drainVector(this.#raw.queryBatch(ids), Float64Array);
+            const STRIDE = 14;
+            const results = [];
+            for (let i = 0; i < shapes.length; i++) {
+                const o = i * STRIDE;
+                results.push({
+                    volume: arr[o],
+                    area: arr[o + 1],
+                    bbox: { xmin: arr[o + 2], ymin: arr[o + 3], zmin: arr[o + 4], xmax: arr[o + 5], ymax: arr[o + 6], zmax: arr[o + 7] },
+                    centerOfMass: { x: arr[o + 8], y: arr[o + 9], z: arr[o + 10] },
+                    shapeType: SHAPE_TYPES[arr[o + 11]] ?? "shape",
+                    isValid: arr[o + 12] === 1.0,
+                });
+            }
+            return results;
+        }));
     }
     /** Fillet multiple solids in a single WASM call. */
     filletBatch(ops) {
-        return wrap("filletBatch", () => {
-            const solids = this.#makeVectorU32(ops.map(op => op.solid));
-            const edgeCounts = this.#makeVectorI32(ops.map(op => op.edges.length));
-            const flatEdges = this.#makeVectorU32(ops.flatMap(op => op.edges));
-            const radii = this.#makeVectorF64(ops.map(op => op.radius));
-            try {
-                return this.#vecToHandles(this.#raw.filletBatch(solids, edgeCounts, flatEdges, radii));
-            }
-            finally {
-                solids.delete();
-                edgeCounts.delete();
-                flatEdges.delete();
-                radii.delete();
-            }
-        });
+        return wrap("filletBatch", () => this.#withU32(ops.map((op) => op.solid), (solids) => this.#withI32(ops.map((op) => op.edges.length), (edgeCounts) => this.#withU32(ops.flatMap((op) => op.edges), (flatEdges) => this.#withF64(ops.map((op) => op.radius), (radii) => this.#vecToHandles(this.#raw.filletBatch(solids, edgeCounts, flatEdges, radii)))))));
     }
     /** Apply 3x4 affine transforms to multiple shapes in a single WASM call. */
     transformBatch(shapes, matrices) {
-        return wrap("transformBatch", () => {
-            const ids = this.#makeVectorU32(shapes);
-            const mats = this.#makeVectorF64(matrices);
-            try {
-                return this.#vecToHandles(this.#raw.transformBatch(ids, mats));
-            }
-            finally {
-                ids.delete();
-                mats.delete();
-            }
-        });
+        return wrap("transformBatch", () => this.#withU32(shapes, (ids) => this.#withF64(matrices, (mats) => this.#vecToHandles(this.#raw.transformBatch(ids, mats)))));
     }
     /** Rotate multiple shapes in a single WASM call. */
     rotateBatch(shapes, params) {
-        return wrap("rotateBatch", () => {
-            const ids = this.#makeVectorU32(shapes);
-            const p = this.#makeVectorF64(params);
-            try {
-                return this.#vecToHandles(this.#raw.rotateBatch(ids, p));
-            }
-            finally {
-                ids.delete();
-                p.delete();
-            }
-        });
+        return wrap("rotateBatch", () => this.#withU32(shapes, (ids) => this.#withF64(params, (p) => this.#vecToHandles(this.#raw.rotateBatch(ids, p)))));
     }
     /** Scale multiple shapes in a single WASM call. */
     scaleBatch(shapes, params) {
-        return wrap("scaleBatch", () => {
-            const ids = this.#makeVectorU32(shapes);
-            const p = this.#makeVectorF64(params);
-            try {
-                return this.#vecToHandles(this.#raw.scaleBatch(ids, p));
-            }
-            finally {
-                ids.delete();
-                p.delete();
-            }
-        });
+        return wrap("scaleBatch", () => this.#withU32(shapes, (ids) => this.#withF64(params, (p) => this.#vecToHandles(this.#raw.scaleBatch(ids, p)))));
     }
     /** Mirror multiple shapes in a single WASM call. */
     mirrorBatch(shapes, params) {
-        return wrap("mirrorBatch", () => {
-            const ids = this.#makeVectorU32(shapes);
-            const p = this.#makeVectorF64(params);
-            try {
-                return this.#vecToHandles(this.#raw.mirrorBatch(ids, p));
-            }
-            finally {
-                ids.delete();
-                p.delete();
-            }
-        });
+        return wrap("mirrorBatch", () => this.#withU32(shapes, (ids) => this.#withF64(params, (p) => this.#vecToHandles(this.#raw.mirrorBatch(ids, p)))));
     }
     // =======================================================================
     // Topology
     // =======================================================================
     getShapeType(shape) {
-        return wrap("getShapeType", () => this.#raw.getShapeType(shape));
+        return wrap("getShapeType", () => asEnum(this.#raw.getShapeType(shape), SHAPE_TYPE_VALUES, "shape type"));
     }
     /** True if the shape is a compound. */
     isCompound(shape) { return this.getShapeType(shape) === "compound"; }
@@ -804,7 +607,7 @@ export class OcctKernel {
         return wrap("hashCode", () => this.#raw.hashCode(shape, upperBound));
     }
     shapeOrientation(shape) {
-        return wrap("shapeOrientation", () => this.#raw.shapeOrientation(shape));
+        return wrap("shapeOrientation", () => asEnum(this.#raw.shapeOrientation(shape), SHAPE_ORIENTATION_VALUES, "shape orientation"));
     }
     sharedEdges(faceA, faceB) {
         return wrap("sharedEdges", () => this.#vecToHandles(this.#raw.sharedEdges(faceA, faceB)));
@@ -864,35 +667,29 @@ export class OcctKernel {
     }
     /** Tessellate multiple shapes in a single WASM call. */
     meshBatch(shapes, options) {
-        return wrap("meshBatch", () => {
-            const ids = this.#makeVectorU32(shapes);
+        return wrap("meshBatch", () => this.#withU32(shapes, (ids) => {
             const linDefl = options?.linearDeflection ?? 0.1;
             const angDefl = options?.angularDeflection ?? 0.5;
+            const raw = this.#raw.meshBatch(ids, linDefl, angDefl);
             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();
-                }
+                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 {
-                ids.delete();
+                raw.delete();
             }
-        });
+        }));
     }
     // =======================================================================
     // I/O
@@ -944,16 +741,18 @@ export class OcctKernel {
         });
     }
     cacheStep(stepData) {
-        const shape = this.importStep(stepData);
-        try {
-            return this.toBREP(shape);
-        }
-        finally {
-            this.release(shape);
-        }
+        return wrap("cacheStep", () => {
+            const shape = this.importStep(stepData);
+            try {
+                return this.toBREP(shape);
+            }
+            finally {
+                this.release(shape);
+            }
+        });
     }
     loadCached(brep) {
-        return this.fromBREP(brep);
+        return wrap("loadCached", () => this.fromBREP(brep));
     }
     // =======================================================================
     // Query / Measure
@@ -1088,7 +887,7 @@ export class OcctKernel {
     }
     /** Classify a UV point relative to a face boundary. */
     classifyPointOnFace(face, u, v) {
-        return wrap("classifyPointOnFace", () => this.#raw.classifyPointOnFace(face, u, v));
+        return wrap("classifyPointOnFace", () => asEnum(this.#raw.classifyPointOnFace(face, u, v), POINT_CLASSIFICATION_VALUES, "point classification"));
     }
     /** Create a BSpline surface from a grid of control points. */
     bsplineSurface(controlPoints, rows, cols) {
@@ -1199,6 +998,24 @@ export class OcctKernel {
             return result;
         });
     }
+    curveDegreeElevate(edge, elevateBy) {
+        return wrap("curveDegreeElevate", () => handle(this.#raw.curveDegreeElevate(edge, elevateBy)));
+    }
+    curveKnotInsert(edge, knot, times) {
+        return wrap("curveKnotInsert", () => handle(this.#raw.curveKnotInsert(edge, knot, times)));
+    }
+    curveKnotRemove(edge, knot, tolerance) {
+        return wrap("curveKnotRemove", () => handle(this.#raw.curveKnotRemove(edge, knot, tolerance)));
+    }
+    curveSplit(edge, param) {
+        return wrap("curveSplit", () => {
+            const parts = this.#vecToHandles(this.#raw.curveSplit(edge, param));
+            if (parts.length !== 2) {
+                throw new Error(`curveSplit: expected 2 edges, got ${parts.length}`);
+            }
+            return [parts[0], parts[1]];
+        });
+    }
     liftCurve2dToPlane(points2d, planeOrigin, planeZ, planeX) {
         return wrap("liftCurve2dToPlane", () => {
             const flatArr = new Array(points2d.length * 2);
@@ -1207,13 +1024,7 @@ export class OcctKernel {
                 flatArr[j++] = p.x;
                 flatArr[j++] = p.y;
             }
-            const flat = this.#makeVectorF64(flatArr);
-            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();
-            }
+            return this.#withF64(flatArr, (flat) => handle(this.#raw.liftCurve2dToPlane(flat, planeOrigin.x, planeOrigin.y, planeOrigin.z, planeZ.x, planeZ.y, planeZ.z, planeX.x, planeX.y, planeX.z)));
         });
     }
     // =======================================================================
@@ -1273,13 +1084,7 @@ export class OcctKernel {
      */
     defeature(shape, faces, tolerance) {
         return wrap("defeature", () => {
-            const vec = this.#makeVectorU32(faces);
-            try {
-                return handle(this.#raw.defeature(shape, vec, tolerance));
-            }
-            finally {
-                vec.delete();
-            }
+            return this.#withU32(faces, (vec) => handle(this.#raw.defeature(shape, vec, tolerance)));
         });
     }
     reverseShape(shape) {
@@ -1300,140 +1105,50 @@ export class OcctKernel {
     // =======================================================================
     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();
-            }
+            return this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.translateWithHistory(shape, dx, dy, dz, hashes, hashUpperBound)));
         });
     }
     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();
-            }
+            return this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.fuseWithHistory(a, b, hashes, hashUpperBound)));
         });
     }
     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();
-            }
+            return this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.cutWithHistory(a, b, hashes, hashUpperBound)));
         });
     }
     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();
-            }
-        });
+        return wrap("filletWithHistory", () => this.#withU32(edges, (edgeVec) => this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.filletWithHistory(solid, edgeVec, radius, hashes, hashUpperBound)))));
     }
     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();
-            }
-        });
+        return wrap("rotateWithHistory", () => this.#withI32(inputFaceHashes, (hashes) => 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))));
     }
     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();
-            }
-        });
+        return wrap("mirrorWithHistory", () => this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.mirrorWithHistory(shape, point.x, point.y, point.z, normal.x, normal.y, normal.z, hashes, hashUpperBound))));
     }
     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();
-            }
-        });
+        return wrap("scaleWithHistory", () => this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.scaleWithHistory(shape, center.x, center.y, center.z, factor, hashes, hashUpperBound))));
     }
     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();
-            }
+            return this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.intersectWithHistory(a, b, hashes, hashUpperBound)));
         });
     }
     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();
-            }
-        });
+        return wrap("chamferWithHistory", () => this.#withU32(edges, (edgeVec) => this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.chamferWithHistory(solid, edgeVec, distance, hashes, hashUpperBound)))));
     }
     shellWithHistory(solid, faces, thickness, tolerance, 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, tolerance, hashes, hashUpperBound));
-            }
-            finally {
-                faceVec.delete();
-                hashes.delete();
-            }
-        });
+        return wrap("shellWithHistory", () => this.#withU32(faces, (faceVec) => this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.shellWithHistory(solid, faceVec, thickness, tolerance, hashes, hashUpperBound)))));
     }
     offsetWithHistory(solid, distance, tolerance, inputFaceHashes, hashUpperBound) {
         return wrap("offsetWithHistory", () => {
-            const hashes = this.#makeVectorI32(inputFaceHashes);
-            try {
-                return this.#extractEvolution(this.#raw.offsetWithHistory(solid, distance, tolerance, hashes, hashUpperBound));
-            }
-            finally {
-                hashes.delete();
-            }
+            return this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.offsetWithHistory(solid, distance, tolerance, hashes, hashUpperBound)));
         });
     }
     thickenWithHistory(shape, thickness, tolerance, inputFaceHashes, hashUpperBound) {
         return wrap("thickenWithHistory", () => {
-            const hashes = this.#makeVectorI32(inputFaceHashes);
-            try {
-                return this.#extractEvolution(this.#raw.thickenWithHistory(shape, thickness, tolerance, hashes, hashUpperBound));
-            }
-            finally {
-                hashes.delete();
-            }
+            return this.#withI32(inputFaceHashes, (hashes) => this.#extractEvolution(this.#raw.thickenWithHistory(shape, thickness, tolerance, hashes, hashUpperBound)));
         });
     }
     // =======================================================================
@@ -1672,6 +1387,36 @@ export class OcctKernel {
         }
         return this.#bulkI32(values);
     }
+    // Scope guards: build a vector, run `fn` with it, and always delete it.
+    // Replaces the make/try/finally/delete boilerplate at every vector-arg call
+    // site so the cleanup can't be forgotten or mis-copied.
+    #withU32(ids, fn) {
+        const vec = this.#makeVectorU32(ids);
+        try {
+            return fn(vec);
+        }
+        finally {
+            vec.delete();
+        }
+    }
+    #withF64(values, fn) {
+        const vec = this.#makeVectorF64(values);
+        try {
+            return fn(vec);
+        }
+        finally {
+            vec.delete();
+        }
+    }
+    #withI32(values, fn) {
+        const vec = this.#makeVectorI32(values);
+        try {
+            return fn(vec);
+        }
+        finally {
+            vec.delete();
+        }
+    }
     #flattenPoints(points) {
         if (points.length * 3 < _a.#BULK_THRESHOLD) {
             const vec = new this.#module.VectorDouble();