brepjs 2.0.0 → 2.0.1

package/dist/brepjs.cjs

@@ -1,5 +1,5 @@
 "use strict";
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
@@ -46,6 +46,13 @@ var __callDispose = (stack, error, hasError) => {
 };
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const opentype = require("opentype.js");
+let _counter = 0;
+function uniqueIOFilename(prefix, ext) {
+  return `${prefix}_${++_counter}.${ext}`;
+}
+function uniqueId() {
+  return `_io_${++_counter}`;
+}
 const HASH_CODE_MAX$1 = 2147483647;
 class OCCTAdapter {
   oc;
@@ -78,9 +85,10 @@ class OCCTAdapter {
     return result;
   }
   intersect(shape, tool, options = {}) {
-    const { simplify = false } = options;
+    const { optimisation, simplify = false } = options;
     const progress = new this.oc.Message_ProgressRange_1();
     const commonOp = new this.oc.BRepAlgoAPI_Common_3(shape, tool, progress);
+    this._applyGlue(commonOp, optimisation);
     commonOp.Build(progress);
     if (simplify) commonOp.SimplifyResult(true, true, 1e-3);
     const result = commonOp.Shape();
@@ -154,7 +162,9 @@ class OCCTAdapter {
       return this._cutAllBatch(shape, tools, options);
     }
     const toolCompound = this._buildCompound(tools);
-    return this.cut(shape, toolCompound, options);
+    const result = this.cut(shape, toolCompound, options);
+    toolCompound.delete();
+    return result;
   }
   _cutAllBatch(shape, tools, options = {}) {
     const { optimisation, simplify = false } = options;
@@ -568,37 +578,157 @@ class OCCTAdapter {
     explorer.delete();
     return { vertices, normals, triangles, faceGroups };
   }
-  meshEdges(shape, tolerance = 1e-3) {
-    const edgeLines = [];
-    const explorer = new this.oc.TopExp_Explorer_2(
+  meshEdges(shape, tolerance, angularTolerance) {
+    if (this.oc.EdgeMeshExtractor) {
+      return this._meshEdgesBulk(shape, tolerance, angularTolerance);
+    }
+    return this._meshEdgesJS(shape, tolerance, angularTolerance);
+  }
+  _meshEdgesBulk(shape, tolerance, angularTolerance) {
+    const raw = this.oc.EdgeMeshExtractor.extract(shape, tolerance, angularTolerance);
+    const linesSize = raw.getLinesSize();
+    const edgeGroupsSize = raw.getEdgeGroupsSize();
+    let lines;
+    if (linesSize > 0) {
+      const linesPtr = raw.getLinesPtr() / 4;
+      lines = this.oc.HEAPF32.slice(linesPtr, linesPtr + linesSize);
+    } else {
+      lines = new Float32Array(0);
+    }
+    const edgeGroups = [];
+    if (edgeGroupsSize > 0) {
+      const egPtr = raw.getEdgeGroupsPtr() / 4;
+      const egRaw = this.oc.HEAP32.slice(egPtr, egPtr + edgeGroupsSize);
+      for (let i = 0; i < egRaw.length; i += 3) {
+        edgeGroups.push({
+          start: egRaw[i],
+          count: egRaw[i + 1],
+          edgeHash: egRaw[i + 2]
+        });
+      }
+    }
+    raw.delete();
+    return { lines, edgeGroups };
+  }
+  _meshEdgesJS(shape, tolerance, angularTolerance) {
+    const mesher = new this.oc.BRepMesh_IncrementalMesh_2(
+      shape,
+      tolerance,
+      false,
+      angularTolerance,
+      false
+    );
+    mesher.delete();
+    const lines = [];
+    const edgeGroups = [];
+    const seenHashes = /* @__PURE__ */ new Set();
+    const faceExplorer = new this.oc.TopExp_Explorer_2(
+      shape,
+      this.oc.TopAbs_ShapeEnum.TopAbs_FACE,
+      this.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+    );
+    while (faceExplorer.More()) {
+      const face = this.oc.TopoDS.Face_1(faceExplorer.Current());
+      const faceLoc = new this.oc.TopLoc_Location_1();
+      const tri = this.oc.BRep_Tool.Triangulation(face, faceLoc, 0);
+      if (!tri.IsNull()) {
+        const triObj = tri.get();
+        const edgeExplorer2 = new this.oc.TopExp_Explorer_2(
+          face,
+          this.oc.TopAbs_ShapeEnum.TopAbs_EDGE,
+          this.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+        );
+        while (edgeExplorer2.More()) {
+          const edgeShape = edgeExplorer2.Current();
+          const edge = this.oc.TopoDS.Edge_1(edgeShape);
+          const edgeHash = edge.HashCode(HASH_CODE_MAX$1);
+          if (!seenHashes.has(edgeHash)) {
+            seenHashes.add(edgeHash);
+            const edgeLoc = new this.oc.TopLoc_Location_1();
+            const polygon = this.oc.BRep_Tool.PolygonOnTriangulation_1(edge, tri, edgeLoc);
+            const edgeNodes = polygon && !polygon.IsNull() ? polygon.get().Nodes() : null;
+            if (edgeNodes) {
+              const lineStart = lines.length / 3;
+              let prevX = 0, prevY = 0, prevZ = 0;
+              let hasPrev = false;
+              for (let i = edgeNodes.Lower(); i <= edgeNodes.Upper(); i++) {
+                const p = triObj.Node(edgeNodes.Value(i)).Transformed(edgeLoc.Transformation());
+                const x = p.X(), y = p.Y(), z = p.Z();
+                if (hasPrev) {
+                  lines.push(prevX, prevY, prevZ, x, y, z);
+                }
+                prevX = x;
+                prevY = y;
+                prevZ = z;
+                hasPrev = true;
+                p.delete();
+              }
+              edgeGroups.push({
+                start: lineStart,
+                count: lines.length / 3 - lineStart,
+                edgeHash
+              });
+              edgeNodes.delete();
+            }
+            if (polygon && !polygon.IsNull()) polygon.delete();
+            edgeLoc.delete();
+          }
+          edgeExplorer2.Next();
+        }
+        edgeExplorer2.delete();
+      }
+      tri.delete();
+      faceLoc.delete();
+      faceExplorer.Next();
+    }
+    faceExplorer.delete();
+    const edgeExplorer = new this.oc.TopExp_Explorer_2(
       shape,
       this.oc.TopAbs_ShapeEnum.TopAbs_EDGE,
       this.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
     );
-    while (explorer.More()) {
-      const edge = explorer.Current();
-      const adaptor = new this.oc.BRepAdaptor_Curve_2(edge);
-      const tangDef = new this.oc.GCPnts_TangentialDeflection_2(
-        adaptor,
-        tolerance,
-        0.1,
-        2,
-        1e-9,
-        1e-7
-      );
-      const points = [];
-      for (let j = 1; j <= tangDef.NbPoints(); j++) {
-        const p = tangDef.Value(j);
-        points.push(p.X(), p.Y(), p.Z());
-        p.delete();
+    while (edgeExplorer.More()) {
+      const edgeShape = edgeExplorer.Current();
+      const edge = this.oc.TopoDS.Edge_1(edgeShape);
+      const edgeHash = edge.HashCode(HASH_CODE_MAX$1);
+      if (!seenHashes.has(edgeHash)) {
+        seenHashes.add(edgeHash);
+        const adaptor = new this.oc.BRepAdaptor_Curve_2(edge);
+        const tangDef = new this.oc.GCPnts_TangentialDeflection_2(
+          adaptor,
+          tolerance,
+          angularTolerance,
+          2,
+          1e-9,
+          1e-7
+        );
+        const lineStart = lines.length / 3;
+        let prevX = 0, prevY = 0, prevZ = 0;
+        let hasPrev = false;
+        for (let j = 1; j <= tangDef.NbPoints(); j++) {
+          const p = tangDef.Value(j);
+          const x = p.X(), y = p.Y(), z = p.Z();
+          if (hasPrev) {
+            lines.push(prevX, prevY, prevZ, x, y, z);
+          }
+          prevX = x;
+          prevY = y;
+          prevZ = z;
+          hasPrev = true;
+          p.delete();
+        }
+        edgeGroups.push({
+          start: lineStart,
+          count: lines.length / 3 - lineStart,
+          edgeHash
+        });
+        tangDef.delete();
+        adaptor.delete();
       }
-      edgeLines.push(new Float32Array(points));
-      tangDef.delete();
-      adaptor.delete();
-      explorer.Next();
+      edgeExplorer.Next();
     }
-    explorer.delete();
-    return edgeLines;
+    edgeExplorer.delete();
+    return { lines: new Float32Array(lines), edgeGroups };
   }
   // --- File I/O ---
   exportSTEP(shapes) {
@@ -609,7 +739,7 @@ class OCCTAdapter {
     for (const shape of shapes) {
       writer.Transfer(shape, this.oc.STEPControl_StepModelType.STEPControl_AsIs, true, progress);
     }
-    const filename = "_export.step";
+    const filename = uniqueIOFilename("_export", "step");
     const done = writer.Write(filename);
     writer.delete();
     progress.delete();
@@ -621,7 +751,7 @@ class OCCTAdapter {
     throw new Error("STEP export failed: writer did not complete successfully");
   }
   exportSTL(shape, binary = false) {
-    const filename = "_export.stl";
+    const filename = uniqueIOFilename("_export", "stl");
     const done = this.oc.StlAPI.Write(shape, filename, !binary);
     if (done) {
       const file = this.oc.FS.readFile("/" + filename);
@@ -632,7 +762,7 @@ class OCCTAdapter {
     throw new Error("STL export failed: StlAPI.Write returned false");
   }
   importSTEP(data) {
-    const filename = "_import.step";
+    const filename = uniqueIOFilename("_import", "step");
     const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
     this.oc.FS.writeFile("/" + filename, buffer);
     const reader = new this.oc.STEPControl_Reader_1();
@@ -650,7 +780,7 @@ class OCCTAdapter {
     throw new Error("Failed to import STEP file: reader could not parse the input data");
   }
   importSTL(data) {
-    const filename = "_import.stl";
+    const filename = uniqueIOFilename("_import", "stl");
     const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
     this.oc.FS.writeFile("/" + filename, buffer);
     const reader = new this.oc.StlAPI_Reader();
@@ -663,12 +793,14 @@ class OCCTAdapter {
       const solidBuilder = new this.oc.BRepBuilderAPI_MakeSolid_1();
       solidBuilder.Add(this.oc.TopoDS.Shell_1(upgraded));
       const solid = solidBuilder.Solid();
+      readShape.delete();
       upgrader.delete();
       solidBuilder.delete();
       reader.delete();
       return solid;
     }
     this.oc.FS.unlink("/" + filename);
+    readShape.delete();
     reader.delete();
     throw new Error("Failed to import STL file: reader could not parse the input data");
   }
@@ -721,6 +853,32 @@ class OCCTAdapter {
   }
   // --- Topology iteration ---
   iterShapes(shape, type) {
+    if (this.oc.TopologyExtractor) {
+      return this._iterShapesBulk(shape, type);
+    }
+    return this._iterShapesJS(shape, type);
+  }
+  _iterShapesBulk(shape, type) {
+    const typeEnumMap = {
+      vertex: 7,
+      edge: 6,
+      wire: 5,
+      face: 4,
+      shell: 3,
+      solid: 2,
+      compsolid: 1,
+      compound: 0
+    };
+    const raw = this.oc.TopologyExtractor.extract(shape, typeEnumMap[type]);
+    const count = raw.getShapesCount();
+    const result = [];
+    for (let i = 0; i < count; i++) {
+      result.push(raw.getShape(i));
+    }
+    raw.delete();
+    return result;
+  }
+  _iterShapesJS(shape, type) {
     const typeMap = {
       vertex: this.oc.TopAbs_ShapeEnum.TopAbs_VERTEX,
       edge: this.oc.TopAbs_ShapeEnum.TopAbs_EDGE,
@@ -1064,14 +1222,6 @@ function localGC(debug) {
     debug ? cleaner : void 0
   ];
 }
-if (!globalThis.FinalizationRegistry) {
-  console.warn("brepjs: FinalizationRegistry unavailable — garbage collection will not work");
-  globalThis.FinalizationRegistry = (() => ({
-    register: () => null,
-    unregister: () => null
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- polyfill shim
-  }));
-}
 const deletableRegistry = new globalThis.FinalizationRegistry((heldValue) => {
   try {
     heldValue.delete();
@@ -1155,7 +1305,7 @@ function vecDistance(a, b) {
 }
 function vecNormalize(v) {
   const len = vecLength(v);
-  if (len === 0) return [0, 0, 0];
+  if (len < 1e-10) return [0, 0, 0];
   return [v[0] / len, v[1] / len, v[2] / len];
 }
 function vecEquals(a, b, tolerance = 1e-5) {
@@ -1284,42 +1434,46 @@ const makeAx3 = (center, dir, xDir) => {
   const oc = getKernel().oc;
   const origin = asPnt(center);
   const direction = asDir(dir);
-  let axis;
-  if (xDir) {
-    const xDirection = asDir(xDir);
-    axis = new oc.gp_Ax3_3(origin, direction, xDirection);
-    xDirection.delete();
-  } else {
-    axis = new oc.gp_Ax3_4(origin, direction);
+  const xDirection = xDir ? asDir(xDir) : null;
+  try {
+    if (xDirection) {
+      return new oc.gp_Ax3_3(origin, direction, xDirection);
+    } else {
+      return new oc.gp_Ax3_4(origin, direction);
+    }
+  } finally {
+    origin.delete();
+    direction.delete();
+    if (xDirection) xDirection.delete();
   }
-  origin.delete();
-  direction.delete();
-  return axis;
 };
 const makeAx2 = (center, dir, xDir) => {
   const oc = getKernel().oc;
   const origin = asPnt(center);
   const direction = asDir(dir);
-  let axis;
-  if (xDir) {
-    const xDirection = asDir(xDir);
-    axis = new oc.gp_Ax2_2(origin, direction, xDirection);
-    xDirection.delete();
-  } else {
-    axis = new oc.gp_Ax2_3(origin, direction);
+  const xDirection = xDir ? asDir(xDir) : null;
+  try {
+    if (xDirection) {
+      return new oc.gp_Ax2_2(origin, direction, xDirection);
+    } else {
+      return new oc.gp_Ax2_3(origin, direction);
+    }
+  } finally {
+    origin.delete();
+    direction.delete();
+    if (xDirection) xDirection.delete();
   }
-  origin.delete();
-  direction.delete();
-  return axis;
 };
 const makeAx1 = (center, dir) => {
   const oc = getKernel().oc;
   const origin = asPnt(center);
   const direction = asDir(dir);
-  const axis = new oc.gp_Ax1_2(origin, direction);
-  origin.delete();
-  direction.delete();
-  return axis;
+  try {
+    return new oc.gp_Ax1_2(origin, direction);
+  } finally {
+    origin.delete();
+    direction.delete();
+  }
 };
 const makeVec = (vector = [0, 0, 0]) => {
   const oc = getKernel().oc;
@@ -1586,24 +1740,24 @@ class Plane {
     const dir = makeDirection(direction);
     const zDir = new Vector(this.zDir).rotate(angle, [0, 0, 0], dir);
     const xDir = new Vector(this.xDir).rotate(angle, [0, 0, 0], dir);
-    const result = new Plane(this.origin, xDir, zDir);
-    zDir.delete();
-    xDir.delete();
-    return result;
+    try {
+      return new Plane(this.origin, xDir, zDir);
+    } finally {
+      zDir.delete();
+      xDir.delete();
+    }
   }
   rotate2DAxes(angle) {
     const xDir = new Vector(this.xDir).rotate(angle, [0, 0, 0], this.zDir);
-    const result = new Plane(this.origin, xDir, this.zDir);
-    xDir.delete();
-    return result;
+    try {
+      return new Plane(this.origin, xDir, this.zDir);
+    } finally {
+      xDir.delete();
+    }
   }
   _calcTransforms() {
     if (this.globalToLocal) this.globalToLocal.delete();
     if (this.localToGlobal) this.localToGlobal.delete();
-    const _globalCoordSystem = new this.oc.gp_Ax3_1();
-    const _localCoordSystem = makeAx3(this.origin, this.zDir, this.xDir);
-    const _forwardT = new this.oc.gp_Trsf_1();
-    _forwardT.SetTransformation_1(_globalCoordSystem, _localCoordSystem);
     this.globalToLocal = new Transformation();
     this.globalToLocal.coordSystemChange("reference", {
       origin: this.origin,
@@ -1619,9 +1773,6 @@ class Plane {
       },
       "reference"
     );
-    _globalCoordSystem.delete();
-    _localCoordSystem.delete();
-    _forwardT.delete();
   }
   setOrigin2d(x, y) {
     this.origin = this.toWorldCoords([x, y]);
@@ -1715,19 +1866,18 @@ class BoundingBox extends WrappingObj {
   }
 }
 const makePlaneFromFace = (face, originOnSurface = [0, 0]) => {
-  const originPoint = face.pointOnSurface(...originOnSurface);
-  const normal = face.normalAt(originPoint);
-  const v = new Vector([0, 0, 1]);
+  const [r, gc] = localGC();
+  const originPoint = r(face.pointOnSurface(...originOnSurface));
+  const normal = r(face.normalAt(originPoint));
+  const v = r(new Vector([0, 0, 1]));
   let xd = v.cross(normal);
   if (xd.Length < 1e-8) {
     xd.delete();
     xd = new Vector([1, 0, 0]);
   }
-  v.delete();
+  r(xd);
   const plane = new Plane(originPoint, xd, normal);
-  originPoint.delete();
-  normal.delete();
-  xd.delete();
+  gc();
   return plane;
 };
 function makePlane(plane = "XY", origin = [0, 0, 0]) {
@@ -1738,31 +1888,35 @@ function makePlane(plane = "XY", origin = [0, 0, 0]) {
   }
 }
 function rotate(shape, angle, position = [0, 0, 0], direction = [0, 0, 1]) {
-  const transformation = new Transformation();
+  const [r, gc] = localGC();
+  const transformation = r(new Transformation());
   transformation.rotate(angle, position, direction);
   const newShape = transformation.transform(shape);
-  transformation.delete();
+  gc();
   return newShape;
 }
 function translate(shape, vector) {
-  const transformation = new Transformation();
+  const [r, gc] = localGC();
+  const transformation = r(new Transformation());
   transformation.translate(vector);
   const newShape = transformation.transform(shape);
-  transformation.delete();
+  gc();
   return newShape;
 }
 function mirror(shape, inputPlane, origin) {
-  const transformation = new Transformation();
+  const [r, gc] = localGC();
+  const transformation = r(new Transformation());
   transformation.mirror(inputPlane, origin);
   const newShape = transformation.transform(shape);
-  transformation.delete();
+  gc();
   return newShape;
 }
 function scale(shape, center, scaleFactor) {
-  const transformation = new Transformation();
+  const [r, gc] = localGC();
+  const transformation = r(new Transformation());
   transformation.scale(center, scaleFactor);
   const newShape = transformation.transform(shape);
-  transformation.delete();
+  gc();
   return newShape;
 }
 let CURVE_TYPES_MAP = null;
@@ -1789,6 +1943,149 @@ const findCurveType = (type) => {
   if (!shapeType2) return err(typeCastError("UNKNOWN_CURVE_TYPE", "Unknown curve type"));
   return ok(shapeType2);
 };
+function buildMeshCacheKey(_shapeHash, tolerance, angularTolerance, skipNormals) {
+  return `${tolerance}:${angularTolerance}:${skipNormals}`;
+}
+function buildEdgeMeshCacheKey(_shapeHash, tolerance, angularTolerance) {
+  return `edge:${tolerance}:${angularTolerance}`;
+}
+let meshCache = /* @__PURE__ */ new WeakMap();
+let edgeMeshCache = /* @__PURE__ */ new WeakMap();
+function getMeshForShape(shape, key) {
+  const shapeCache = meshCache.get(shape);
+  if (!shapeCache) return void 0;
+  return shapeCache.get(key);
+}
+function setMeshForShape(shape, key, value) {
+  let shapeCache = meshCache.get(shape);
+  if (!shapeCache) {
+    shapeCache = /* @__PURE__ */ new Map();
+    meshCache.set(shape, shapeCache);
+  }
+  shapeCache.set(key, value);
+}
+function getEdgeMeshForShape(shape, key) {
+  const shapeCache = edgeMeshCache.get(shape);
+  if (!shapeCache) return void 0;
+  return shapeCache.get(key);
+}
+function setEdgeMeshForShape(shape, key, value) {
+  let shapeCache = edgeMeshCache.get(shape);
+  if (!shapeCache) {
+    shapeCache = /* @__PURE__ */ new Map();
+    edgeMeshCache.set(shape, shapeCache);
+  }
+  shapeCache.set(key, value);
+}
+function clearMeshCache() {
+  meshCache = /* @__PURE__ */ new WeakMap();
+  edgeMeshCache = /* @__PURE__ */ new WeakMap();
+}
+function setMeshCacheSize(_size) {
+}
+function meshShape(shape, {
+  tolerance = 1e-3,
+  angularTolerance = 0.1,
+  skipNormals = false,
+  cache = true
+} = {}) {
+  const cacheKey = buildMeshCacheKey(0, tolerance, angularTolerance, skipNormals);
+  if (cache) {
+    const cached = getMeshForShape(shape.wrapped, cacheKey);
+    if (cached) return cached;
+  }
+  const result = getKernel().mesh(shape.wrapped, {
+    tolerance,
+    angularTolerance,
+    skipNormals
+  });
+  const mesh = {
+    vertices: result.vertices,
+    normals: result.normals,
+    triangles: result.triangles,
+    faceGroups: result.faceGroups.map((g) => ({
+      start: g.start,
+      count: g.count,
+      faceId: g.faceHash
+    }))
+  };
+  if (cache) {
+    setMeshForShape(shape.wrapped, cacheKey, mesh);
+  }
+  return mesh;
+}
+function meshShapeEdges(shape, { tolerance = 1e-3, angularTolerance = 0.1, cache = true } = {}) {
+  const cacheKey = buildEdgeMeshCacheKey(0, tolerance, angularTolerance);
+  if (cache) {
+    const cached = getEdgeMeshForShape(shape.wrapped, cacheKey);
+    if (cached) return cached;
+  }
+  const kernelResult = getKernel().meshEdges(shape.wrapped, tolerance, angularTolerance);
+  const result = {
+    lines: Array.from(kernelResult.lines),
+    edgeGroups: kernelResult.edgeGroups.map((g) => ({
+      start: g.start,
+      count: g.count,
+      edgeId: g.edgeHash
+    }))
+  };
+  if (cache) {
+    setEdgeMeshForShape(shape.wrapped, cacheKey, result);
+  }
+  return result;
+}
+function exportSTEP$1(shape) {
+  const oc = getKernel().oc;
+  const filename = uniqueIOFilename("_blob", "step");
+  const writer = new oc.STEPControl_Writer_1();
+  const progress = new oc.Message_ProgressRange_1();
+  try {
+    oc.Interface_Static.SetIVal("write.step.schema", 5);
+    writer.Model(true).delete();
+    writer.Transfer(shape.wrapped, oc.STEPControl_StepModelType.STEPControl_AsIs, true, progress);
+    const done = writer.Write(filename);
+    if (done === oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
+      try {
+        const file = oc.FS.readFile("/" + filename);
+        oc.FS.unlink("/" + filename);
+        return ok(new Blob([file], { type: "application/STEP" }));
+      } catch (e) {
+        return err(ioError("STEP_FILE_READ_ERROR", "Failed to read exported STEP file", e));
+      }
+    }
+    return err(ioError("STEP_EXPORT_FAILED", "Failed to write STEP file"));
+  } finally {
+    writer.delete();
+    progress.delete();
+  }
+}
+function exportSTL(shape, {
+  tolerance = 1e-3,
+  angularTolerance = 0.1,
+  binary = false
+} = {}) {
+  const oc = getKernel().oc;
+  const mesher = new oc.BRepMesh_IncrementalMesh_2(
+    shape.wrapped,
+    tolerance,
+    false,
+    angularTolerance,
+    false
+  );
+  mesher.delete();
+  const filename = uniqueIOFilename("_blob", "stl");
+  const done = oc.StlAPI.Write(shape.wrapped, filename, !binary);
+  if (done) {
+    try {
+      const file = oc.FS.readFile("/" + filename);
+      oc.FS.unlink("/" + filename);
+      return ok(new Blob([file], { type: "application/sla" }));
+    } catch (e) {
+      return err(ioError("STL_FILE_READ_ERROR", "Failed to read exported STL file", e));
+    }
+  }
+  return err(ioError("STL_EXPORT_FAILED", "Failed to write STL file"));
+}
 let _shapesModule = null;
 function getShapesModuleSync() {
   if (!_shapesModule) {
@@ -1817,23 +2114,23 @@ const asTopo = (entity) => {
   }[entity];
 };
 const iterTopo = function* iterTopo2(shape, topo) {
-  const oc = getKernel().oc;
-  const explorer = new oc.TopExp_Explorer_2(shape, asTopo(topo), asTopo("shape"));
-  const seen = /* @__PURE__ */ new Map();
-  while (explorer.More()) {
-    const item = explorer.Current();
-    const hash = item.HashCode(HASH_CODE_MAX);
-    const bucket = seen.get(hash);
-    if (!bucket) {
-      seen.set(hash, [item]);
-      yield item;
-    } else if (!bucket.some((s) => s.IsSame(item))) {
-      bucket.push(item);
-      yield item;
-    }
-    explorer.Next();
+  const topoToShapeType = {
+    vertex: "vertex",
+    edge: "edge",
+    wire: "wire",
+    face: "face",
+    shell: "shell",
+    solid: "solid",
+    solidCompound: "compsolid",
+    compound: "compound",
+    shape: "compound"
+    // fallback; 'shape' isn't used in iterShapes
+  };
+  const shapeType2 = topoToShapeType[topo];
+  if (shapeType2) {
+    const shapes = getKernel().iterShapes(shape, shapeType2);
+    for (const s of shapes) yield s;
   }
-  explorer.delete();
 };
 const shapeType = (shape) => {
   if (shape.IsNull()) return err(typeCastError("NULL_SHAPE", "This shape has no type, it is null"));
@@ -2067,7 +2364,14 @@ class Shape extends WrappingObj {
     return bbox;
   }
   _mesh({ tolerance = 1e-3, angularTolerance = 0.1 } = {}) {
-    new this.oc.BRepMesh_IncrementalMesh_2(this.wrapped, tolerance, false, angularTolerance, false);
+    const mesher = new this.oc.BRepMesh_IncrementalMesh_2(
+      this.wrapped,
+      tolerance,
+      false,
+      angularTolerance,
+      false
+    );
+    mesher.delete();
   }
   /**
    * Exports the current shape as a set of triangles for rendering.
@@ -2100,93 +2404,12 @@ class Shape extends WrappingObj {
    *
    * @category Shape Export
    */
-  meshEdges({ tolerance = 1e-3, angularTolerance = 0.1 } = {}) {
-    const r = gcWithScope();
-    const recordedEdges = /* @__PURE__ */ new Set();
-    const lines = [];
-    const edgeGroups = [];
-    const addEdge = () => {
-      const start = lines.length;
-      let prevX = 0;
-      let prevY = 0;
-      let prevZ = 0;
-      let hasPrev = false;
-      return [
-        (p) => {
-          const x = p.X();
-          const y = p.Y();
-          const z = p.Z();
-          if (hasPrev) {
-            lines.push(prevX, prevY, prevZ, x, y, z);
-          }
-          prevX = x;
-          prevY = y;
-          prevZ = z;
-          hasPrev = true;
-        },
-        (edgeHash) => {
-          edgeGroups.push({
-            start: start / 3,
-            count: (lines.length - start) / 3,
-            edgeId: edgeHash
-          });
-          recordedEdges.add(edgeHash);
-        }
-      ];
-    };
-    const aLocation = r(new this.oc.TopLoc_Location_1());
-    const faces = this.faces;
-    for (const face of faces) {
-      const triangulation = r(this.oc.BRep_Tool.Triangulation(face.wrapped, aLocation, 0));
-      if (triangulation.IsNull()) {
-        continue;
-      }
-      const tri = triangulation.get();
-      const faceEdges = face.edges;
-      for (const edge of faceEdges) {
-        r(edge);
-        if (recordedEdges.has(edge.hashCode)) continue;
-        const edgeLoc = r(new this.oc.TopLoc_Location_1());
-        const polygon = r(
-          this.oc.BRep_Tool.PolygonOnTriangulation_1(edge.wrapped, triangulation, edgeLoc)
-        );
-        const edgeNodes = polygon?.get()?.Nodes();
-        if (!edgeNodes) {
-          continue;
-        }
-        r(edgeNodes);
-        const [recordPoint, done] = addEdge();
-        for (let i = edgeNodes.Lower(); i <= edgeNodes.Upper(); i++) {
-          const p = r(r(tri.Node(edgeNodes.Value(i))).Transformed(edgeLoc.Transformation()));
-          recordPoint(p);
-        }
-        done(edge.hashCode);
-      }
-    }
-    const allEdges = this.edges;
-    for (const edge of allEdges) {
-      r(edge);
-      const edgeHash = edge.hashCode;
-      if (recordedEdges.has(edgeHash)) continue;
-      const adaptorCurve = r(new this.oc.BRepAdaptor_Curve_2(edge.wrapped));
-      const tangDef = r(
-        new this.oc.GCPnts_TangentialDeflection_2(
-          adaptorCurve,
-          tolerance,
-          angularTolerance,
-          2,
-          1e-9,
-          1e-7
-        )
-      );
-      const [recordPoint, done] = addEdge();
-      for (let j = 0; j < tangDef.NbPoints(); j++) {
-        const p = r(tangDef.Value(j + 1).Transformed(aLocation.Transformation()));
-        recordPoint(p);
-      }
-      done(edgeHash);
-    }
-    return { lines, edgeGroups };
+  meshEdges({
+    tolerance = 1e-3,
+    angularTolerance = 0.1,
+    cache = true
+  } = {}) {
+    return meshShapeEdges(this, { tolerance, angularTolerance, cache });
   }
   /**
    * Exports the current shape as a STEP file Blob.
@@ -2194,7 +2417,7 @@ class Shape extends WrappingObj {
    * @category Shape Export
    */
   blobSTEP() {
-    const filename = "blob.step";
+    const filename = uniqueIOFilename("_blob", "step");
     const writer = new this.oc.STEPControl_Writer_1();
     this.oc.Interface_Static.SetIVal("write.step.schema", 5);
     writer.Model(true).delete();
@@ -2228,7 +2451,7 @@ class Shape extends WrappingObj {
    */
   blobSTL({ tolerance = 1e-3, angularTolerance = 0.1, binary = false } = {}) {
     this._mesh({ tolerance, angularTolerance });
-    const filename = "blob.stl";
+    const filename = uniqueIOFilename("_blob", "stl");
     const done = this.oc.StlAPI.Write(this.wrapped, filename, !binary);
     if (done) {
       try {
@@ -2312,28 +2535,52 @@ class _1DShape extends Shape {
     return new Curve(this._geomAdaptor());
   }
   get startPoint() {
-    return this.curve.startPoint;
+    const c = this.curve;
+    const result = c.startPoint;
+    c.delete();
+    return result;
   }
   get endPoint() {
-    return this.curve.endPoint;
+    const c = this.curve;
+    const result = c.endPoint;
+    c.delete();
+    return result;
   }
   tangentAt(position = 0) {
-    return this.curve.tangentAt(position);
+    const c = this.curve;
+    const result = c.tangentAt(position);
+    c.delete();
+    return result;
   }
   pointAt(position = 0) {
-    return this.curve.pointAt(position);
+    const c = this.curve;
+    const result = c.pointAt(position);
+    c.delete();
+    return result;
   }
   get isClosed() {
-    return this.curve.isClosed;
+    const c = this.curve;
+    const result = c.isClosed;
+    c.delete();
+    return result;
   }
   get isPeriodic() {
-    return this.curve.isPeriodic;
+    const c = this.curve;
+    const result = c.isPeriodic;
+    c.delete();
+    return result;
   }
   get period() {
-    return this.curve.period;
+    const c = this.curve;
+    const result = c.period;
+    c.delete();
+    return result;
   }
   get geomType() {
-    return this.curve.curveType;
+    const c = this.curve;
+    const result = c.curveType;
+    c.delete();
+    return result;
   }
   get length() {
     const properties = new this.oc.GProp_GProps_1();
@@ -2425,11 +2672,13 @@ class Face extends Shape {
   }
   get geomType() {
     const surface = this.surface;
-    const geomType = unwrap(surface.surfaceType);
-    surface.delete();
-    return geomType;
-  }
-  get UVBounds() {
+    try {
+      return unwrap(surface.surfaceType);
+    } finally {
+      surface.delete();
+    }
+  }
+  get UVBounds() {
     const uMin = { current: 0 };
     const uMax = { current: 0 };
     const vMin = { current: 0 };
@@ -2891,7 +3140,13 @@ function zip(arrays) {
 }
 const makeLine = (v1, v2) => {
   const oc = getKernel().oc;
-  return new Edge(new oc.BRepBuilderAPI_MakeEdge_3(asPnt(v1), asPnt(v2)).Edge());
+  const [r, gc] = localGC();
+  const p1 = r(asPnt(v1));
+  const p2 = r(asPnt(v2));
+  const maker = r(new oc.BRepBuilderAPI_MakeEdge_3(p1, p2));
+  const edge = new Edge(maker.Edge());
+  gc();
+  return edge;
 };
 const makeCircle = (radius, center = [0, 0, 0], normal = [0, 0, 1]) => {
   const oc = getKernel().oc;
@@ -2930,8 +3185,8 @@ const makeHelix = (pitch, height, radius, center = [0, 0, 0], dir = [0, 0, 1], l
     new oc.Geom2d_Line_3(r(new oc.gp_Pnt2d_3(0, 0)), r(new oc.gp_Dir2d_4(myDir, pitch)))
   );
   const nTurns = height / pitch;
-  const uStart = geomLine.Value(0);
-  const uStop = geomLine.Value(nTurns * Math.sqrt((2 * Math.PI) ** 2 + pitch ** 2));
+  const uStart = r(geomLine.Value(0));
+  const uStop = r(geomLine.Value(nTurns * Math.sqrt((2 * Math.PI) ** 2 + pitch ** 2)));
   const geomSeg = r(new oc.GCE2d_MakeSegment_1(uStart, uStop));
   const geomSurf = new oc.Geom_CylindricalSurface_1(r(makeAx3(center, dir)), radius);
   const e = r(
@@ -2947,9 +3202,17 @@ const makeHelix = (pitch, height, radius, center = [0, 0, 0], dir = [0, 0, 1], l
 };
 const makeThreePointArc = (v1, v2, v3) => {
   const oc = getKernel().oc;
-  const circleGeom = new oc.GC_MakeArcOfCircle_4(asPnt(v1), asPnt(v2), asPnt(v3)).Value();
-  const curve = new oc.Handle_Geom_Curve_2(circleGeom.get());
-  return new Edge(new oc.BRepBuilderAPI_MakeEdge_24(curve).Edge());
+  const [r, gc] = localGC();
+  const p1 = r(asPnt(v1));
+  const p2 = r(asPnt(v2));
+  const p3 = r(asPnt(v3));
+  const arcMaker = r(new oc.GC_MakeArcOfCircle_4(p1, p2, p3));
+  const circleGeom = r(arcMaker.Value());
+  const curve = r(new oc.Handle_Geom_Curve_2(circleGeom.get()));
+  const edgeMaker = r(new oc.BRepBuilderAPI_MakeEdge_24(curve));
+  const edge = new Edge(edgeMaker.Edge());
+  gc();
+  return edge;
 };
 const makeEllipseArc = (majorRadius, minorRadius, startAngle, endAngle, center = [0, 0, 0], normal = [0, 0, 1], xDir) => {
   const oc = getKernel().oc;
@@ -3013,13 +3276,17 @@ const makeBezierCurve = (points) => {
     bug("makeBezierCurve", `Need at least 2 points for a Bezier curve, got ${points.length}`);
   }
   const oc = getKernel().oc;
-  const arrayOfPoints = new oc.TColgp_Array1OfPnt_2(1, points.length);
+  const [r, gc] = localGC();
+  const arrayOfPoints = r(new oc.TColgp_Array1OfPnt_2(1, points.length));
   points.forEach((p, i) => {
-    arrayOfPoints.SetValue(i + 1, asPnt(p));
+    arrayOfPoints.SetValue(i + 1, r(asPnt(p)));
   });
   const bezCurve = new oc.Geom_BezierCurve_1(arrayOfPoints);
-  const curve = new oc.Handle_Geom_Curve_2(bezCurve);
-  return new Edge(new oc.BRepBuilderAPI_MakeEdge_24(curve).Edge());
+  const curve = r(new oc.Handle_Geom_Curve_2(bezCurve));
+  const edgeMaker = r(new oc.BRepBuilderAPI_MakeEdge_24(curve));
+  const edge = new Edge(edgeMaker.Edge());
+  gc();
+  return edge;
 };
 const makeTangentArc = (startPoint, startTgt, endPoint) => {
   const oc = getKernel().oc;
@@ -3038,7 +3305,8 @@ const makeTangentArc = (startPoint, startTgt, endPoint) => {
 };
 const assembleWire$1 = (listOfEdges) => {
   const oc = getKernel().oc;
-  const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+  const [r, gc] = localGC();
+  const wireBuilder = r(new oc.BRepBuilderAPI_MakeWire_1());
   listOfEdges.forEach((e) => {
     if (e instanceof Edge) {
       wireBuilder.Add_1(e.wrapped);
@@ -3047,7 +3315,7 @@ const assembleWire$1 = (listOfEdges) => {
       wireBuilder.Add_2(e.wrapped);
     }
   });
-  const progress = new oc.Message_ProgressRange_1();
+  const progress = r(new oc.Message_ProgressRange_1());
   wireBuilder.Build(progress);
   const res = wireBuilder.Error();
   if (res !== oc.BRepBuilderAPI_WireError.BRepBuilderAPI_WireDone) {
@@ -3056,8 +3324,7 @@ const assembleWire$1 = (listOfEdges) => {
       [oc.BRepBuilderAPI_WireError.BRepBuilderAPI_NonManifoldWire, "non manifold wire"],
       [oc.BRepBuilderAPI_WireError.BRepBuilderAPI_DisconnectedWire, "disconnected wire"]
     ]);
-    wireBuilder.delete();
-    progress.delete();
+    gc();
     return err(
       occtError(
         "WIRE_BUILD_FAILED",
@@ -3066,8 +3333,7 @@ const assembleWire$1 = (listOfEdges) => {
     );
   }
   const wire = new Wire(wireBuilder.Wire());
-  wireBuilder.delete();
-  progress.delete();
+  gc();
   return ok(wire);
 };
 const makeFace = (wire, holes) => {
@@ -3120,33 +3386,37 @@ const makeNonPlanarFace = (wire) => {
 };
 const makeCylinder = (radius, height, location = [0, 0, 0], direction = [0, 0, 1]) => {
   const oc = getKernel().oc;
-  const axis = makeAx2(location, direction);
-  const cylinder = new oc.BRepPrimAPI_MakeCylinder_3(axis, radius, height);
+  const [r, gc] = localGC();
+  const axis = r(makeAx2(location, direction));
+  const cylinder = r(new oc.BRepPrimAPI_MakeCylinder_3(axis, radius, height));
   const solid = new Solid(cylinder.Shape());
-  axis.delete();
-  cylinder.delete();
+  gc();
   return solid;
 };
 const makeSphere = (radius) => {
   const oc = getKernel().oc;
-  const sphereMaker = new oc.BRepPrimAPI_MakeSphere_1(radius);
+  const [r, gc] = localGC();
+  const sphereMaker = r(new oc.BRepPrimAPI_MakeSphere_1(radius));
   const sphere = new Solid(sphereMaker.Shape());
-  sphereMaker.delete();
+  gc();
   return sphere;
 };
-class EllpsoidTransform extends WrappingObj {
+class EllipsoidTransform extends WrappingObj {
   constructor(x, y, z) {
     const oc = getKernel().oc;
     const r = gcWithScope();
     const xyRatio = Math.sqrt(x * y / z);
     const xzRatio = x / xyRatio;
     const yzRatio = y / xyRatio;
+    const ax1 = r(makeAx1([0, 0, 0], [0, 1, 0]));
+    const ax2 = r(makeAx1([0, 0, 0], [0, 0, 1]));
+    const ax3 = r(makeAx1([0, 0, 0], [1, 0, 0]));
     const transform = new oc.gp_GTrsf_1();
-    transform.SetAffinity_1(makeAx1([0, 0, 0], [0, 1, 0]), xzRatio);
+    transform.SetAffinity_1(ax1, xzRatio);
     const xy = r(new oc.gp_GTrsf_1());
-    xy.SetAffinity_1(makeAx1([0, 0, 0], [0, 0, 1]), xyRatio);
+    xy.SetAffinity_1(ax2, xyRatio);
     const yz = r(new oc.gp_GTrsf_1());
-    yz.SetAffinity_1(makeAx1([0, 0, 0], [1, 0, 0]), yzRatio);
+    yz.SetAffinity_1(ax3, yzRatio);
     transform.Multiply(xy);
     transform.Multiply(yz);
     super(transform);
@@ -3178,60 +3448,71 @@ const makeEllipsoid = (aLength, bLength, cLength) => {
   sphere.SetRadius(1);
   const sphericalSurface = r(new oc.Geom_SphericalSurface_2(sphere));
   const baseSurface = oc.GeomConvert.SurfaceToBSplineSurface(sphericalSurface.UReversed()).get();
-  const poles = convertToJSArray(baseSurface.Poles_2());
-  const transform = new EllpsoidTransform(aLength, bLength, cLength);
-  poles.forEach((columns, rowIdx) => {
-    columns.forEach((value, colIdx) => {
-      const newPoint = transform.applyToPoint(value);
-      baseSurface.SetPole_1(rowIdx + 1, colIdx + 1, newPoint);
+  try {
+    const poles = convertToJSArray(baseSurface.Poles_2());
+    const transform = new EllipsoidTransform(aLength, bLength, cLength);
+    poles.forEach((columns, rowIdx) => {
+      columns.forEach((value, colIdx) => {
+        const newPoint = transform.applyToPoint(value);
+        baseSurface.SetPole_1(rowIdx + 1, colIdx + 1, newPoint);
+        newPoint.delete();
+      });
     });
-  });
-  const shell = unwrap(
-    cast(r(new oc.BRepBuilderAPI_MakeShell_2(baseSurface.UReversed(), false)).Shell())
-  );
-  return unwrap(makeSolid([shell]));
+    const shell = unwrap(
+      cast(r(new oc.BRepBuilderAPI_MakeShell_2(baseSurface.UReversed(), false)).Shell())
+    );
+    return unwrap(makeSolid([shell]));
+  } finally {
+    baseSurface.delete();
+  }
 };
 const makeBox = (corner1, corner2) => {
   const oc = getKernel().oc;
-  const boxMaker = new oc.BRepPrimAPI_MakeBox_4(asPnt(corner1), asPnt(corner2));
+  const [r, gc] = localGC();
+  const p1 = r(asPnt(corner1));
+  const p2 = r(asPnt(corner2));
+  const boxMaker = r(new oc.BRepPrimAPI_MakeBox_4(p1, p2));
   const box = new Solid(boxMaker.Solid());
-  boxMaker.delete();
+  gc();
   return box;
 };
 const makeVertex = (point) => {
   const oc = getKernel().oc;
-  const pnt2 = asPnt(point);
-  const vertexMaker = new oc.BRepBuilderAPI_MakeVertex(pnt2);
+  const [r, gc] = localGC();
+  const pnt2 = r(asPnt(point));
+  const vertexMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt2));
   const vertex = vertexMaker.Vertex();
-  vertexMaker.delete();
+  gc();
   return new Vertex(vertex);
 };
 const makeOffset = (face, offset2, tolerance = 1e-6) => {
   const oc = getKernel().oc;
   const progress = new oc.Message_ProgressRange_1();
   const offsetBuilder = new oc.BRepOffsetAPI_MakeOffsetShape();
-  offsetBuilder.PerformByJoin(
-    face.wrapped,
-    offset2,
-    tolerance,
-    oc.BRepOffset_Mode.BRepOffset_Skin,
-    false,
-    false,
-    oc.GeomAbs_JoinType.GeomAbs_Arc,
-    false,
-    progress
-  );
-  const result = andThen(
-    downcast(offsetBuilder.Shape()),
-    (downcasted) => andThen(cast(downcasted), (newShape) => {
-      if (!isShape3D$1(newShape))
-        return err(typeCastError("OFFSET_NOT_3D", "Could not offset to a 3d shape"));
-      return ok(newShape);
-    })
-  );
-  offsetBuilder.delete();
-  progress.delete();
-  return result;
+  try {
+    offsetBuilder.PerformByJoin(
+      face.wrapped,
+      offset2,
+      tolerance,
+      oc.BRepOffset_Mode.BRepOffset_Skin,
+      false,
+      false,
+      oc.GeomAbs_JoinType.GeomAbs_Arc,
+      false,
+      progress
+    );
+    return andThen(
+      downcast(offsetBuilder.Shape()),
+      (downcasted) => andThen(cast(downcasted), (newShape) => {
+        if (!isShape3D$1(newShape))
+          return err(typeCastError("OFFSET_NOT_3D", "Could not offset to a 3d shape"));
+        return ok(newShape);
+      })
+    );
+  } finally {
+    offsetBuilder.delete();
+    progress.delete();
+  }
 };
 const compoundShapes = (shapeArray) => {
   const oc = getKernel().oc;
@@ -3615,13 +3896,15 @@ function offsetWire2D(wire, offset2, kind = "arc") {
   const wrapped = castShape(resultShape);
   offsetter.delete();
   if (!isWire(wrapped)) {
+    wrapped[Symbol.dispose]();
     return err(typeCastError("OFFSET_NOT_WIRE", "Offset did not produce a Wire"));
   }
   return ok(wrapped);
 }
 function getSurfaceType(face) {
   const oc = getKernel().oc;
-  const adaptor = new oc.BRepAdaptor_Surface_2(face.wrapped, false);
+  const r = gcWithScope();
+  const adaptor = r(new oc.BRepAdaptor_Surface_2(face.wrapped, false));
   const ga = oc.GeomAbs_SurfaceType;
   const CAST_MAP = /* @__PURE__ */ new Map([
     [ga.GeomAbs_Plane, "PLANE"],
@@ -3637,7 +3920,6 @@ function getSurfaceType(face) {
     [ga.GeomAbs_OtherSurface, "OTHER_SURFACE"]
   ]);
   const surfType = CAST_MAP.get(adaptor.GetType());
-  adaptor.delete();
   if (!surfType) {
     return err(
       typeCastError("UNKNOWN_SURFACE_TYPE", "Unrecognized surface type from OCCT adapter")
@@ -3672,16 +3954,14 @@ function uvBounds(face) {
 }
 function pointOnSurface(face, u, v) {
   const oc = getKernel().oc;
+  const r = gcWithScope();
   const bounds = uvBounds(face);
-  const adaptor = new oc.BRepAdaptor_Surface_2(face.wrapped, false);
-  const p = new oc.gp_Pnt_1();
+  const adaptor = r(new oc.BRepAdaptor_Surface_2(face.wrapped, false));
+  const p = r(new oc.gp_Pnt_1());
   const absU = u * (bounds.uMax - bounds.uMin) + bounds.uMin;
   const absV = v * (bounds.vMax - bounds.vMin) + bounds.vMin;
   adaptor.D0(absU, absV, p);
-  const result = [p.X(), p.Y(), p.Z()];
-  p.delete();
-  adaptor.delete();
-  return result;
+  return [p.X(), p.Y(), p.Z()];
 }
 function uvCoordinates(face, point) {
   const oc = getKernel().oc;
@@ -3720,13 +4000,11 @@ function normalAt(face, locationPoint) {
 }
 function faceCenter(face) {
   const oc = getKernel().oc;
-  const props = new oc.GProp_GProps_1();
+  const r = gcWithScope();
+  const props = r(new oc.GProp_GProps_1());
   oc.BRepGProp.SurfaceProperties_2(face.wrapped, props, 1e-7, true);
-  const center = props.CentreOfMass();
-  const result = [center.X(), center.Y(), center.Z()];
-  center.delete();
-  props.delete();
-  return result;
+  const center = r(props.CentreOfMass());
+  return [center.X(), center.Y(), center.Z()];
 }
 function outerWire(face) {
   const oc = getKernel().oc;
@@ -3737,8 +4015,7 @@ function innerWires(face) {
   const allWires = Array.from(iterTopo(face.wrapped, "wire")).map(
     (w) => castShape(unwrap(downcast(w)))
   );
-  const outerHash = outer.wrapped.HashCode(2147483647);
-  const result = allWires.filter((w) => w.wrapped.HashCode(2147483647) !== outerHash);
+  const result = allWires.filter((w) => !w.wrapped.IsSame(outer.wrapped));
   return result;
 }
 function triangulateFace(face, index0 = 0, skipNormals = false) {
@@ -3794,195 +4071,6 @@ function triangulateFace(face, index0 = 0, skipNormals = false) {
   }
   return result;
 }
-const DEFAULT_MAX_SIZE = 128;
-let cache = /* @__PURE__ */ new Map();
-let maxSize = DEFAULT_MAX_SIZE;
-function buildMeshCacheKey(shapeHash, tolerance, angularTolerance, skipNormals) {
-  return `${shapeHash}:${tolerance}:${angularTolerance}:${skipNormals}`;
-}
-function getMesh(key) {
-  const entry = cache.get(key);
-  if (!entry) return void 0;
-  cache.delete(key);
-  cache.set(key, entry);
-  return entry.value;
-}
-function setMesh(key, value) {
-  if (cache.has(key)) {
-    cache.delete(key);
-  }
-  if (cache.size >= maxSize) {
-    const oldest = cache.keys().next().value;
-    if (oldest !== void 0) {
-      cache.delete(oldest);
-    }
-  }
-  cache.set(key, { key, value });
-}
-function clearMeshCache() {
-  cache = /* @__PURE__ */ new Map();
-}
-function setMeshCacheSize(size) {
-  maxSize = size;
-  while (cache.size > maxSize) {
-    const oldest = cache.keys().next().value;
-    if (oldest !== void 0) {
-      cache.delete(oldest);
-    }
-  }
-}
-function meshShape(shape, {
-  tolerance = 1e-3,
-  angularTolerance = 0.1,
-  skipNormals = false,
-  cache: cache2 = true
-} = {}) {
-  const shapeHash = shape.wrapped.HashCode(HASH_CODE_MAX);
-  if (cache2) {
-    const cacheKey = buildMeshCacheKey(shapeHash, tolerance, angularTolerance, skipNormals);
-    const cached = getMesh(cacheKey);
-    if (cached) return cached;
-  }
-  const result = getKernel().mesh(shape.wrapped, {
-    tolerance,
-    angularTolerance,
-    skipNormals
-  });
-  const mesh = {
-    vertices: result.vertices,
-    normals: result.normals,
-    triangles: result.triangles,
-    faceGroups: result.faceGroups.map((g) => ({
-      start: g.start,
-      count: g.count,
-      faceId: g.faceHash
-    }))
-  };
-  if (cache2) {
-    const cacheKey = buildMeshCacheKey(shapeHash, tolerance, angularTolerance, skipNormals);
-    setMesh(cacheKey, mesh);
-  }
-  return mesh;
-}
-function meshShapeEdges(shape, { tolerance = 1e-3, angularTolerance = 0.1 } = {}) {
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  const recordedEdges = /* @__PURE__ */ new Set();
-  const lines = [];
-  const edgeGroups = [];
-  const addEdge = () => {
-    const start = lines.length;
-    let prevX = 0;
-    let prevY = 0;
-    let prevZ = 0;
-    let hasPrev = false;
-    return [
-      (p) => {
-        const x = p.X();
-        const y = p.Y();
-        const z = p.Z();
-        if (hasPrev) {
-          lines.push(prevX, prevY, prevZ, x, y, z);
-        }
-        prevX = x;
-        prevY = y;
-        prevZ = z;
-        hasPrev = true;
-      },
-      (edgeHash) => {
-        edgeGroups.push({
-          start: start / 3,
-          count: (lines.length - start) / 3,
-          edgeId: edgeHash
-        });
-        recordedEdges.add(edgeHash);
-      }
-    ];
-  };
-  const aLocation = r(new oc.TopLoc_Location_1());
-  const faces = getFaces(shape);
-  for (const face of faces) {
-    const triangulation = r(oc.BRep_Tool.Triangulation(face.wrapped, aLocation, 0));
-    if (triangulation.IsNull()) continue;
-    const tri = triangulation.get();
-    const faceEdges = getEdges$1(face);
-    for (const edge of faceEdges) {
-      const edgeHash = edge.wrapped.HashCode(HASH_CODE_MAX);
-      if (recordedEdges.has(edgeHash)) continue;
-      const edgeLoc = r(new oc.TopLoc_Location_1());
-      const polygon = r(
-        oc.BRep_Tool.PolygonOnTriangulation_1(edge.wrapped, triangulation, edgeLoc)
-      );
-      const edgeNodes = polygon?.get()?.Nodes();
-      if (!edgeNodes) continue;
-      r(edgeNodes);
-      const [recordPoint, done] = addEdge();
-      for (let i = edgeNodes.Lower(); i <= edgeNodes.Upper(); i++) {
-        const p = r(r(tri.Node(edgeNodes.Value(i))).Transformed(edgeLoc.Transformation()));
-        recordPoint(p);
-      }
-      done(edgeHash);
-    }
-  }
-  const allEdges = getEdges$1(shape);
-  for (const edge of allEdges) {
-    const edgeHash = edge.wrapped.HashCode(HASH_CODE_MAX);
-    if (recordedEdges.has(edgeHash)) continue;
-    const adaptorCurve = r(new oc.BRepAdaptor_Curve_2(edge.wrapped));
-    const tangDef = r(
-      new oc.GCPnts_TangentialDeflection_2(adaptorCurve, tolerance, angularTolerance, 2, 1e-9, 1e-7)
-    );
-    const [recordPoint, done] = addEdge();
-    for (let j = 0; j < tangDef.NbPoints(); j++) {
-      const p = r(tangDef.Value(j + 1).Transformed(aLocation.Transformation()));
-      recordPoint(p);
-    }
-    done(edgeHash);
-  }
-  return { lines, edgeGroups };
-}
-function exportSTEP$1(shape) {
-  const oc = getKernel().oc;
-  const filename = "blob.step";
-  const writer = new oc.STEPControl_Writer_1();
-  oc.Interface_Static.SetIVal("write.step.schema", 5);
-  writer.Model(true).delete();
-  const progress = new oc.Message_ProgressRange_1();
-  writer.Transfer(shape.wrapped, oc.STEPControl_StepModelType.STEPControl_AsIs, true, progress);
-  const done = writer.Write(filename);
-  writer.delete();
-  progress.delete();
-  if (done === oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
-    try {
-      const file = oc.FS.readFile("/" + filename);
-      oc.FS.unlink("/" + filename);
-      return ok(new Blob([file], { type: "application/STEP" }));
-    } catch (e) {
-      return err(ioError("STEP_FILE_READ_ERROR", "Failed to read exported STEP file", e));
-    }
-  }
-  return err(ioError("STEP_EXPORT_FAILED", "Failed to write STEP file"));
-}
-function exportSTL(shape, {
-  tolerance = 1e-3,
-  angularTolerance = 0.1,
-  binary = false
-} = {}) {
-  const oc = getKernel().oc;
-  new oc.BRepMesh_IncrementalMesh_2(shape.wrapped, tolerance, false, angularTolerance, false);
-  const filename = "blob.stl";
-  const done = oc.StlAPI.Write(shape.wrapped, filename, !binary);
-  if (done) {
-    try {
-      const file = oc.FS.readFile("/" + filename);
-      oc.FS.unlink("/" + filename);
-      return ok(new Blob([file], { type: "application/sla" }));
-    } catch (e) {
-      return err(ioError("STL_FILE_READ_ERROR", "Failed to read exported STL file", e));
-    }
-  }
-  return err(ioError("STL_EXPORT_FAILED", "Failed to write STL file"));
-}
 function applyGlue(op, optimisation) {
   const oc = getKernel().oc;
   if (optimisation === "commonFace") {
@@ -4006,6 +4094,7 @@ function buildCompoundOcInternal(shapes) {
 function castToShape3D(shape, errorCode, errorMsg) {
   const wrapped = castShape(shape);
   if (!isShape3D(wrapped)) {
+    wrapped[Symbol.dispose]();
     return err(typeCastError(errorCode, errorMsg));
   }
   return ok(wrapped);
@@ -4074,29 +4163,44 @@ function buildCompound(shapes) {
   return createCompound(compound);
 }
 initCast(shapesModule);
+function buildLawFromProfile(extrusionLength, { profile, endFactor = 1 }) {
+  const oc = getKernel().oc;
+  const r = gcWithScope();
+  let law;
+  if (profile === "s-curve") {
+    law = r(new oc.Law_S());
+    law.Set_1(0, 1, extrusionLength, endFactor);
+  } else if (profile === "linear") {
+    law = r(new oc.Law_Linear());
+    law.Set(0, 1, extrusionLength, endFactor);
+  } else {
+    return err(
+      validationError("UNSUPPORTED_PROFILE", `Unsupported extrusion profile: ${String(profile)}`)
+    );
+  }
+  return ok(law.Trim(0, extrusionLength, 1e-6));
+}
 const basicFaceExtrusion = (face, extrusionVec) => {
   const oc = getKernel().oc;
-  const solidBuilder = new oc.BRepPrimAPI_MakePrism_1(
-    face.wrapped,
-    extrusionVec.wrapped,
-    false,
-    true
+  const [r, gc] = localGC();
+  const solidBuilder = r(
+    new oc.BRepPrimAPI_MakePrism_1(face.wrapped, extrusionVec.wrapped, false, true)
   );
   const solid = new Solid(unwrap(downcast(solidBuilder.Shape())));
-  solidBuilder.delete();
+  gc();
   return solid;
 };
 const revolution = (face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) => {
   const oc = getKernel().oc;
-  const ax = makeAx1(center, direction);
-  const revolBuilder = new oc.BRepPrimAPI_MakeRevol_1(face.wrapped, ax, angle * DEG2RAD, false);
+  const [r, gc] = localGC();
+  const ax = r(makeAx1(center, direction));
+  const revolBuilder = r(new oc.BRepPrimAPI_MakeRevol_1(face.wrapped, ax, angle * DEG2RAD, false));
   const result = andThen(cast(revolBuilder.Shape()), (shape) => {
     if (!isShape3D$2(shape))
       return err(typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
     return ok(shape);
   });
-  ax.delete();
-  revolBuilder.delete();
+  gc();
   return result;
 };
 function genericSweep(wire, spine, {
@@ -4109,8 +4213,9 @@ function genericSweep(wire, spine, {
   forceProfileSpineOthogonality
 } = {}, shellMode = false) {
   const oc = getKernel().oc;
+  const [r, gc] = localGC();
   const withCorrection = transitionMode === "round" ? true : !!forceProfileSpineOthogonality;
-  const sweepBuilder = new oc.BRepOffsetAPI_MakePipeShell(spine.wrapped);
+  const sweepBuilder = r(new oc.BRepOffsetAPI_MakePipeShell(spine.wrapped));
   {
     const mode = {
       transformed: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_Transformed,
@@ -4133,91 +4238,71 @@ function genericSweep(wire, spine, {
   }
   if (!law) sweepBuilder.Add_1(wire.wrapped, !!withContact, withCorrection);
   else sweepBuilder.SetLaw_1(wire.wrapped, law, !!withContact, withCorrection);
-  const progress = new oc.Message_ProgressRange_1();
+  const progress = r(new oc.Message_ProgressRange_1());
   sweepBuilder.Build(progress);
   if (!shellMode) {
     sweepBuilder.MakeSolid();
   }
   const shape = unwrap(cast(sweepBuilder.Shape()));
   if (!isShape3D$2(shape)) {
-    sweepBuilder.delete();
-    progress.delete();
+    gc();
     return err(typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
   }
   if (shellMode) {
     const startWire = unwrap(cast(sweepBuilder.FirstShape()));
     const endWire = unwrap(cast(sweepBuilder.LastShape()));
     if (!isWire$1(startWire)) {
-      sweepBuilder.delete();
+      gc();
       return err(typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
     }
     if (!isWire$1(endWire)) {
-      sweepBuilder.delete();
+      gc();
       return err(typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
     }
-    sweepBuilder.delete();
+    gc();
     return ok([shape, startWire, endWire]);
   }
-  sweepBuilder.delete();
-  progress.delete();
+  gc();
   return ok(shape);
 }
-const buildLawFromProfile$1 = (extrusionLength, { profile, endFactor = 1 }) => {
-  const oc = getKernel().oc;
-  let law;
-  if (profile === "s-curve") {
-    law = new oc.Law_S();
-    law.Set_1(0, 1, extrusionLength, endFactor);
-  } else if (profile === "linear") {
-    law = new oc.Law_Linear();
-    law.Set(0, 1, extrusionLength, endFactor);
-  } else {
-    return err(
-      validationError("UNSUPPORTED_PROFILE", `Unsupported extrusion profile: ${String(profile)}`)
-    );
-  }
-  const trimmed = law.Trim(0, extrusionLength, 1e-6);
-  law.delete();
-  return ok(trimmed);
-};
 const supportExtrude$1 = (wire, center, normal, support) => {
-  const centerVec = new Vector(center);
-  const normalVec = new Vector(normal);
-  const endVec = centerVec.add(normalVec);
-  const mainSpineEdge = makeLine(centerVec, endVec);
-  const spine = unwrap(assembleWire$1([mainSpineEdge]));
-  centerVec.delete();
-  normalVec.delete();
-  endVec.delete();
-  return genericSweep(wire, spine, { support });
+  const [r, gc] = localGC();
+  const centerVec = r(new Vector(center));
+  const normalVec = r(new Vector(normal));
+  const endVec = r(centerVec.add(normalVec));
+  const mainSpineEdge = r(makeLine(centerVec, endVec));
+  const spine = r(unwrap(assembleWire$1([mainSpineEdge])));
+  const result = genericSweep(wire, spine, { support });
+  gc();
+  return result;
 };
 function complexExtrude$1(wire, center, normal, profileShape, shellMode = false) {
-  const centerVec = new Vector(center);
-  const normalVec = new Vector(normal);
-  const endVec = centerVec.add(normalVec);
-  const mainSpineEdge = makeLine(centerVec, endVec);
-  const spine = unwrap(assembleWire$1([mainSpineEdge]));
-  const law = profileShape ? unwrap(buildLawFromProfile$1(normalVec.Length, profileShape)) : null;
-  centerVec.delete();
-  endVec.delete();
-  normalVec.delete();
-  return shellMode ? genericSweep(wire, spine, { law }, shellMode) : genericSweep(wire, spine, { law }, shellMode);
+  const [r, gc] = localGC();
+  const centerVec = r(new Vector(center));
+  const normalVec = r(new Vector(normal));
+  const endVec = r(centerVec.add(normalVec));
+  const mainSpineEdge = r(makeLine(centerVec, endVec));
+  const spine = r(unwrap(assembleWire$1([mainSpineEdge])));
+  const law = profileShape ? r(unwrap(buildLawFromProfile(normalVec.Length, profileShape))) : null;
+  const result = shellMode ? genericSweep(wire, spine, { law }, shellMode) : genericSweep(wire, spine, { law }, shellMode);
+  gc();
+  return result;
 }
 function twistExtrude$1(wire, angleDegrees, center, normal, profileShape, shellMode = false) {
-  const centerVec = new Vector(center);
-  const normalVec = new Vector(normal);
-  const endVec = centerVec.add(normalVec);
-  const mainSpineEdge = makeLine(centerVec, endVec);
-  const spine = unwrap(assembleWire$1([mainSpineEdge]));
+  const [r, gc] = localGC();
+  const centerVec = r(new Vector(center));
+  const normalVec = r(new Vector(normal));
+  const endVec = r(centerVec.add(normalVec));
+  const mainSpineEdge = r(makeLine(centerVec, endVec));
+  const spine = r(unwrap(assembleWire$1([mainSpineEdge])));
   const extrusionLength = normalVec.Length;
   const pitch = 360 / angleDegrees * extrusionLength;
   const radius = 1;
-  const auxiliarySpine = makeHelix(pitch, extrusionLength, radius, center, normal);
-  const law = profileShape ? unwrap(buildLawFromProfile$1(extrusionLength, profileShape)) : null;
-  centerVec.delete();
-  normalVec.delete();
-  endVec.delete();
-  return shellMode ? genericSweep(wire, spine, { auxiliarySpine, law }, shellMode) : genericSweep(wire, spine, { auxiliarySpine, law }, shellMode);
+  const auxiliarySpine = r(makeHelix(pitch, extrusionLength, radius, center, normal));
+  const law = profileShape ? r(unwrap(buildLawFromProfile(extrusionLength, profileShape))) : null;
+  const result = shellMode ? genericSweep(wire, spine, { auxiliarySpine, law }, shellMode) : genericSweep(wire, spine, { auxiliarySpine, law }, shellMode);
+  gc();
+  return result;
 }
 const loft = (wires, { ruled = true, startPoint, endPoint } = {}, returnShell = false) => {
   const oc = getKernel().oc;
@@ -4247,31 +4332,48 @@ function uuidv() {
     crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> Number(c) / 4).toString(16)
   );
 }
-const wrapString$1 = (str) => {
+function wrapString(str) {
   const oc = getKernel().oc;
   return new oc.TCollection_ExtendedString_2(str, true);
-};
-function parseSlice$1(hex, index) {
+}
+function parseSlice(hex, index) {
   return parseInt(hex.slice(index * 2, (index + 1) * 2), 16);
 }
-function colorFromHex$1(hex) {
+function colorFromHex(hex) {
   let color = hex;
   if (color.indexOf("#") === 0) color = color.slice(1);
   if (color.length === 3) {
     color = color.replace(/([0-9a-f])/gi, "$1$1");
   }
-  return [parseSlice$1(color, 0), parseSlice$1(color, 1), parseSlice$1(color, 2)];
+  return [parseSlice(color, 0), parseSlice(color, 1), parseSlice(color, 2)];
 }
-const wrapColor$1 = (hex, alpha = 1) => {
+function wrapColor(hex, alpha = 1) {
   const oc = getKernel().oc;
-  const [r, g, b] = colorFromHex$1(hex);
-  return new oc.Quantity_ColorRGBA_5(r / 255, g / 255, b / 255, alpha);
-};
+  const [red, green, blue] = colorFromHex(hex);
+  return new oc.Quantity_ColorRGBA_5(red / 255, green / 255, blue / 255, alpha);
+}
+function configureStepUnits(unit, modelUnit, r) {
+  if (!unit && !modelUnit) return;
+  const oc = getKernel().oc;
+  r(new oc.STEPCAFControl_Writer_1());
+  oc.Interface_Static.SetCVal("xstep.cascade.unit", (modelUnit || unit || "MM").toUpperCase());
+  oc.Interface_Static.SetCVal("write.step.unit", (unit || modelUnit || "MM").toUpperCase());
+}
+function configureStepWriter(writer) {
+  const oc = getKernel().oc;
+  writer.SetColorMode(true);
+  writer.SetLayerMode(true);
+  writer.SetNameMode(true);
+  oc.Interface_Static.SetIVal("write.surfacecurve.mode", true);
+  oc.Interface_Static.SetIVal("write.precision.mode", 0);
+  oc.Interface_Static.SetIVal("write.step.assembly", 2);
+  oc.Interface_Static.SetIVal("write.step.schema", 5);
+}
 class AssemblyExporter extends WrappingObj {
 }
 function createAssembly(shapes = []) {
   const oc = getKernel().oc;
-  const doc = new oc.TDocStd_Document(wrapString$1("XmlOcaf"));
+  const doc = new oc.TDocStd_Document(wrapString("XmlOcaf"));
   oc.XCAFDoc_ShapeTool.SetAutoNaming(false);
   const mainLabel = doc.Main();
   const tool = oc.XCAFDoc_DocumentTool.ShapeTool(mainLabel).get();
@@ -4279,10 +4381,10 @@ function createAssembly(shapes = []) {
   for (const { shape, name, color, alpha } of shapes) {
     const shapeNode = tool.NewShape();
     tool.SetShape(shapeNode, shape.wrapped);
-    oc.TDataStd_Name.Set_1(shapeNode, wrapString$1(name || uuidv()));
+    oc.TDataStd_Name.Set_1(shapeNode, wrapString(name || uuidv()));
     ctool.SetColor_3(
       shapeNode,
-      wrapColor$1(color || "#f00", alpha ?? 1),
+      wrapColor(color || "#f00", alpha ?? 1),
       oc.XCAFDoc_ColorType.XCAFDoc_ColorSurf
     );
   }
@@ -4293,38 +4395,32 @@ function exportSTEP(shapes = [], { unit, modelUnit } = {}) {
   const oc = getKernel().oc;
   const r = gcWithScope();
   const doc = createAssembly(shapes);
-  if (unit || modelUnit) {
-    r(new oc.STEPCAFControl_Writer_1());
-    oc.Interface_Static.SetCVal("xstep.cascade.unit", (modelUnit || unit || "MM").toUpperCase());
-    oc.Interface_Static.SetCVal("write.step.unit", (unit || modelUnit || "MM").toUpperCase());
-  }
-  const session = r(new oc.XSControl_WorkSession());
-  const writer = r(
-    new oc.STEPCAFControl_Writer_2(r(new oc.Handle_XSControl_WorkSession_2(session)), false)
-  );
-  writer.SetColorMode(true);
-  writer.SetLayerMode(true);
-  writer.SetNameMode(true);
-  oc.Interface_Static.SetIVal("write.surfacecurve.mode", true);
-  oc.Interface_Static.SetIVal("write.precision.mode", 0);
-  oc.Interface_Static.SetIVal("write.step.assembly", 2);
-  oc.Interface_Static.SetIVal("write.step.schema", 5);
-  const progress = r(new oc.Message_ProgressRange_1());
-  writer.Transfer_1(
-    new oc.Handle_TDocStd_Document_2(doc.wrapped),
-    oc.STEPControl_StepModelType.STEPControl_AsIs,
-    null,
-    progress
-  );
-  const filename = "export.step";
-  const done = writer.Write(filename);
-  if (done === oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
-    const file = oc.FS.readFile("/" + filename);
-    oc.FS.unlink("/" + filename);
-    const blob = new Blob([file], { type: "application/STEP" });
-    return ok(blob);
-  } else {
-    return err(ioError("STEP_EXPORT_FAILED", "Failed to write STEP file"));
+  try {
+    configureStepUnits(unit, modelUnit, r);
+    const session = r(new oc.XSControl_WorkSession());
+    const writer = r(
+      new oc.STEPCAFControl_Writer_2(r(new oc.Handle_XSControl_WorkSession_2(session)), false)
+    );
+    configureStepWriter(writer);
+    const progress = r(new oc.Message_ProgressRange_1());
+    writer.Transfer_1(
+      new oc.Handle_TDocStd_Document_2(doc.wrapped),
+      oc.STEPControl_StepModelType.STEPControl_AsIs,
+      null,
+      progress
+    );
+    const filename = uniqueIOFilename("_export", "step");
+    const done = writer.Write(filename);
+    if (done === oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
+      const file = oc.FS.readFile("/" + filename);
+      oc.FS.unlink("/" + filename);
+      const blob = new Blob([file], { type: "application/STEP" });
+      return ok(blob);
+    } else {
+      return err(ioError("STEP_EXPORT_FAILED", "Failed to write STEP file"));
+    }
+  } finally {
+    doc.delete();
   }
 }
 function fuseAllShapes(shapes, { optimisation = "none", simplify = false, strategy = "native" } = {}) {
@@ -4532,9 +4628,6 @@ const cartesianToPolar = ([x, y]) => {
   const theta = Math.atan2(y, x);
   return [r, theta];
 };
-const determinant2x2 = (matrix) => {
-  return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
-};
 function deserializeCurve2D(data) {
   const oc = getKernel().oc;
   const handle = oc.GeomToolsWrapper.Read(data);
@@ -4831,23 +4924,24 @@ function* commonSegmentsIteration(intersector) {
   const nSegments = intersector.NbSegments();
   if (!nSegments) return;
   const oc = getKernel().oc;
+  const r = gcWithScope();
   for (let i = 1; i <= nSegments; i++) {
     const h1 = new oc.Handle_Geom2d_Curve_1();
-    const h2 = new oc.Handle_Geom2d_Curve_1();
+    const h2 = r(new oc.Handle_Geom2d_Curve_1());
     try {
       intersector.Segment(i, h1, h2);
     } catch {
       continue;
     }
     yield new Curve2D(h1);
-    h2.delete();
   }
 }
 const intersectCurves = (first, second, precision = 1e-9) => {
   if (first.boundingBox.isOut(second.boundingBox))
     return ok({ intersections: [], commonSegments: [], commonSegmentsPoints: [] });
   const oc = getKernel().oc;
-  const intersector = new oc.Geom2dAPI_InterCurveCurve_1();
+  const r = gcWithScope();
+  const intersector = r(new oc.Geom2dAPI_InterCurveCurve_1());
   let intersections;
   let commonSegments;
   try {
@@ -4856,8 +4950,6 @@ const intersectCurves = (first, second, precision = 1e-9) => {
     commonSegments = Array.from(commonSegmentsIteration(intersector));
   } catch (e) {
     return err(computationError("INTERSECTION_FAILED", "Intersections failed between curves", e));
-  } finally {
-    intersector.delete();
   }
   const segmentsAsPoints = commonSegments.filter((c) => samePoint$2(c.firstPoint, c.lastPoint, precision)).map((c) => c.firstPoint);
   if (segmentsAsPoints.length) {
@@ -4869,15 +4961,14 @@ const intersectCurves = (first, second, precision = 1e-9) => {
 };
 const selfIntersections = (curve, precision = 1e-9) => {
   const oc = getKernel().oc;
-  const intersector = new oc.Geom2dAPI_InterCurveCurve_1();
+  const r = gcWithScope();
+  const intersector = r(new oc.Geom2dAPI_InterCurveCurve_1());
   let intersections;
   try {
     intersector.Init_1(curve.wrapped, curve.wrapped, precision);
     intersections = Array.from(pointsIteration(intersector));
   } catch (e) {
     return err(computationError("SELF_INTERSECTION_FAILED", "Self intersection failed", e));
-  } finally {
-    intersector.delete();
   }
   return ok(intersections);
 };
@@ -5636,6 +5727,7 @@ function round5(v) {
 const fromPnt = (pnt2) => `${round2(pnt2.X())} ${round2(pnt2.Y())}`;
 const adaptedCurveToPathElem = (adaptor, lastPoint) => {
   const oc = getKernel().oc;
+  const r = gcWithScope();
   const curveType = unwrap(findCurveType(adaptor.GetType()));
   const [endX, endY] = lastPoint;
   const endpoint = `${round5(endX)} ${round5(endY)}`;
@@ -5643,22 +5735,26 @@ const adaptedCurveToPathElem = (adaptor, lastPoint) => {
     return `L ${endpoint}`;
   }
   if (curveType === "BEZIER_CURVE") {
-    const curve = adaptor.Bezier().get();
+    const bezierHandle = r(adaptor.Bezier());
+    const curve = bezierHandle.get();
     const deg = curve.Degree();
     if (deg === 1) {
       return `L ${endpoint}`;
     }
     if (deg === 2) {
-      return `Q ${fromPnt(curve.Pole(2))} ${endpoint}`;
+      const pole2 = r(curve.Pole(2));
+      return `Q ${fromPnt(pole2)} ${endpoint}`;
     }
     if (deg === 3) {
-      const p1 = fromPnt(curve.Pole(2));
-      const p2 = fromPnt(curve.Pole(3));
+      const pole2 = r(curve.Pole(2));
+      const pole3 = r(curve.Pole(3));
+      const p1 = fromPnt(pole2);
+      const p2 = fromPnt(pole3);
       return `C ${p1} ${p2} ${endpoint}`;
     }
   }
   if (curveType === "CIRCLE") {
-    const curve = adaptor.Circle();
+    const curve = r(adaptor.Circle());
     const radius = curve.Radius();
     const p1 = adaptor.FirstParameter();
     const p2 = adaptor.LastParameter();
@@ -5667,16 +5763,17 @@ const adaptedCurveToPathElem = (adaptor, lastPoint) => {
     return `A ${radius} ${radius} 0 ${Math.abs(paramAngle) > 180 ? "1" : "0"} ${curve.IsDirect() ? "1" : "0"} ${end}`;
   }
   if (curveType === "ELLIPSE") {
-    const curve = adaptor.Ellipse();
+    const curve = r(adaptor.Ellipse());
     const rx = curve.MajorRadius();
     const ry = curve.MinorRadius();
     const p1 = adaptor.FirstParameter();
     const p2 = adaptor.LastParameter();
     const paramAngle = (p2 - p1) * RAD2DEG;
     const end = paramAngle !== 360 ? endpoint : `${round5(endX)} ${round5(endY + 1e-4)}`;
-    const dir0 = new oc.gp_Dir2d_1();
-    const angle = 180 - curve.XAxis().Direction().Angle(dir0) * RAD2DEG;
-    dir0.delete();
+    const dir0 = r(new oc.gp_Dir2d_1());
+    const xAxis = r(curve.XAxis());
+    const xDir = r(xAxis.Direction());
+    const angle = 180 - xDir.Angle(dir0) * RAD2DEG;
     return `A ${round5(rx)} ${round5(ry)} ${round5(angle)} ${Math.abs(paramAngle) > 180 ? "1" : "0"} ${curve.IsDirect() ? "1" : "0"} ${end}`;
   }
   bug("adaptedCurveToPathElem", `Unsupported curve type: ${curveType}`);
@@ -5694,8 +5791,9 @@ function curvesAsEdgesOnPlane(curves, plane) {
   const ax = r(makeAx2(plane.origin, plane.zDir, plane.xDir));
   const oc = getKernel().oc;
   const edges = curves.map((curve) => {
-    const curve3d = oc.GeomLib.To3d(ax, curve.wrapped);
-    return new Edge(new oc.BRepBuilderAPI_MakeEdge_24(curve3d).Edge());
+    const curve3d = r(oc.GeomLib.To3d(ax, curve.wrapped));
+    const edgeBuilder = r(new oc.BRepBuilderAPI_MakeEdge_24(curve3d));
+    return new Edge(edgeBuilder.Edge());
   });
   gc();
   return edges;
@@ -6107,12 +6205,15 @@ class FaceFinder extends Finder3d {
    * @category Filter
    */
   parallelTo(plane) {
+    const [r, gc] = localGC();
     if (typeof plane === "string") return this.atAngleWith(PLANE_TO_DIR[plane]);
     if (typeof plane !== "string" && plane instanceof Plane)
       return this.atAngleWith(plane.zDir);
     if (typeof plane !== "string" && "normalAt" in plane) {
-      const normal = plane.normalAt();
-      return this.atAngleWith(normal);
+      const normal = r(plane.normalAt());
+      const normalPoint = [normal.x, normal.y, normal.z];
+      gc();
+      return this.atAngleWith(normalPoint);
     }
     return this;
   }
@@ -6138,13 +6239,22 @@ class FaceFinder extends Finder3d {
   inPlane(inputPlane, origin) {
     const plane = inputPlane instanceof Plane ? makePlane(inputPlane) : makePlane(inputPlane, origin);
     this.parallelTo(plane);
-    const centerInPlane = ({ element }) => element.center.equals(element.center.projectToPlane(plane));
+    const centerInPlane = ({ element }) => {
+      const [r, gc] = localGC();
+      const center = element.center;
+      const projected = r(center.projectToPlane(plane));
+      const result = center.equals(projected);
+      gc();
+      return result;
+    };
     this.filters.push(centerInPlane);
     return this;
   }
   shouldKeep(element) {
-    const normal = element.normalAt();
+    const [r, gc] = localGC();
+    const normal = r(element.normalAt());
     const shouldKeep = this.filters.every((filter) => filter({ normal, element }));
+    gc();
     return shouldKeep;
   }
   applyFilter(shape) {
@@ -6155,7 +6265,7 @@ class FaceFinder extends Finder3d {
   }
 }
 function getSingleFace(f, shape) {
-  if ("normalAt" in f && typeof f.normalAt === "function") return ok(f);
+  if (f instanceof Face) return ok(f);
   const finder = f instanceof FaceFinder ? f : f(new FaceFinder());
   return finder.find(shape, { unique: true });
 }
@@ -6173,6 +6283,9 @@ class Blueprint {
   _orientation;
   _guessedOrientation;
   constructor(curves) {
+    if (curves.length === 0) {
+      throw new Error("Blueprint requires at least one curve");
+    }
     this.curves = curves;
     this._boundingBox = null;
     this._orientation = null;
@@ -6185,7 +6298,7 @@ class Blueprint {
     if (this._boundingBox) this._boundingBox.delete();
   }
   clone() {
-    return new Blueprint(this.curves);
+    return new Blueprint(this.curves.map((c) => c.clone()));
   }
   get repr() {
     return ["Blueprint", ...this.curves.map((c) => c.repr)].join("\n");
@@ -6319,45 +6432,54 @@ class Blueprint {
     if (!this.boundingBox.containsPoint(point)) return false;
     const oc = getKernel().oc;
     const intersector = new oc.Geom2dAPI_InterCurveCurve_1();
-    const segment = make2dSegmentCurve(point, this.boundingBox.outsidePoint());
-    let crossCounts = 0;
-    const onCurve = this.curves.find((c) => c.isOnCurve(point));
-    if (onCurve) return false;
-    this.curves.forEach((c) => {
-      if (c.boundingBox.isOut(segment.boundingBox)) return;
-      intersector.Init_1(segment.wrapped, c.wrapped, 1e-9);
-      crossCounts += Number(intersector.NbPoints());
-    });
-    intersector.delete();
-    return !!(crossCounts % 2);
+    try {
+      const segment = make2dSegmentCurve(point, this.boundingBox.outsidePoint());
+      let crossCounts = 0;
+      const onCurve = this.curves.find((c) => c.isOnCurve(point));
+      if (onCurve) return false;
+      this.curves.forEach((c) => {
+        if (c.boundingBox.isOut(segment.boundingBox)) return;
+        intersector.Init_1(segment.wrapped, c.wrapped, 1e-9);
+        crossCounts += Number(intersector.NbPoints());
+      });
+      return !!(crossCounts % 2);
+    } finally {
+      intersector.delete();
+    }
   }
   isClosed() {
     return samePoint$2(this.firstPoint, this.lastPoint);
   }
   intersects(other) {
+    if (this.boundingBox.isOut(other.boundingBox)) return false;
     const oc = getKernel().oc;
     const intersector = new oc.Geom2dAPI_InterCurveCurve_1();
-    if (this.boundingBox.isOut(other.boundingBox)) return false;
-    for (const myCurve of this.curves) {
-      for (const otherCurve of other.curves) {
-        if (myCurve.boundingBox.isOut(otherCurve.boundingBox)) continue;
-        intersector.Init_1(myCurve.wrapped, otherCurve.wrapped, 1e-9);
-        if (intersector.NbPoints() || intersector.NbSegments()) return true;
+    try {
+      for (const myCurve of this.curves) {
+        for (const otherCurve of other.curves) {
+          if (myCurve.boundingBox.isOut(otherCurve.boundingBox)) continue;
+          intersector.Init_1(myCurve.wrapped, otherCurve.wrapped, 1e-9);
+          if (intersector.NbPoints() || intersector.NbSegments()) return true;
+        }
       }
+      return false;
+    } finally {
+      intersector.delete();
     }
-    intersector.delete();
-    return false;
   }
 }
 class CompoundBlueprint {
   blueprints;
   _boundingBox;
   constructor(blueprints) {
+    if (blueprints.length === 0) {
+      throw new Error("CompoundBlueprint requires at least one blueprint (the outer boundary)");
+    }
     this.blueprints = blueprints;
     this._boundingBox = null;
   }
   clone() {
-    return new CompoundBlueprint(this.blueprints);
+    return new CompoundBlueprint(this.blueprints.map((bp) => bp.clone()));
   }
   get boundingBox() {
     if (!this._boundingBox) {
@@ -6433,7 +6555,7 @@ class Blueprints {
     return ["Blueprints", ...this.blueprints.map((b) => b.repr)].join("\n");
   }
   clone() {
-    return new Blueprints(this.blueprints);
+    return new Blueprints(this.blueprints.map((bp) => bp.clone()));
   }
   get boundingBox() {
     if (!this._boundingBox) {
@@ -6591,8 +6713,7 @@ class Sketch {
   }
   set baseFace(newFace) {
     if (this._baseFace) this._baseFace.delete();
-    if (!newFace) this._baseFace = newFace;
-    else this._baseFace = newFace.clone();
+    this._baseFace = newFace ? newFace.clone() : newFace;
   }
   delete() {
     this.wire.delete();
@@ -7180,7 +7301,7 @@ class BaseSketcher2d {
       (c) => new Curve2D(c.innerCurve.Mirrored_2(mirrorAxis))
     );
     mirroredCurves.reverse();
-    mirroredCurves.map((c) => {
+    mirroredCurves.forEach((c) => {
       c.reverse();
     });
     this.pendingCurves.push(...mirroredCurves);
@@ -7365,16 +7486,22 @@ const rotateToStartAtSegment = (curves, segment) => {
   const end = curves.slice(startIndex);
   return end.concat(start);
 };
+const hashPoint = (p) => `${p[0].toFixed(6)},${p[1].toFixed(6)}`;
+const hashSegment = (first, last) => {
+  const h1 = hashPoint(first);
+  const h2 = hashPoint(last);
+  return h1 < h2 ? `${h1}|${h2}` : `${h2}|${h1}`;
+};
 function* createSegmentOnPoints(curves, allIntersections, allCommonSegments) {
+  const intersectionSet = new Set(allIntersections.map(hashPoint));
+  const commonSegmentSet = new Set(
+    allCommonSegments.map((seg) => hashSegment(seg.firstPoint, seg.lastPoint))
+  );
   const endsAtIntersection = (curve) => {
-    return !!allIntersections.find((intersection) => {
-      return samePoint$1(intersection, curve.lastPoint);
-    });
+    return intersectionSet.has(hashPoint(curve.lastPoint));
   };
   const isCommonSegment = (curve) => {
-    return !!allCommonSegments.find((segment) => {
-      return samePoint$1(segment.firstPoint, curve.firstPoint) && samePoint$1(segment.lastPoint, curve.lastPoint) || samePoint$1(segment.firstPoint, curve.lastPoint) && samePoint$1(segment.lastPoint, curve.firstPoint);
-    });
+    return commonSegmentSet.has(hashSegment(curve.firstPoint, curve.lastPoint));
   };
   let currentCurves = [];
   for (const curve of curves) {
@@ -7881,16 +8008,30 @@ function intersect2D(first, second) {
   }
   if (first instanceof CompoundBlueprint) {
     const wrapper = first.blueprints[0];
-    const cut = first.blueprints[1];
-    return cut2D(intersect2D(wrapper, second), cut);
+    const cuts = first.blueprints.slice(1);
+    if (cuts.length === 0) {
+      return intersect2D(wrapper, second);
+    }
+    let result = intersect2D(wrapper, second);
+    for (const cut of cuts) {
+      result = cut2D(result, cut);
+    }
+    return result;
   }
   if (second instanceof Blueprints) {
     return mergeNonIntersecting(second.blueprints.map((bp) => intersect2D(first, bp)));
   }
   if (second instanceof CompoundBlueprint) {
     const wrapper = second.blueprints[0];
-    const cut = second.blueprints[1];
-    return cut2D(intersect2D(wrapper, first), cut);
+    const cuts = second.blueprints.slice(1);
+    if (cuts.length === 0) {
+      return intersect2D(wrapper, first);
+    }
+    let result = intersect2D(wrapper, first);
+    for (const cut of cuts) {
+      result = cut2D(result, cut);
+    }
+    return result;
   }
   bug("intersect2D", "Unhandled Shape2D combination");
 }
@@ -8011,12 +8152,15 @@ class EdgeFinder extends Finder3d {
    * @category Filter
    */
   parallelTo(plane) {
+    const [r, gc] = localGC();
     if (typeof plane === "string") return this.atAngleWith(PLANE_TO_DIR[plane], 90);
     if (typeof plane !== "string" && plane instanceof Plane)
       return this.atAngleWith(plane.zDir, 90);
     if (typeof plane !== "string" && "normalAt" in plane) {
-      const normal = plane.normalAt();
-      return this.atAngleWith(normal, 90);
+      const normal = r(plane.normalAt());
+      const normalPoint = [normal.x, normal.y, normal.z];
+      gc();
+      return this.atAngleWith(normalPoint, 90);
     }
     return this;
   }
@@ -8031,17 +8175,29 @@ class EdgeFinder extends Finder3d {
   inPlane(inputPlane, origin) {
     const plane = inputPlane instanceof Plane ? makePlane(inputPlane) : makePlane(inputPlane, origin);
     this.parallelTo(plane);
-    const firstPointInPlane = ({ element }) => element.startPoint.equals(element.startPoint.projectToPlane(plane));
+    const firstPointInPlane = ({ element }) => {
+      const [r, gc] = localGC();
+      const startPoint = element.startPoint;
+      const projected = r(startPoint.projectToPlane(plane));
+      const result = startPoint.equals(projected);
+      gc();
+      return result;
+    };
     this.filters.push(firstPointInPlane);
     return this;
   }
   shouldKeep(element) {
+    const [r, gc] = localGC();
     let normal = null;
+    let tangent = null;
     try {
-      normal = element.tangentAt().normalized();
+      tangent = r(element.tangentAt());
+      normal = r(tangent.normalized());
     } catch {
     }
-    return this.filters.every((filter) => filter({ normal, element }));
+    const result = this.filters.every((filter) => filter({ normal, element }));
+    gc();
+    return result;
   }
   applyFilter(shape) {
     return shape.edges.filter((edge) => {
@@ -8207,13 +8363,25 @@ function measureShapeVolumeProperties(shape) {
   return new VolumePhysicalProperties(properties);
 }
 function measureVolume$1(shape) {
-  return measureShapeVolumeProperties(shape).volume;
+  const [r, gc] = localGC();
+  const props = r(measureShapeVolumeProperties(shape));
+  const v = props.volume;
+  gc();
+  return v;
 }
 function measureArea$1(shape) {
-  return measureShapeSurfaceProperties(shape).area;
+  const [r, gc] = localGC();
+  const props = r(measureShapeSurfaceProperties(shape));
+  const a = props.area;
+  gc();
+  return a;
 }
 function measureLength$1(shape) {
-  return measureShapeLinearProperties(shape).length;
+  const [r, gc] = localGC();
+  const props = r(measureShapeLinearProperties(shape));
+  const l = props.length;
+  gc();
+  return l;
 }
 class DistanceTool extends WrappingObj {
   constructor() {
@@ -8221,17 +8389,22 @@ class DistanceTool extends WrappingObj {
     super(new oc.BRepExtrema_DistShapeShape_1());
   }
   distanceBetween(shape1, shape2) {
+    const [r, gc] = localGC();
     this.wrapped.LoadS1(shape1.wrapped);
     this.wrapped.LoadS2(shape2.wrapped);
     const oc = getKernel().oc;
-    const progress = new oc.Message_ProgressRange_1();
+    const progress = r(new oc.Message_ProgressRange_1());
     this.wrapped.Perform(progress);
-    progress.delete();
+    gc();
     return this.wrapped.Value();
   }
 }
 function measureDistanceBetween(shape1, shape2) {
-  return new DistanceTool().distanceBetween(shape1, shape2);
+  const [r, gc] = localGC();
+  const tool = r(new DistanceTool());
+  const dist = tool.distanceBetween(shape1, shape2);
+  gc();
+  return dist;
 }
 class DistanceQuery extends WrappingObj {
   constructor(shape) {
@@ -8240,19 +8413,19 @@ class DistanceQuery extends WrappingObj {
     this.wrapped.LoadS1(shape.wrapped);
   }
   distanceTo(shape) {
+    const [r, gc] = localGC();
     this.wrapped.LoadS2(shape.wrapped);
     const oc = getKernel().oc;
-    const progress = new oc.Message_ProgressRange_1();
+    const progress = r(new oc.Message_ProgressRange_1());
     this.wrapped.Perform(progress);
-    progress.delete();
+    gc();
     return this.wrapped.Value();
   }
 }
-const uniqueId$1 = () => Date.now().toString(36) + Math.random().toString(36).substring(2);
 async function importSTEP$1(STEPBlob) {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const fileName = uniqueId$1();
+  const fileName = uniqueId();
   try {
     const bufferView = new Uint8Array(await STEPBlob.arrayBuffer());
     oc.FS.writeFile(`/${fileName}`, bufferView);
@@ -8274,7 +8447,7 @@ async function importSTEP$1(STEPBlob) {
 async function importSTL$1(STLBlob) {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
-  const fileName = uniqueId$1();
+  const fileName = uniqueId();
   try {
     const bufferView = new Uint8Array(await STLBlob.arrayBuffer());
     oc.FS.writeFile(`/${fileName}`, bufferView);
@@ -8315,6 +8488,10 @@ class Sketcher {
     this.plane.delete();
     this.pointer.delete();
     this.firstPoint.delete();
+    for (const edge of this.pendingEdges) {
+      edge.delete();
+    }
+    this.pendingEdges = [];
   }
   _updatePointer(newPointer) {
     this.pointer.delete();
@@ -8389,12 +8566,16 @@ class Sketcher {
     );
   }
   tangentArcTo(end) {
+    const [r, gc] = localGC();
     const endPoint = this.plane.toWorldCoords(end);
-    const previousEdge = this.pendingEdges[this.pendingEdges.length - 1];
-    this.pendingEdges.push(
-      makeTangentArc(previousEdge.endPoint, previousEdge.tangentAt(1), endPoint)
-    );
+    const previousEdge = this.pendingEdges.length ? this.pendingEdges[this.pendingEdges.length - 1] : null;
+    if (!previousEdge)
+      bug("Sketcher.tangentArcTo", "You need a previous edge to create a tangent arc");
+    const prevEnd = r(previousEdge.endPoint);
+    const prevTangent = r(previousEdge.tangentAt(1));
+    this.pendingEdges.push(makeTangentArc(prevEnd, prevTangent, endPoint));
     this._updatePointer(endPoint);
+    gc();
     return this;
   }
   tangentArc(xDist, yDist) {
@@ -8402,16 +8583,18 @@ class Sketcher {
     return this.tangentArcTo([xDist + pointer.x, yDist + pointer.y]);
   }
   sagittaArcTo(end, sagitta) {
+    const [r, gc] = localGC();
     const startPoint = this.pointer;
     const endPoint = this.plane.toWorldCoords(end);
-    let p = endPoint.add(startPoint);
-    const midPoint = p.multiply(0.5);
-    p = endPoint.sub(startPoint);
-    const sagDirection = p.cross(this.plane.zDir).normalized();
-    const sagVector = sagDirection.multiply(sagitta);
-    const sagPoint = midPoint.add(sagVector);
+    const sum = r(endPoint.add(startPoint));
+    const midPoint = r(sum.multiply(0.5));
+    const diff = r(endPoint.sub(startPoint));
+    const sagDirection = r(r(diff.cross(this.plane.zDir)).normalized());
+    const sagVector = r(sagDirection.multiply(sagitta));
+    const sagPoint = r(midPoint.add(sagVector));
     this.pendingEdges.push(makeThreePointArc(this.pointer, sagPoint, endPoint));
     this._updatePointer(endPoint);
+    gc();
     return this;
   }
   sagittaArc(xDist, yDist, sagitta) {
@@ -8569,10 +8752,13 @@ class Sketcher {
     return this.smoothSplineTo([xDist + pointer.x, yDist + pointer.y], splineConfig);
   }
   _mirrorWireOnStartEnd(wire) {
-    const startToEndVector = this.pointer.sub(this.firstPoint).normalize();
-    const normal = startToEndVector.cross(this.plane.zDir);
+    const [r, gc] = localGC();
+    const diff = r(this.pointer.sub(this.firstPoint));
+    const startToEndVector = r(diff.normalize());
+    const normal = r(startToEndVector.cross(this.plane.zDir));
     const mirroredWire = wire.clone().mirror(normal, this.pointer);
     const combinedWire = unwrap(assembleWire$1([wire, mirroredWire]));
+    gc();
     return combinedWire;
   }
   buildWire() {
@@ -8607,32 +8793,19 @@ class Sketcher {
 }
 const guessFaceFromWires = (wires) => {
   const oc = getKernel().oc;
-  const faceBuilder = new oc.BRepOffsetAPI_MakeFilling(
-    3,
-    15,
-    2,
-    false,
-    1e-5,
-    1e-4,
-    0.01,
-    0.1,
-    8,
-    9
+  const [r, gc] = localGC();
+  const faceBuilder = r(
+    new oc.BRepOffsetAPI_MakeFilling(3, 15, 2, false, 1e-5, 1e-4, 0.01, 0.1, 8, 9)
   );
   wires.forEach((wire, wireIndex) => {
     wire.edges.forEach((edge) => {
-      faceBuilder.Add_1(
-        edge.wrapped,
-        oc.GeomAbs_Shape.GeomAbs_C0,
-        wireIndex === 0
-      );
+      faceBuilder.Add_1(edge.wrapped, oc.GeomAbs_Shape.GeomAbs_C0, wireIndex === 0);
     });
   });
-  const progress = new oc.Message_ProgressRange_1();
+  const progress = r(new oc.Message_ProgressRange_1());
   faceBuilder.Build(progress);
-  progress.delete();
   const newFace = unwrap(cast(faceBuilder.Shape()));
-  faceBuilder.delete();
+  gc();
   if (!(newFace instanceof Face)) {
     bug("guessFaceFromWires", "Failed to create a face");
   }
@@ -8640,9 +8813,10 @@ const guessFaceFromWires = (wires) => {
 };
 const fixWire = (wire, baseFace) => {
   const oc = getKernel().oc;
-  const wireFixer = new oc.ShapeFix_Wire_2(wire.wrapped, baseFace.wrapped, 1e-9);
+  const [r, gc] = localGC();
+  const wireFixer = r(new oc.ShapeFix_Wire_2(wire.wrapped, baseFace.wrapped, 1e-9));
   wireFixer.FixEdgeCurves();
-  wireFixer.delete();
+  gc();
   return wire;
 };
 const faceFromWires = (wires) => {
@@ -8710,41 +8884,39 @@ class CompoundSketch {
     twistAngle,
     origin
   } = {}) {
-    const rawVec = new Vector(extrusionDirection || this.outerSketch.defaultDirection);
-    const normVec = rawVec.normalized();
-    const extrusionVec = normVec.multiply(extrusionDistance);
-    rawVec.delete();
-    normVec.delete();
-    try {
-      if (extrusionProfile && !twistAngle) {
-        return solidFromShellGenerator(
-          this.sketches,
-          (sketch) => complexExtrude$1(
-            sketch.wire,
-            origin || this.outerSketch.defaultOrigin,
-            extrusionVec,
-            extrusionProfile,
-            true
-          )
-        );
-      }
-      if (twistAngle) {
-        return solidFromShellGenerator(
-          this.sketches,
-          (sketch) => twistExtrude$1(
-            sketch.wire,
-            twistAngle,
-            origin || this.outerSketch.defaultOrigin,
-            extrusionVec,
-            extrusionProfile,
-            true
-          )
-        );
-      }
-      return basicFaceExtrusion(this.face(), extrusionVec);
-    } finally {
-      extrusionVec.delete();
+    const [r, gc] = localGC();
+    const rawVec = r(new Vector(extrusionDirection || this.outerSketch.defaultDirection));
+    const normVec = r(rawVec.normalized());
+    const extrusionVec = r(normVec.multiply(extrusionDistance));
+    let result;
+    if (extrusionProfile && !twistAngle) {
+      result = solidFromShellGenerator(
+        this.sketches,
+        (sketch) => complexExtrude$1(
+          sketch.wire,
+          origin || this.outerSketch.defaultOrigin,
+          extrusionVec,
+          extrusionProfile,
+          true
+        )
+      );
+    } else if (twistAngle) {
+      result = solidFromShellGenerator(
+        this.sketches,
+        (sketch) => twistExtrude$1(
+          sketch.wire,
+          twistAngle,
+          origin || this.outerSketch.defaultOrigin,
+          extrusionVec,
+          extrusionProfile,
+          true
+        )
+      );
+    } else {
+      result = basicFaceExtrusion(this.face(), extrusionVec);
     }
+    gc();
+    return result;
   }
   /**
    * Revolves the drawing on an axis (defined by its direction and an origin
@@ -8913,69 +9085,16 @@ const makeBaseBox = (xLength, yLength, zLength) => {
 };
 const samePoint = (x, y) => samePoint$2(x, y, PRECISION_OFFSET * 10);
 const getIntersectionPoint = (line1Start, line1End, line2Start, line2End) => {
-  const denom = determinant2x2([
-    [
-      determinant2x2([
-        [line1Start[0], 1],
-        [line1End[0], 1]
-      ]),
-      determinant2x2([
-        [line1Start[1], 1],
-        [line1End[1], 1]
-      ])
-    ],
-    [
-      determinant2x2([
-        [line2Start[0], 1],
-        [line2End[0], 1]
-      ]),
-      determinant2x2([
-        [line2Start[1], 1],
-        [line2End[1], 1]
-      ])
-    ]
-  ]);
+  const dx1 = line1Start[0] - line1End[0];
+  const dy1 = line1Start[1] - line1End[1];
+  const dx2 = line2Start[0] - line2End[0];
+  const dy2 = line2Start[1] - line2End[1];
+  const denom = dx1 * dy2 - dy1 * dx2;
   if (Math.abs(denom) < 1e-12) return null;
-  const cross1 = determinant2x2([
-    [line1Start[0], line1Start[1]],
-    [line1End[0], line1End[1]]
-  ]);
-  const cross2 = determinant2x2([
-    [line2Start[0], line2Start[1]],
-    [line2End[0], line2End[1]]
-  ]);
-  const x = determinant2x2([
-    [
-      cross1,
-      determinant2x2([
-        [line1Start[0], 1],
-        [line1End[0], 1]
-      ])
-    ],
-    [
-      cross2,
-      determinant2x2([
-        [line2Start[0], 1],
-        [line2End[0], 1]
-      ])
-    ]
-  ]) / denom;
-  const y = determinant2x2([
-    [
-      cross1,
-      determinant2x2([
-        [line1Start[1], 1],
-        [line1End[1], 1]
-      ])
-    ],
-    [
-      cross2,
-      determinant2x2([
-        [line2Start[1], 1],
-        [line2End[1], 1]
-      ])
-    ]
-  ]) / denom;
+  const cross1 = line1Start[0] * line1End[1] - line1Start[1] * line1End[0];
+  const cross2 = line2Start[0] * line2End[1] - line2Start[1] * line2End[0];
+  const x = (cross1 * dx2 - cross2 * dx1) / denom;
+  const y = (cross1 * dy2 - cross2 * dy1) / denom;
   return [x, y];
 };
 function joinRound(appendCurve, previousLastPoint, firstPoint, previousCurve, _curve) {
@@ -9028,7 +9147,6 @@ function rawOffsets(blueprint, offset2, offsetConfig = {}) {
   let savedLastCurve = null;
   let previousCurve = offsetCurves.at(-1);
   if (!previousCurve) return [];
-  if (offsettedArray.length === 1) return offsettedArray;
   function appendCurve(curve) {
     if (curve instanceof Curve2D) {
       offsettedArray.push(curve);
@@ -9231,6 +9349,17 @@ function fillet2D(shape, radius, finder) {
 function chamfer2D(shape, radius, finder) {
   return modifyCorner2D(chamferCurves, shape, radius, finder);
 }
+function wrapSketchData(data) {
+  const opts = {};
+  if (data.defaultOrigin) opts.defaultOrigin = data.defaultOrigin;
+  if (data.defaultDirection) opts.defaultDirection = data.defaultDirection;
+  const sketch = new Sketch(data.wire, opts);
+  if (data.baseFace) sketch.baseFace = data.baseFace;
+  return sketch;
+}
+function wrapSketchDataArray(dataArr) {
+  return new CompoundSketch(dataArr.map(wrapSketchData));
+}
 const FONT_REGISTER = {};
 async function loadFont(fontPath, fontFamily = "default", force = false) {
   if (!force && FONT_REGISTER[fontFamily]) {
@@ -9294,20 +9423,12 @@ function textBlueprints(text, { startX = 0, startY = 0, fontSize = 16, fontFamil
   const blueprints = Array.from(sketchFontCommands(writtenText.commands));
   return organiseBlueprints(blueprints).mirror([0, 0]);
 }
-function wrapSketchData$1(data) {
-  const opts = {};
-  if (data.defaultOrigin) opts.defaultOrigin = data.defaultOrigin;
-  if (data.defaultDirection) opts.defaultDirection = data.defaultDirection;
-  const sketch = new Sketch(data.wire, opts);
-  if (data.baseFace) sketch.baseFace = data.baseFace;
-  return sketch;
-}
 function sketchText(text, textConfig, planeConfig = {}) {
   const textBp = textBlueprints(text, textConfig);
   const results = typeof planeConfig.plane === "string" || planeConfig.plane === void 0 ? textBp.sketchOnPlane(planeConfig.plane, planeConfig.origin) : textBp.sketchOnPlane(planeConfig.plane);
   return new Sketches(
     results.map(
-      (item) => Array.isArray(item) ? new CompoundSketch(item.map(wrapSketchData$1)) : wrapSketchData$1(item)
+      (item) => Array.isArray(item) ? new CompoundSketch(item.map(wrapSketchData)) : wrapSketchData(item)
     )
   );
 }
@@ -9330,28 +9451,32 @@ function isProjectionPlane(plane) {
 }
 function lookFromPlane(projectionPlane) {
   const { dir, xAxis } = PROJECTION_PLANES[projectionPlane];
-  return new ProjectionCamera([0, 0, 0], dir, xAxis);
+  return new ProjectionCamera(
+    [0, 0, 0],
+    dir,
+    xAxis
+  );
 }
 function defaultXDir(direction) {
-  const dir = new Vector(direction);
-  let yAxis = new Vector([0, 0, 1]);
+  const [r, gc] = localGC();
+  const dir = r(new Vector(direction));
+  let yAxis = r(new Vector([0, 0, 1]));
   let xAxis = yAxis.cross(dir);
   if (xAxis.Length === 0) {
-    yAxis.delete();
     xAxis.delete();
-    yAxis = new Vector([0, 1, 0]);
+    yAxis = r(new Vector([0, 1, 0]));
     xAxis = yAxis.cross(dir);
   }
-  dir.delete();
-  yAxis.delete();
+  gc();
   return xAxis.normalize();
 }
 class ProjectionCamera extends WrappingObj {
   constructor(position = [0, 0, 0], direction = [0, 0, 1], xAxis) {
-    const xDir = xAxis ? new Vector(xAxis) : defaultXDir(direction);
+    const [r, gc] = localGC();
+    const xDir = xAxis ? r(new Vector(xAxis)) : r(defaultXDir(direction));
     const ax2 = makeAx2(position, direction, xDir);
+    gc();
     super(ax2);
-    xDir.delete();
   }
   get position() {
     return new Vector(this.wrapped.Location());
@@ -9366,32 +9491,47 @@ class ProjectionCamera extends WrappingObj {
     return new Vector(this.wrapped.YDirection());
   }
   autoAxes() {
-    const dir = this.direction;
-    const xAxis = defaultXDir(dir);
-    this.wrapped.SetXDirection(asDir(xAxis));
-    dir.delete();
-    xAxis.delete();
+    const [r, gc] = localGC();
+    const dir = r(this.direction);
+    const xAxis = r(defaultXDir(dir));
+    const ocDir = r(asDir(xAxis));
+    this.wrapped.SetXDirection(ocDir);
+    gc();
   }
   setPosition(position) {
-    this.wrapped.SetLocation(asPnt(position));
+    const [r, gc] = localGC();
+    const pnt2 = r(asPnt(position));
+    this.wrapped.SetLocation(pnt2);
+    gc();
     return this;
   }
   setXAxis(xAxis) {
-    this.wrapped.SetXDirection(asDir(xAxis));
+    const [r, gc] = localGC();
+    const dir = r(asDir(xAxis));
+    this.wrapped.SetXDirection(dir);
+    gc();
     return this;
   }
   setYAxis(yAxis) {
-    this.wrapped.SetYDirection(asDir(yAxis));
+    const [r, gc] = localGC();
+    const dir = r(asDir(yAxis));
+    this.wrapped.SetYDirection(dir);
+    gc();
     return this;
   }
   lookAt(shape) {
-    const lookAtPoint = new Vector(
-      "boundingBox" in shape ? shape.boundingBox.center : shape
+    const [r, gc] = localGC();
+    const lookAtPoint = r(
+      new Vector(
+        "boundingBox" in shape ? shape.boundingBox.center : shape
+      )
     );
-    const direction = this.position.sub(lookAtPoint).normalized();
-    this.wrapped.SetDirection(direction.toDir());
-    lookAtPoint.delete();
-    direction.delete();
+    const pos = r(this.position);
+    const diff = r(pos.sub(lookAtPoint));
+    const direction = r(diff.normalized());
+    const ocDir = r(direction.toDir());
+    this.wrapped.SetDirection(ocDir);
+    gc();
     this.autoAxes();
     return this;
   }
@@ -9409,7 +9549,9 @@ function makeProjectedEdges(shape, camera, withHiddenLines = true) {
   hiddenLineRemoval.Projector_1(projector);
   hiddenLineRemoval.Update();
   hiddenLineRemoval.Hide_1();
-  const hlrShapes = new oc.HLRBRep_HLRToShape(new oc.Handle_HLRBRep_Algo_2(hiddenLineRemoval));
+  const hlrShapes = r(
+    new oc.HLRBRep_HLRToShape(r(new oc.Handle_HLRBRep_Algo_2(hiddenLineRemoval)))
+  );
   const visible = [
     ...getEdges(hlrShapes.VCompound_1()),
     ...getEdges(hlrShapes.Rg1LineVCompound_1()),
@@ -9424,17 +9566,6 @@ function makeProjectedEdges(shape, camera, withHiddenLines = true) {
   hidden.forEach((e) => oc.BRepLib.BuildCurves3d_2(e.wrapped));
   return { visible, hidden };
 }
-function wrapSketchData(data) {
-  const opts = {};
-  if (data.defaultOrigin) opts.defaultOrigin = data.defaultOrigin;
-  if (data.defaultDirection) opts.defaultDirection = data.defaultDirection;
-  const sketch = new Sketch(data.wire, opts);
-  if (data.baseFace) sketch.baseFace = data.baseFace;
-  return sketch;
-}
-function wrapSketchDataArray(dataArr) {
-  return new CompoundSketch(dataArr.map(wrapSketchData));
-}
 function wrapBlueprintResult(shape, result) {
   if (shape instanceof Blueprint) {
     return wrapSketchData(result);
@@ -9686,33 +9817,38 @@ const drawParametricFunction = (func, { pointsCount = 400, start = 0, stop = 1,
   return drawPointsInterpolation(points, approximationConfig, { closeShape });
 };
 const edgesToDrawing = (edges) => {
+  const [r, gc] = localGC();
   const planeSketch = drawRectangle(1e3, 1e3).sketchOnPlane();
-  const planeFace = unwrap(makeFace(planeSketch.wire));
+  const planeFace = r(unwrap(makeFace(planeSketch.wire)));
   const curves = edges.map((e) => edgeToCurve(e, planeFace));
-  planeFace.delete();
+  gc();
   const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint(s));
   if (stitchedCurves.length === 0) return new Drawing();
   if (stitchedCurves.length === 1) return new Drawing(stitchedCurves[0]);
   return new Drawing(new Blueprints(stitchedCurves));
 };
 function drawProjection(shape, projectionCamera = "front") {
+  const [r, gc] = localGC();
   let camera;
-  if (projectionCamera instanceof ProjectionCamera) {
+  const ownCamera = !(projectionCamera instanceof ProjectionCamera);
+  if (!ownCamera) {
     camera = projectionCamera;
   } else {
-    camera = lookFromPlane(projectionCamera);
+    camera = r(lookFromPlane(projectionCamera));
   }
   const { visible, hidden } = makeProjectedEdges(shape, camera);
+  gc();
   return {
     visible: edgesToDrawing(visible),
     hidden: edgesToDrawing(hidden)
   };
 }
 function drawFaceOutline(face) {
-  const clonedFace = face.clone();
-  const outerWire2 = clonedFace.outerWire();
+  const [r, gc] = localGC();
+  const clonedFace = r(face.clone());
+  const outerWire2 = r(clonedFace.outerWire());
   const curves = outerWire2.edges.map((e) => edgeToCurve(e, face));
-  outerWire2.delete();
+  gc();
   const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint(s));
   if (stitchedCurves.length === 0) return new Drawing();
   if (stitchedCurves.length === 1) return new Drawing(stitchedCurves[0]);
@@ -9783,7 +9919,7 @@ function mirrorDrawing(drawing, centerOrDirection, origin, mode) {
 }
 function createPlane(origin, xDirection = null, normal = [0, 0, 1]) {
   const zDir = vecNormalize(normal);
-  if (vecLength(zDir) === 0) throw new Error("Plane normal must be non-zero");
+  if (vecIsZero(zDir)) throw new Error("Plane normal must be non-zero");
   let xDir;
   if (!xDirection) {
     const ax3 = makeOcAx3(origin, zDir);
@@ -9794,7 +9930,7 @@ function createPlane(origin, xDirection = null, normal = [0, 0, 1]) {
   } else {
     xDir = vecNormalize(xDirection);
   }
-  if (vecLength(xDir) === 0) throw new Error("Plane xDir must be non-zero");
+  if (vecIsZero(xDir)) throw new Error("Plane xDir must be non-zero");
   const yDir = vecNormalize(vecCross(zDir, xDir));
   return { origin, xDir, yDir, zDir };
 }
@@ -9843,16 +9979,12 @@ function pivotPlane(plane, angleDeg, axis = [1, 0, 0]) {
 }
 function makeSpineWire(start, end) {
   const oc = getKernel().oc;
-  const pnt1 = toOcPnt(start);
-  const pnt2 = toOcPnt(end);
-  const edgeMaker = new oc.BRepBuilderAPI_MakeEdge_3(pnt1, pnt2);
-  const wireMaker = new oc.BRepBuilderAPI_MakeWire_2(edgeMaker.Edge());
-  const wire = castShape(wireMaker.Wire());
-  edgeMaker.delete();
-  wireMaker.delete();
-  pnt1.delete();
-  pnt2.delete();
-  return wire;
+  const r = gcWithScope();
+  const pnt1 = r(toOcPnt(start));
+  const pnt2 = r(toOcPnt(end));
+  const edgeMaker = r(new oc.BRepBuilderAPI_MakeEdge_3(pnt1, pnt2));
+  const wireMaker = r(new oc.BRepBuilderAPI_MakeWire_2(edgeMaker.Edge()));
+  return castShape(wireMaker.Wire());
 }
 function makeHelixWire(pitch, height, radius, center, dir, lefthand = false) {
   const oc = getKernel().oc;
@@ -9863,8 +9995,8 @@ function makeHelixWire(pitch, height, radius, center, dir, lefthand = false) {
     new oc.Geom2d_Line_3(r(new oc.gp_Pnt2d_3(0, 0)), r(new oc.gp_Dir2d_4(myDir, pitch)))
   );
   const nTurns = height / pitch;
-  const uStart = geomLine.Value(0);
-  const uStop = geomLine.Value(nTurns * Math.sqrt((2 * Math.PI) ** 2 + pitch ** 2));
+  const uStart = r(geomLine.Value(0));
+  const uStop = r(geomLine.Value(nTurns * Math.sqrt((2 * Math.PI) ** 2 + pitch ** 2)));
   const geomSeg = r(new oc.GCE2d_MakeSegment_1(uStart, uStop));
   const ax3 = makeOcAx3(center, dir);
   const geomSurf = new oc.Geom_CylindricalSurface_1(ax3, radius);
@@ -9881,12 +10013,10 @@ function makeHelixWire(pitch, height, radius, center, dir, lefthand = false) {
 }
 function extrudeFace(face, extrusionVec) {
   const oc = getKernel().oc;
-  const vec2 = toOcVec(extrusionVec);
-  const builder = new oc.BRepPrimAPI_MakePrism_1(face.wrapped, vec2, false, true);
-  const solid = createSolid(unwrap(downcast(builder.Shape())));
-  builder.delete();
-  vec2.delete();
-  return solid;
+  const r = gcWithScope();
+  const vec2 = r(toOcVec(extrusionVec));
+  const builder = r(new oc.BRepPrimAPI_MakePrism_1(face.wrapped, vec2, false, true));
+  return createSolid(unwrap(downcast(builder.Shape())));
 }
 function revolveFace(face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) {
   const oc = getKernel().oc;
@@ -9903,6 +10033,7 @@ function revolveFace(face, center = [0, 0, 0], direction = [0, 0, 1], angle = 36
 }
 function sweep(wire, spine, config = {}, shellMode = false) {
   const oc = getKernel().oc;
+  const r = gcWithScope();
   const {
     frenet = false,
     auxiliarySpine,
@@ -9913,7 +10044,7 @@ function sweep(wire, spine, config = {}, shellMode = false) {
     forceProfileSpineOthogonality
   } = config;
   const withCorrection = transitionMode === "round" ? true : !!forceProfileSpineOthogonality;
-  const builder = new oc.BRepOffsetAPI_MakePipeShell(spine.wrapped);
+  const builder = r(new oc.BRepOffsetAPI_MakePipeShell(spine.wrapped));
   {
     const mode = {
       transformed: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_Transformed,
@@ -9932,20 +10063,16 @@ function sweep(wire, spine, config = {}, shellMode = false) {
   }
   if (!law) builder.Add_1(wire.wrapped, !!withContact, withCorrection);
   else builder.SetLaw_1(wire.wrapped, law, !!withContact, withCorrection);
-  const progress = new oc.Message_ProgressRange_1();
+  const progress = r(new oc.Message_ProgressRange_1());
   builder.Build(progress);
   if (!shellMode) builder.MakeSolid();
   const shape = castShape(builder.Shape());
   if (!isShape3D(shape)) {
-    builder.delete();
-    progress.delete();
     return err(typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
   }
   if (shellMode) {
     const startWire = castShape(builder.FirstShape());
     const endWire = castShape(builder.LastShape());
-    builder.delete();
-    progress.delete();
     if (!isWire(startWire)) {
       return err(typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
     }
@@ -9954,28 +10081,8 @@ function sweep(wire, spine, config = {}, shellMode = false) {
     }
     return ok([shape, startWire, endWire]);
   }
-  builder.delete();
-  progress.delete();
   return ok(shape);
 }
-function buildLawFromProfile(extrusionLength, { profile, endFactor = 1 }) {
-  const oc = getKernel().oc;
-  let law;
-  if (profile === "s-curve") {
-    law = new oc.Law_S();
-    law.Set_1(0, 1, extrusionLength, endFactor);
-  } else if (profile === "linear") {
-    law = new oc.Law_Linear();
-    law.Set(0, 1, extrusionLength, endFactor);
-  } else {
-    return err(
-      validationError("UNSUPPORTED_PROFILE", `Unsupported extrusion profile: ${String(profile)}`)
-    );
-  }
-  const trimmed = law.Trim(0, extrusionLength, 1e-6);
-  law.delete();
-  return ok(trimmed);
-}
 function supportExtrude(wire, center, normal, support) {
   const endPoint = vecAdd(center, normal);
   const spine = makeSpineWire(center, endPoint);
@@ -10021,116 +10128,83 @@ function loftWires(wires, { ruled = true, startPoint, endPoint } = {}, returnShe
   }
   return ok(result);
 }
-function wrapString(str) {
-  const oc = getKernel().oc;
-  return new oc.TCollection_ExtendedString_2(str, true);
-}
-function parseSlice(hex, index) {
-  return parseInt(hex.slice(index * 2, (index + 1) * 2), 16);
-}
-function colorFromHex(hex) {
-  let color = hex;
-  if (color.indexOf("#") === 0) color = color.slice(1);
-  if (color.length === 3) {
-    color = color.replace(/([0-9a-f])/gi, "$1$1");
-  }
-  return [parseSlice(color, 0), parseSlice(color, 1), parseSlice(color, 2)];
-}
-function wrapColor(hex, alpha = 1) {
-  const oc = getKernel().oc;
-  const [red, green, blue] = colorFromHex(hex);
-  return new oc.Quantity_ColorRGBA_5(red / 255, green / 255, blue / 255, alpha);
-}
 function exportAssemblySTEP(shapes = [], { unit, modelUnit } = {}) {
   const oc = getKernel().oc;
   const r = gcWithScope();
   const doc = new oc.TDocStd_Document(wrapString("XmlOcaf"));
-  oc.XCAFDoc_ShapeTool.SetAutoNaming(false);
-  const mainLabel = doc.Main();
-  const tool = oc.XCAFDoc_DocumentTool.ShapeTool(mainLabel).get();
-  const ctool = oc.XCAFDoc_DocumentTool.ColorTool(mainLabel).get();
-  for (const { shape, name, color, alpha } of shapes) {
-    const shapeNode = tool.NewShape();
-    tool.SetShape(shapeNode, shape.wrapped);
-    oc.TDataStd_Name.Set_1(shapeNode, wrapString(name || uuidv()));
-    ctool.SetColor_3(
-      shapeNode,
-      wrapColor(color || "#f00", alpha ?? 1),
-      oc.XCAFDoc_ColorType.XCAFDoc_ColorSurf
+  try {
+    oc.XCAFDoc_ShapeTool.SetAutoNaming(false);
+    const mainLabel = doc.Main();
+    const tool = oc.XCAFDoc_DocumentTool.ShapeTool(mainLabel).get();
+    const ctool = oc.XCAFDoc_DocumentTool.ColorTool(mainLabel).get();
+    for (const { shape, name, color, alpha } of shapes) {
+      const shapeNode = tool.NewShape();
+      tool.SetShape(shapeNode, shape.wrapped);
+      oc.TDataStd_Name.Set_1(shapeNode, wrapString(name || uuidv()));
+      ctool.SetColor_3(
+        shapeNode,
+        wrapColor(color || "#f00", alpha ?? 1),
+        oc.XCAFDoc_ColorType.XCAFDoc_ColorSurf
+      );
+    }
+    tool.UpdateAssemblies();
+    configureStepUnits(unit, modelUnit, r);
+    const session = r(new oc.XSControl_WorkSession());
+    const writer = r(
+      new oc.STEPCAFControl_Writer_2(r(new oc.Handle_XSControl_WorkSession_2(session)), false)
     );
+    configureStepWriter(writer);
+    const progress = r(new oc.Message_ProgressRange_1());
+    writer.Transfer_1(
+      new oc.Handle_TDocStd_Document_2(doc),
+      oc.STEPControl_StepModelType.STEPControl_AsIs,
+      null,
+      progress
+    );
+    const filename = uniqueIOFilename("_export", "step");
+    const done = writer.Write(filename);
+    if (done === oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
+      const file = oc.FS.readFile("/" + filename);
+      oc.FS.unlink("/" + filename);
+      return ok(new Blob([file], { type: "application/STEP" }));
+    }
+    return err(ioError("STEP_EXPORT_FAILED", "Failed to write STEP file"));
+  } finally {
+    doc.delete();
   }
-  tool.UpdateAssemblies();
-  if (unit || modelUnit) {
-    r(new oc.STEPCAFControl_Writer_1());
-    oc.Interface_Static.SetCVal("xstep.cascade.unit", (modelUnit || unit || "MM").toUpperCase());
-    oc.Interface_Static.SetCVal("write.step.unit", (unit || modelUnit || "MM").toUpperCase());
-  }
-  const session = r(new oc.XSControl_WorkSession());
-  const writer = r(
-    new oc.STEPCAFControl_Writer_2(r(new oc.Handle_XSControl_WorkSession_2(session)), false)
-  );
-  writer.SetColorMode(true);
-  writer.SetLayerMode(true);
-  writer.SetNameMode(true);
-  oc.Interface_Static.SetIVal("write.surfacecurve.mode", true);
-  oc.Interface_Static.SetIVal("write.precision.mode", 0);
-  oc.Interface_Static.SetIVal("write.step.assembly", 2);
-  oc.Interface_Static.SetIVal("write.step.schema", 5);
-  const progress = r(new oc.Message_ProgressRange_1());
-  writer.Transfer_1(
-    new oc.Handle_TDocStd_Document_2(doc),
-    oc.STEPControl_StepModelType.STEPControl_AsIs,
-    null,
-    progress
-  );
-  const filename = "export.step";
-  const done = writer.Write(filename);
-  doc.delete();
-  if (done === oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
-    const file = oc.FS.readFile("/" + filename);
-    oc.FS.unlink("/" + filename);
-    return ok(new Blob([file], { type: "application/STEP" }));
-  }
-  return err(ioError("STEP_EXPORT_FAILED", "Failed to write STEP file"));
 }
 function measureVolumeProps(shape) {
   const oc = getKernel().oc;
-  const props = new oc.GProp_GProps_1();
+  const r = gcWithScope();
+  const props = r(new oc.GProp_GProps_1());
   oc.BRepGProp.VolumeProperties_1(shape.wrapped, props, false, false, false);
-  const pnt2 = props.CentreOfMass();
-  const result = {
+  const pnt2 = r(props.CentreOfMass());
+  return {
     mass: props.Mass(),
     centerOfMass: [pnt2.X(), pnt2.Y(), pnt2.Z()]
   };
-  pnt2.delete();
-  props.delete();
-  return result;
 }
 function measureSurfaceProps(shape) {
   const oc = getKernel().oc;
-  const props = new oc.GProp_GProps_1();
+  const r = gcWithScope();
+  const props = r(new oc.GProp_GProps_1());
   oc.BRepGProp.SurfaceProperties_1(shape.wrapped, props, false, false);
-  const pnt2 = props.CentreOfMass();
-  const result = {
+  const pnt2 = r(props.CentreOfMass());
+  return {
     mass: props.Mass(),
     centerOfMass: [pnt2.X(), pnt2.Y(), pnt2.Z()]
   };
-  pnt2.delete();
-  props.delete();
-  return result;
 }
 function measureLinearProps(shape) {
   const oc = getKernel().oc;
-  const props = new oc.GProp_GProps_1();
+  const r = gcWithScope();
+  const props = r(new oc.GProp_GProps_1());
   oc.BRepGProp.LinearProperties(shape.wrapped, props, false, false);
-  const pnt2 = props.CentreOfMass();
-  const result = {
+  const pnt2 = r(props.CentreOfMass());
+  return {
     mass: props.Mass(),
     centerOfMass: [pnt2.X(), pnt2.Y(), pnt2.Z()]
   };
-  pnt2.delete();
-  props.delete();
-  return result;
 }
 function measureVolume(shape) {
   return measureVolumeProps(shape).mass;
@@ -10143,15 +10217,13 @@ function measureLength(shape) {
 }
 function measureDistance(shape1, shape2) {
   const oc = getKernel().oc;
-  const distTool = new oc.BRepExtrema_DistShapeShape_1();
+  const r = gcWithScope();
+  const distTool = r(new oc.BRepExtrema_DistShapeShape_1());
   distTool.LoadS1(shape1.wrapped);
   distTool.LoadS2(shape2.wrapped);
-  const progress = new oc.Message_ProgressRange_1();
+  const progress = r(new oc.Message_ProgressRange_1());
   distTool.Perform(progress);
-  const dist = distTool.Value();
-  progress.delete();
-  distTool.delete();
-  return dist;
+  return distTool.Value();
 }
 function createDistanceQuery(referenceShape) {
   const oc = getKernel().oc;
@@ -10161,17 +10233,18 @@ function createDistanceQuery(referenceShape) {
     distanceTo(other) {
       distTool.LoadS2(other.wrapped);
       const progress = new oc.Message_ProgressRange_1();
-      distTool.Perform(progress);
-      const dist = distTool.Value();
-      progress.delete();
-      return dist;
+      try {
+        distTool.Perform(progress);
+        return distTool.Value();
+      } finally {
+        progress.delete();
+      }
     },
     dispose() {
       distTool.delete();
     }
   };
 }
-const uniqueId = () => Date.now().toString(36) + Math.random().toString(36).substring(2);
 async function importSTEP(blob) {
   const oc = getKernel().oc;
   const r = gcWithScope();
@@ -10185,6 +10258,9 @@ async function importSTEP(blob) {
     }
     reader.TransferRoots(r(new oc.Message_ProgressRange_1()));
     const stepShape = reader.OneShape();
+    if (stepShape.IsNull()) {
+      return err(ioError("STEP_IMPORT_FAILED", "STEP file contains no valid geometry"));
+    }
     return ok(castShape(stepShape));
   } finally {
     try {
@@ -10293,15 +10369,13 @@ function createEdgeFinder(filters) {
       const d = vecNormalize(resolveDir(dir));
       return withFilter((edge) => {
         const oc = getKernel().oc;
-        const adaptor = new oc.BRepAdaptor_Curve_2(edge.wrapped);
-        const tmpPnt = new oc.gp_Pnt_1();
-        const tmpVec = new oc.gp_Vec_1();
+        const r = gcWithScope();
+        const adaptor = r(new oc.BRepAdaptor_Curve_2(edge.wrapped));
+        const tmpPnt = r(new oc.gp_Pnt_1());
+        const tmpVec = r(new oc.gp_Vec_1());
         const mid = (Number(adaptor.FirstParameter()) + Number(adaptor.LastParameter())) / 2;
         adaptor.D1(mid, tmpPnt, tmpVec);
         const tangent = vecNormalize([tmpVec.X(), tmpVec.Y(), tmpVec.Z()]);
-        tmpPnt.delete();
-        tmpVec.delete();
-        adaptor.delete();
         const ang = Math.acos(Math.min(1, Math.abs(vecDot(tangent, d))));
         return Math.abs(ang - DEG2RAD * angle) < 1e-6;
       });
@@ -10309,24 +10383,20 @@ function createEdgeFinder(filters) {
     ofLength: (length, tolerance = 1e-3) => withFilter((edge) => Math.abs(curveLength(edge) - length) < tolerance),
     ofCurveType: (curveType) => withFilter((edge) => getCurveType(edge) === curveType),
     parallelTo: (dir = "Z") => createEdgeFinder([...filters]).inDirection(dir, 0),
-    atDistance: (distance, point = [0, 0, 0]) => {
+    atDistance: (distance, point = [0, 0, 0]) => withFilter((edge) => {
       const oc = getKernel().oc;
-      const pnt2 = toOcPnt(point);
-      const vtxMaker = new oc.BRepBuilderAPI_MakeVertex(pnt2);
+      const r = gcWithScope();
+      const pnt2 = r(toOcPnt(point));
+      const vtxMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt2));
       const vtx = vtxMaker.Vertex();
-      vtxMaker.delete();
-      pnt2.delete();
-      const distTool = new oc.BRepExtrema_DistShapeShape_1();
+      const distTool = r(new oc.BRepExtrema_DistShapeShape_1());
       distTool.LoadS1(vtx);
-      return withFilter((edge) => {
-        distTool.LoadS2(edge.wrapped);
-        const progress = new oc.Message_ProgressRange_1();
-        distTool.Perform(progress);
-        const d = distTool.Value();
-        progress.delete();
-        return Math.abs(d - distance) < 1e-6;
-      });
-    }
+      distTool.LoadS2(edge.wrapped);
+      const progress = r(new oc.Message_ProgressRange_1());
+      distTool.Perform(progress);
+      const d = distTool.Value();
+      return Math.abs(d - distance) < 1e-6;
+    })
   };
 }
 function faceFinder() {
@@ -10353,24 +10423,20 @@ function createFaceFinder(filters) {
     },
     parallelTo: (dir = "Z") => createFaceFinder([...filters]).inDirection(dir, 0),
     ofSurfaceType: (surfaceType) => withFilter((face) => unwrap(getSurfaceType(face)) === surfaceType),
-    atDistance: (distance, point = [0, 0, 0]) => {
+    atDistance: (distance, point = [0, 0, 0]) => withFilter((face) => {
       const oc = getKernel().oc;
-      const pnt2 = toOcPnt(point);
-      const vtxMaker = new oc.BRepBuilderAPI_MakeVertex(pnt2);
+      const r = gcWithScope();
+      const pnt2 = r(toOcPnt(point));
+      const vtxMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt2));
       const vtx = vtxMaker.Vertex();
-      vtxMaker.delete();
-      pnt2.delete();
-      const distTool = new oc.BRepExtrema_DistShapeShape_1();
+      const distTool = r(new oc.BRepExtrema_DistShapeShape_1());
       distTool.LoadS1(vtx);
-      return withFilter((face) => {
-        distTool.LoadS2(face.wrapped);
-        const progress = new oc.Message_ProgressRange_1();
-        distTool.Perform(progress);
-        const d = distTool.Value();
-        progress.delete();
-        return Math.abs(d - distance) < 1e-6;
-      });
-    }
+      distTool.LoadS2(face.wrapped);
+      const progress = r(new oc.Message_ProgressRange_1());
+      distTool.Perform(progress);
+      const d = distTool.Value();
+      return Math.abs(d - distance) < 1e-6;
+    })
   };
 }
 function createCamera(position = [0, 0, 0], direction = [0, 0, 1], xAxis) {
@@ -10396,23 +10462,8 @@ function cameraLookAt(camera, target) {
   const direction = vecNormalize(vecSub(camera.position, target));
   return createCamera(camera.position, direction);
 }
-const PLANE_MAP = {
-  XY: { dir: [0, 0, 1], xAxis: [1, 0, 0] },
-  XZ: { dir: [0, -1, 0], xAxis: [1, 0, 0] },
-  YZ: { dir: [1, 0, 0], xAxis: [0, 1, 0] },
-  YX: { dir: [0, 0, -1], xAxis: [0, 1, 0] },
-  ZX: { dir: [0, 1, 0], xAxis: [0, 0, 1] },
-  ZY: { dir: [-1, 0, 0], xAxis: [0, 0, 1] },
-  front: { dir: [0, -1, 0], xAxis: [1, 0, 0] },
-  back: { dir: [0, 1, 0], xAxis: [-1, 0, 0] },
-  right: { dir: [-1, 0, 0], xAxis: [0, -1, 0] },
-  left: { dir: [1, 0, 0], xAxis: [0, 1, 0] },
-  bottom: { dir: [0, 0, 1], xAxis: [1, 0, 0] },
-  top: { dir: [0, 0, -1], xAxis: [1, 0, 0] }
-};
 function cameraFromPlane(planeName) {
-  const config = PLANE_MAP[planeName];
-  if (!config) throw new Error(`Unknown projection plane: ${planeName}`);
+  const config = PROJECTION_PLANES[planeName];
   return createCamera([0, 0, 0], config.dir, config.xAxis);
 }
 function cameraToProjectionCamera(camera) {
@@ -10626,6 +10677,8 @@ exports.fuseAllShapes = fuseAllShapes;
 exports.fuseBlueprint2D = fuseBlueprint2D;
 exports.fuseBlueprints = fuseBlueprints;
 exports.fuseShapes = fuseShapes;
+exports.gcWithObject = gcWithObject;
+exports.gcWithScope = gcWithScope;
 exports.genericSweep = genericSweep;
 exports.getBounds = getBounds;
 exports.getEdges = getEdges$1;