brepjs-bim 0.24.3 → 0.24.5

package/dist/brepjs-bim.js

@@ -1,4 +1,4 @@
-import { GeometryCleanupError, addHoles, applyMatrix, autoHeal, box, castShape, clone, convexHull, cut, err, extrude, fuse, fuseAll, getBounds, getKernel, getSolids, isClosedWire, isOk, isPlanarWire, isSolid, isValid, isValidSolid, locate, measureVolume, mesh, ok, outerWire, polygon, revolve, rotate, translate, validSolid } from "brepjs";
+import { GeometryCleanupError, addHoles, applyMatrix, autoHeal, box, castShape, clone, convexHull, createSolid, cut, err, extrude, fuse, fuseAll, getBounds, getKernel, getSolids, isClosedWire, isOk, isPlanarWire, isSolid, isValid, isValidSolid, locate, measureVolume, mesh, ok, outerWire, polygon, revolve, rotate, translate, validSolid } from "brepjs";
 import * as WebIFC from "web-ifc";
 import { Handle, IFCROOT, IfcAPI } from "web-ifc";
 //#region src/identity/ifcGuid.ts
@@ -243,7 +243,7 @@ function _usingCtx() {
 //#region src/elementFns/wallFns.ts
 function wallToSolid(spec) {
 	try {
-		var _usingCtx$20 = _usingCtx();
+		var _usingCtx$21 = _usingCtx();
 		if (spec.length <= 0) return err(specError("WALL_ZERO_LENGTH", "Wall length must be positive"));
 		if (spec.height <= 0) return err(specError("WALL_ZERO_HEIGHT", "Wall height must be positive"));
 		if (spec.thickness <= 0) return err(specError("WALL_ZERO_THICKNESS", "Wall thickness must be positive"));
@@ -271,7 +271,7 @@ function wallToSolid(spec) {
 			]
 		]);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "WALL_PROFILE_FAILED", "Failed to create wall profile"));
-		const profile = _usingCtx$20.u(profileResult.value);
+		const profile = _usingCtx$21.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			length,
 			0,
@@ -285,16 +285,16 @@ function wallToSolid(spec) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$20.e = _;
+		_usingCtx$21.e = _;
 	} finally {
-		_usingCtx$20.d();
+		_usingCtx$21.d();
 	}
 }
 //#endregion
 //#region src/elementFns/slabFns.ts
 function slabToSolid(spec) {
 	try {
-		var _usingCtx$19 = _usingCtx();
+		var _usingCtx$20 = _usingCtx();
 		if (spec.length <= 0) return err(specError("SLAB_ZERO_LENGTH", "Slab length must be positive"));
 		if (spec.width <= 0) return err(specError("SLAB_ZERO_WIDTH", "Slab width must be positive"));
 		if (spec.thickness <= 0) return err(specError("SLAB_ZERO_THICKNESS", "Slab thickness must be positive"));
@@ -322,7 +322,7 @@ function slabToSolid(spec) {
 			]
 		]);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "SLAB_PROFILE_FAILED", "Failed to create slab profile"));
-		const profile = _usingCtx$19.u(profileResult.value);
+		const profile = _usingCtx$20.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			0,
 			0,
@@ -336,9 +336,9 @@ function slabToSolid(spec) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$19.e = _;
+		_usingCtx$20.e = _;
 	} finally {
-		_usingCtx$19.d();
+		_usingCtx$20.d();
 	}
 }
 //#endregion
@@ -6335,14 +6335,14 @@ function to3D(points) {
 }
 function extendedProfileToFace(profile) {
 	try {
-		var _usingCtx$18 = _usingCtx();
+		var _usingCtx$19 = _usingCtx();
 		const invalid = validateProfile(profile);
 		if (invalid !== null) return err(invalid);
 		const outerResult = polygon(to3D(outerLoop(profile)));
 		if (!outerResult.ok) return err(fromBrepError(outerResult.error, "PROFILE_FACE_FAILED", "Failed to build profile outer face"));
 		const holes = holeLoops(profile);
 		if (holes.length === 0) return ok(outerResult.value);
-		const outerFace = _usingCtx$18.u(outerResult.value);
+		const outerFace = _usingCtx$19.u(outerResult.value);
 		const holeFaces = [];
 		const holeWires = [];
 		const disposeHoleFaces = () => {
@@ -6367,9 +6367,9 @@ function extendedProfileToFace(profile) {
 		disposeHoleFaces();
 		return ok(faceWithHoles);
 	} catch (_) {
-		_usingCtx$18.e = _;
+		_usingCtx$19.e = _;
 	} finally {
-		_usingCtx$18.d();
+		_usingCtx$19.d();
 	}
 }
 //#endregion
@@ -6691,7 +6691,7 @@ function profileToPolygon(profile, circleSegments = 32) {
 //#region src/elementFns/beamFns.ts
 function beamToSolid(spec) {
 	try {
-		var _usingCtx$17 = _usingCtx();
+		var _usingCtx$18 = _usingCtx();
 		if (spec.length <= 0) return err(specError("BEAM_ZERO_LENGTH", "Beam length must be positive"));
 		if (isExtendedProfile(spec.profile)) try {
 			var _usingCtx3 = _usingCtx();
@@ -6729,7 +6729,7 @@ function beamToSolid(spec) {
 		]);
 		const profileResult = polygon(profilePts);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "BEAM_PROFILE_FAILED", "Failed to create beam profile"));
-		const profile = _usingCtx$17.u(profileResult.value);
+		const profile = _usingCtx$18.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			spec.length,
 			0,
@@ -6743,16 +6743,16 @@ function beamToSolid(spec) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$17.e = _;
+		_usingCtx$18.e = _;
 	} finally {
-		_usingCtx$17.d();
+		_usingCtx$18.d();
 	}
 }
 //#endregion
 //#region src/elementFns/columnFns.ts
 function columnToSolid(spec) {
 	try {
-		var _usingCtx$16 = _usingCtx();
+		var _usingCtx$17 = _usingCtx();
 		if (spec.height <= 0) return err(specError("COLUMN_ZERO_HEIGHT", "Column height must be positive"));
 		if (isExtendedProfile(spec.profile)) try {
 			var _usingCtx3 = _usingCtx();
@@ -6781,7 +6781,7 @@ function columnToSolid(spec) {
 		const profilePts = profilePtsResult.value;
 		const profileResult = polygon(profilePts);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "COLUMN_PROFILE_FAILED", "Failed to create column profile"));
-		const profile = _usingCtx$16.u(profileResult.value);
+		const profile = _usingCtx$17.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			0,
 			0,
@@ -6795,9 +6795,9 @@ function columnToSolid(spec) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$16.e = _;
+		_usingCtx$17.e = _;
 	} finally {
-		_usingCtx$16.d();
+		_usingCtx$17.d();
 	}
 }
 //#endregion
@@ -6805,7 +6805,7 @@ function columnToSolid(spec) {
 var EPSILON_MM = 1;
 function openingToSolid(spec, wallThickness) {
 	try {
-		var _usingCtx$15 = _usingCtx();
+		var _usingCtx$16 = _usingCtx();
 		if (spec.width <= 0) return err(specError("OPENING_ZERO_WIDTH", "Opening width must be positive"));
 		if (spec.height <= 0) return err(specError("OPENING_ZERO_HEIGHT", "Opening height must be positive"));
 		if (wallThickness <= 0) return err(specError("OPENING_ZERO_WALL_THICKNESS", "Wall thickness must be positive"));
@@ -6837,7 +6837,7 @@ function openingToSolid(spec, wallThickness) {
 			]
 		]);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "OPENING_PROFILE_FAILED", "Failed to create opening profile"));
-		const profile = _usingCtx$15.u(profileResult.value);
+		const profile = _usingCtx$16.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			spec.width,
 			0,
@@ -6851,16 +6851,16 @@ function openingToSolid(spec, wallThickness) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$15.e = _;
+		_usingCtx$16.e = _;
 	} finally {
-		_usingCtx$15.d();
+		_usingCtx$16.d();
 	}
 }
 //#endregion
 //#region src/elementFns/slabOpeningFns.ts
 function slabOpeningToSolid(spec, slabThickness) {
 	try {
-		var _usingCtx$14 = _usingCtx();
+		var _usingCtx$15 = _usingCtx();
 		if (spec.sizeX <= 0) return err(specError("SLAB_OPENING_ZERO_SIZE_X", "Slab opening sizeX must be positive"));
 		if (spec.sizeY <= 0) return err(specError("SLAB_OPENING_ZERO_SIZE_Y", "Slab opening sizeY must be positive"));
 		if (slabThickness <= 0) return err(specError("SLAB_OPENING_ZERO_SLAB_THICKNESS", "Slab thickness must be positive"));
@@ -6892,7 +6892,7 @@ function slabOpeningToSolid(spec, slabThickness) {
 			]
 		]);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "SLAB_OPENING_PROFILE_FAILED", "Failed to create slab opening profile"));
-		const profile = _usingCtx$14.u(profileResult.value);
+		const profile = _usingCtx$15.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			0,
 			0,
@@ -6906,16 +6906,16 @@ function slabOpeningToSolid(spec, slabThickness) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$14.e = _;
+		_usingCtx$15.e = _;
 	} finally {
-		_usingCtx$14.d();
+		_usingCtx$15.d();
 	}
 }
 //#endregion
 //#region src/elementFns/spaceFns.ts
 function spaceToSolid(spec) {
 	try {
-		var _usingCtx$13 = _usingCtx();
+		var _usingCtx$14 = _usingCtx();
 		if (spec.length <= 0) return err(specError("SPACE_ZERO_LENGTH", "Space length must be positive"));
 		if (spec.width <= 0) return err(specError("SPACE_ZERO_WIDTH", "Space width must be positive"));
 		if (spec.height <= 0) return err(specError("SPACE_ZERO_HEIGHT", "Space height must be positive"));
@@ -6943,7 +6943,7 @@ function spaceToSolid(spec) {
 			]
 		]);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "SPACE_PROFILE_FAILED", "Failed to create space footprint"));
-		const profile = _usingCtx$13.u(profileResult.value);
+		const profile = _usingCtx$14.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			0,
 			0,
@@ -6957,9 +6957,9 @@ function spaceToSolid(spec) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$13.e = _;
+		_usingCtx$14.e = _;
 	} finally {
-		_usingCtx$13.d();
+		_usingCtx$14.d();
 	}
 }
 //#endregion
@@ -6974,7 +6974,7 @@ function gate(solid, code) {
 }
 function flatRoof(spec) {
 	try {
-		var _usingCtx$12 = _usingCtx();
+		var _usingCtx$13 = _usingCtx();
 		const { length, width, thickness } = spec;
 		const face = polygon([
 			[
@@ -6999,7 +6999,7 @@ function flatRoof(spec) {
 			]
 		]);
 		if (!face.ok) return err(fromBrepError(face.error, "ROOF_PROFILE_FAILED", "Failed to create roof profile"));
-		const profile = _usingCtx$12.u(face.value);
+		const profile = _usingCtx$13.u(face.value);
 		const solid = extrude(profile, [
 			0,
 			0,
@@ -7008,9 +7008,9 @@ function flatRoof(spec) {
 		if (!solid.ok) return err(fromBrepError(solid.error, "ROOF_EXTRUDE_FAILED", "Failed to extrude roof profile"));
 		return gate(solid.value, "ROOF_INVALID_SOLID");
 	} catch (_) {
-		_usingCtx$12.e = _;
+		_usingCtx$13.e = _;
 	} finally {
-		_usingCtx$12.d();
+		_usingCtx$13.d();
 	}
 }
 function shedRoof(spec, pitch) {
@@ -7206,7 +7206,7 @@ function roofToSolid(spec) {
 //#region src/elementFns/curtainWallFns.ts
 function boxSolid(sizeX, sizeY, sizeZ) {
 	try {
-		var _usingCtx$11 = _usingCtx();
+		var _usingCtx$12 = _usingCtx();
 		const profileResult = polygon([
 			[
 				0,
@@ -7230,7 +7230,7 @@ function boxSolid(sizeX, sizeY, sizeZ) {
 			]
 		]);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "CURTAIN_WALL_PROFILE_FAILED", "Failed to create component profile"));
-		const profile = _usingCtx$11.u(profileResult.value);
+		const profile = _usingCtx$12.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			0,
 			0,
@@ -7244,9 +7244,9 @@ function boxSolid(sizeX, sizeY, sizeZ) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$11.e = _;
+		_usingCtx$12.e = _;
 	} finally {
-		_usingCtx$11.d();
+		_usingCtx$12.d();
 	}
 }
 function disposeComponents(components) {
@@ -7345,7 +7345,7 @@ function curtainWallToGrid(spec) {
 //#region src/elementFns/foundationFns.ts
 function footingToSolid(spec) {
 	try {
-		var _usingCtx$10 = _usingCtx();
+		var _usingCtx$11 = _usingCtx();
 		if (spec.length <= 0) return err(specError("FOOTING_ZERO_LENGTH", "Footing length must be positive"));
 		if (spec.width <= 0) return err(specError("FOOTING_ZERO_WIDTH", "Footing width must be positive"));
 		if (spec.thickness <= 0) return err(specError("FOOTING_ZERO_THICKNESS", "Footing thickness must be positive"));
@@ -7373,7 +7373,7 @@ function footingToSolid(spec) {
 			]
 		]);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "FOOTING_PROFILE_FAILED", "Failed to create footing profile"));
-		const profile = _usingCtx$10.u(profileResult.value);
+		const profile = _usingCtx$11.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			0,
 			0,
@@ -7387,9 +7387,9 @@ function footingToSolid(spec) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$10.e = _;
+		_usingCtx$11.e = _;
 	} finally {
-		_usingCtx$10.d();
+		_usingCtx$11.d();
 	}
 }
 function pileToSolid(spec) {
@@ -7446,7 +7446,7 @@ function pileToSolid(spec) {
 //#region src/elementFns/railingFns.ts
 function panelRailing(spec) {
 	try {
-		var _usingCtx$9 = _usingCtx();
+		var _usingCtx$10 = _usingCtx();
 		const { length, height, thickness } = spec;
 		const profileResult = polygon([
 			[
@@ -7471,7 +7471,7 @@ function panelRailing(spec) {
 			]
 		]);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "RAILING_PROFILE_FAILED", "Failed to create railing profile"));
-		const profile = _usingCtx$9.u(profileResult.value);
+		const profile = _usingCtx$10.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			length,
 			0,
@@ -7485,9 +7485,9 @@ function panelRailing(spec) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$9.e = _;
+		_usingCtx$10.e = _;
 	} finally {
-		_usingCtx$9.d();
+		_usingCtx$10.d();
 	}
 }
 function postedRailing(spec) {
@@ -7550,7 +7550,7 @@ function railingToSolid(spec) {
 //#region src/elementFns/coveringFns.ts
 function coveringToSolid(spec) {
 	try {
-		var _usingCtx$8 = _usingCtx();
+		var _usingCtx$9 = _usingCtx();
 		if (spec.length <= 0) return err(specError("COVERING_ZERO_LENGTH", "Covering length must be positive"));
 		if (spec.width <= 0) return err(specError("COVERING_ZERO_WIDTH", "Covering width must be positive"));
 		if (spec.thickness <= 0) return err(specError("COVERING_ZERO_THICKNESS", "Covering thickness must be positive"));
@@ -7578,7 +7578,7 @@ function coveringToSolid(spec) {
 			]
 		]);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "COVERING_PROFILE_FAILED", "Failed to create covering profile"));
-		const profile = _usingCtx$8.u(profileResult.value);
+		const profile = _usingCtx$9.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			0,
 			0,
@@ -7592,9 +7592,9 @@ function coveringToSolid(spec) {
 		}
 		return ok(solid);
 	} catch (_) {
-		_usingCtx$8.e = _;
+		_usingCtx$9.e = _;
 	} finally {
-		_usingCtx$8.d();
+		_usingCtx$9.d();
 	}
 }
 //#endregion
@@ -7782,6 +7782,31 @@ function measureProductBodyMaterial(solids) {
 		return measured;
 	});
 }
+/** Borrow all items and query their tight bounds in their existing coordinates. */
+function productBodyBounds(solids) {
+	const items = validateItems(solids, "productBodyBounds");
+	if (!items.ok) return items;
+	return ownedOperation("productBodyBounds", (scope) => {
+		let bounds;
+		for (const [itemIndex, solid] of items.value.entries()) {
+			scope.itemIndex = itemIndex;
+			const ready = before("bounds", itemIndex);
+			if (!ready.ok) return ready;
+			const current = (productBodyTestHooks()?.bounds ?? getBounds)(solid);
+			if (!Object.values(current).every(Number.isFinite) || current.xMin > current.xMax || current.yMin > current.yMax || current.zMin > current.zMax) return err(bodyError("productBodyBounds", "BODY_INVALID_BOUNDS", "Expected finite ordered bounds", current, itemIndex));
+			bounds = bounds === void 0 ? { ...current } : {
+				xMin: Math.min(bounds.xMin, current.xMin),
+				xMax: Math.max(bounds.xMax, current.xMax),
+				yMin: Math.min(bounds.yMin, current.yMin),
+				yMax: Math.max(bounds.yMax, current.yMax),
+				zMin: Math.min(bounds.zMin, current.zMin),
+				zMax: Math.max(bounds.zMax, current.zMax)
+			};
+		}
+		if (bounds === void 0) throw new Error("Validated Body produced no bounds");
+		return ok(Object.freeze({ bounds: Object.freeze(bounds) }));
+	});
+}
 //#endregion
 //#region src/model/bimModel.ts
 function exactWallBodyImmutable() {
@@ -8337,18 +8362,18 @@ var BimModel = class {
 	}
 	#cutWallGeometry(wall, openingSpec) {
 		try {
-			var _usingCtx$7 = _usingCtx();
+			var _usingCtx$8 = _usingCtx();
 			if (wall.geometry.kind === "EXACT") return exactWallBodyImmutable();
 			const toolResult = openingToSolid(openingSpec, wall.spec.thickness);
 			if (!toolResult.ok) return err(toolResult.error);
-			const tool = _usingCtx$7.u(toolResult.value);
+			const tool = _usingCtx$8.u(toolResult.value);
 			const cutResult = cut(wall.geometry.solid, tool);
 			if (!cutResult.ok) return err(fromBrepError(cutResult.error, "WALL_CUT_FAILED", "Boolean cut of wall with opening failed"));
 			return ok(cutResult.value);
 		} catch (_) {
-			_usingCtx$7.e = _;
+			_usingCtx$8.e = _;
 		} finally {
-			_usingCtx$7.d();
+			_usingCtx$8.d();
 		}
 	}
 	#replaceWallGeometry(wall, newGeometry) {
@@ -8963,7 +8988,7 @@ function buildSilhouette$1(numberOfRisers, riserHeight, treadLength) {
 }
 function stairFlightToSolid(spec) {
 	try {
-		var _usingCtx$6 = _usingCtx();
+		var _usingCtx$7 = _usingCtx();
 		if (spec.width <= 0) return err(specError("STAIR_FLIGHT_ZERO_WIDTH", "Stair flight width must be positive"));
 		if (spec.riserHeight <= 0) return err(specError("STAIR_FLIGHT_ZERO_RISER", "Stair flight riserHeight must be positive"));
 		if (spec.treadLength <= 0) return err(specError("STAIR_FLIGHT_ZERO_TREAD", "Stair flight treadLength must be positive"));
@@ -8971,7 +8996,7 @@ function stairFlightToSolid(spec) {
 		const silhouette = buildSilhouette$1(spec.numberOfRisers, spec.riserHeight, spec.treadLength);
 		const profileResult = polygon(silhouette);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "STAIR_FLIGHT_PROFILE_FAILED", "Failed to create stair flight silhouette profile"));
-		const profile = _usingCtx$6.u(profileResult.value);
+		const profile = _usingCtx$7.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			0,
 			spec.width,
@@ -8988,9 +9013,9 @@ function stairFlightToSolid(spec) {
 			geometrySimplified: false
 		});
 	} catch (_) {
-		_usingCtx$6.e = _;
+		_usingCtx$7.e = _;
 	} finally {
-		_usingCtx$6.d();
+		_usingCtx$7.d();
 	}
 }
 //#endregion
@@ -9021,7 +9046,7 @@ function buildSilhouette(length, rise, thickness) {
 }
 function rampFlightToSolid(spec) {
 	try {
-		var _usingCtx$5 = _usingCtx();
+		var _usingCtx$6 = _usingCtx();
 		if (spec.width <= 0) return err(specError("RAMP_FLIGHT_ZERO_WIDTH", "Ramp flight width must be positive"));
 		if (spec.length <= 0) return err(specError("RAMP_FLIGHT_ZERO_LENGTH", "Ramp flight length must be positive"));
 		if (spec.slope <= 0) return err(specError("RAMP_FLIGHT_ZERO_SLOPE", "Ramp flight slope must be positive"));
@@ -9030,7 +9055,7 @@ function rampFlightToSolid(spec) {
 		const silhouette = buildSilhouette(spec.length, rise, spec.thickness);
 		const profileResult = polygon(silhouette);
 		if (!profileResult.ok) return err(fromBrepError(profileResult.error, "RAMP_FLIGHT_PROFILE_FAILED", "Failed to create ramp flight silhouette profile"));
-		const profile = _usingCtx$5.u(profileResult.value);
+		const profile = _usingCtx$6.u(profileResult.value);
 		const solidResult = extrude(profile, [
 			0,
 			spec.width,
@@ -9047,9 +9072,9 @@ function rampFlightToSolid(spec) {
 			geometrySimplified: true
 		});
 	} catch (_) {
-		_usingCtx$5.e = _;
+		_usingCtx$6.e = _;
 	} finally {
-		_usingCtx$5.d();
+		_usingCtx$6.d();
 	}
 }
 //#endregion
@@ -9192,22 +9217,22 @@ function placedSolids(el, options = {}) {
 		case "STAIR": {
 			const out = [];
 			for (const flight of el.spec.flights) try {
-				var _usingCtx$4 = _usingCtx();
+				var _usingCtx$5 = _usingCtx();
 				const built = stairFlightToSolid(flight);
 				if (!built.ok) {
 					disposeAll$1(out);
 					return err(built.error);
 				}
-				const placed = placeWithinParent(_usingCtx$4.u(built.value.solid), flight, parentFrame);
+				const placed = placeWithinParent(_usingCtx$5.u(built.value.solid), flight, parentFrame);
 				if (!placed.ok) {
 					disposeAll$1(out);
 					return placed;
 				}
 				out.push(placed.value);
 			} catch (_) {
-				_usingCtx$4.e = _;
+				_usingCtx$5.e = _;
 			} finally {
-				_usingCtx$4.d();
+				_usingCtx$5.d();
 			}
 			return ok(out);
 		}
@@ -11691,22 +11716,22 @@ function writeStairAssembly(w, spec, stairKey, assemblyGuid, ownerHistoryId, geo
 	const flightExpressIds = [];
 	let geometrySimplified = false;
 	for (const [i, flight] of spec.flights.entries()) try {
-		var _usingCtx$3 = _usingCtx();
+		var _usingCtx$4 = _usingCtx();
 		const built = stairFlightToSolid(flight);
 		if (!built.ok) return {
 			ok: false,
 			error: built.error
 		};
-		const flightSolid = _usingCtx$3.u(built.value.solid);
+		const flightSolid = _usingCtx$4.u(built.value.solid);
 		const flightPlacementId = writeLocalPlacement(w, flight.origin, flight.axisZ, flight.axisX, stairPlacementId);
 		const tess = writeTessellation(w, flightSolid, geomSubContextId, flightPlacementId);
 		if (tess.usedFallback) geometrySimplified = true;
 		const flightExpressId = writeStairFlightEntity(w, deriveIfcGuidSync(`elem:STAIR_FLIGHT:${stairKey}:${i}`), `${stairName} Flight ${i + 1}`, flight, ownerHistoryId, flightPlacementId, tess.productDefinitionShapeId);
 		flightExpressIds.push(flightExpressId);
 	} catch (_) {
-		_usingCtx$3.e = _;
+		_usingCtx$4.e = _;
 	} finally {
-		_usingCtx$3.d();
+		_usingCtx$4.d();
 	}
 	writeRelAggregates(w, deriveIfcGuidSync(`rel:AGGREGATES:STAIR:${stairKey}`), ownerHistoryId, assemblyExpressId, flightExpressIds);
 	writeAssemblyType(w, WebIFC.IFCSTAIRTYPE, "Stair Type", deriveIfcGuidSync(`type:STAIR:${stairKey}`), deriveIfcGuidSync(`rel-type:STAIR:${stairKey}`), predefinedType, ownerHistoryId, [assemblyExpressId]);
@@ -13069,7 +13094,7 @@ function pushWeightQuantity(w, qtyIds, volumeM3, densityKgM3) {
 	if (densityKgM3 === void 0) return;
 	qtyIds.push(writeWeightQuantity(w, "GrossWeight", volumeM3, densityKgM3));
 }
-function writeWallBaseQuantities(w, ownerHistoryId, wallExpressId, spec, openings, densityKgM3) {
+function writeWallBaseQuantities(w, ownerHistoryId, wallExpressId, spec, openings, netVolumeM3, densityKgM3) {
 	const lengthM = toIfcLengthM(spec.length);
 	const widthM = toIfcLengthM(spec.thickness);
 	const heightM = toIfcLengthM(spec.height);
@@ -13085,7 +13110,6 @@ function writeWallBaseQuantities(w, ownerHistoryId, wallExpressId, spec, opening
 		if (toIfcLengthM(op.offsetFromFloor) < FLOOR_TOUCH_EPSILON_M) sumFloorTouchingFootprintM2 += opWidthM * widthM;
 	}
 	const netSideAreaM2 = grossSideAreaM2 - sumOpeningAreaM2;
-	const netVolumeM3 = grossVolumeM3 - sumOpeningAreaM2 * widthM;
 	const netFootprintM2 = grossFootprintM2 - sumFloorTouchingFootprintM2;
 	const qtyIds = [
 		writeQtyLength(w, "Length", lengthM),
@@ -13101,7 +13125,7 @@ function writeWallBaseQuantities(w, ownerHistoryId, wallExpressId, spec, opening
 	pushWeightQuantity(w, qtyIds, netVolumeM3, densityKgM3);
 	writeRelDefinesByProperties(w, ownerHistoryId, wallExpressId, writeElementQuantity(w, ownerHistoryId, "Qto_WallBaseQuantities", qtyIds));
 }
-function writeExactWallBaseQuantities(w, ownerHistoryId, wallExpressId, values) {
+function writeWallBodyQuantities(w, ownerHistoryId, wallExpressId, values) {
 	writeRelDefinesByProperties(w, ownerHistoryId, wallExpressId, writeElementQuantity(w, ownerHistoryId, "Qto_WallBaseQuantities", [
 		writeQtyLength(w, "Length", values.lengthM),
 		writeQtyLength(w, "Width", values.widthM),
@@ -15165,10 +15189,25 @@ function preflightExactBody(input) {
 	return ok([first.value, ...remainingPrepared]);
 }
 //#endregion
-//#region src/serialize/exactWallQuantities.ts
-function deriveExactWallQuantities(input) {
+//#region src/serialize/wallQuantities.ts
+function deriveWallQuantities(input) {
 	try {
-		const measured = measureProductBodyMaterial(input.solids);
+		const items = [];
+		for (const retained of input.solids) {
+			if (getKernel().shapeType(retained.wrapped) !== "compound") {
+				items.push(retained);
+				continue;
+			}
+			const cardinality = singleWrapperChild(retained);
+			if (!cardinality.ok) return cardinality;
+			const children = getSolids(retained);
+			const [child] = children;
+			if (children.length !== 1 || child === void 0 || !isValidSolid(child)) return wallVolumeError(/* @__PURE__ */ new Error("Expected one valid solid in a retained recipe wrapper"));
+			items.push(child);
+		}
+		const [first, ...rest] = items;
+		if (first === void 0) return wallVolumeError(/* @__PURE__ */ new Error("Expected retained Wall material"));
+		const measured = measureProductBodyMaterial([first, ...rest]);
 		if (!measured.ok) return wallVolumeError(measured.error);
 		return ok({
 			lengthM: toIfcLengthM(input.spec.length),
@@ -15180,8 +15219,24 @@ function deriveExactWallQuantities(input) {
 		return wallVolumeError(cause);
 	}
 }
+/** Count before cached extraction: a failed later cast cannot strand earlier children. */
+function singleWrapperChild(retained) {
+	const kernel = getKernel();
+	let count;
+	if (kernel.subShapeCount !== void 0) count = kernel.subShapeCount(retained.wrapped, "solid");
+	else {
+		const rawChildren = kernel.iterShapes(retained.wrapped, "solid");
+		const cleanup = cleanupOwnedResources(rawChildren.map((raw, itemIndex) => ({
+			resource: { [Symbol.dispose]: () => kernel.dispose(raw) },
+			itemIndex
+		})), { operation: "wallQuantityWrapperCount" });
+		if (cleanup.kind === "FAILED") return wallVolumeError({ cleanup });
+		count = rawChildren.length;
+	}
+	return count === 1 ? ok(void 0) : wallVolumeError(/* @__PURE__ */ new Error("Expected one valid solid in a retained recipe wrapper"));
+}
 function wallVolumeError(cause) {
-	return err(ifcError("IFC_EXACT_WALL_QUANTITY_DERIVATION_FAILED", "Failed to derive a positive finite NetVolume for the retained Wall Body", cause));
+	return err(ifcError("IFC_WALL_QUANTITY_DERIVATION_FAILED", "Failed to derive a positive finite NetVolume for the retained Wall Body", cause));
 }
 //#endregion
 //#region src/serialize/toIfc.ts
@@ -15212,8 +15267,13 @@ function preflightProductBodies(elements) {
 	return ok(preflighted);
 }
 async function toIfc(model, meta) {
+	const serialized = await serializeIfc(model, meta);
+	return serialized.ok ? ok(serialized.value.bytes) : serialized;
+}
+async function serializeIfc(model, meta) {
 	try {
-		var _usingCtx$2 = _usingCtx();
+		var _usingCtx$3 = _usingCtx();
+		const issues = [];
 		const project = model.getProject();
 		if (!project) return err(ifcError("NO_PROJECT", "BimModel has no project — call model.init() first"));
 		if ((model.getBridges().length > 0 || model.getBridgeParts().length > 0 || model.getEarthworksFills().length > 0) && (meta.ifcSchema ?? "IFC4") !== "IFC4X3") return err(ifcError("IFC4X3_REQUIRED", "Bridge, Bridge Part, and Earthworks Fill entities require IFC4X3 serialization"));
@@ -15223,7 +15283,7 @@ async function toIfc(model, meta) {
 			organization: meta.organizationName
 		});
 		if (!writerResult.ok) return writerResult;
-		const w = _usingCtx$2.u(writerResult.value);
+		const w = _usingCtx$3.u(writerResult.value);
 		w.setModelScope(project.guid);
 		const elements = model.getAllElements();
 		const relationships = model.getAllRelationships();
@@ -15331,10 +15391,10 @@ async function toIfc(model, meta) {
 			const wall = preflighted.element;
 			const containingId = findContainerOf(wall.localId, relationships);
 			const storeyPlacementId = containingId !== null ? placementMap.get(containingId) ?? null : null;
-			const exactQuantities = preflighted.kind === "EXACT" ? deriveExactWallQuantities({
+			const bodyQuantities = deriveWallQuantities({
 				spec: wall.spec,
-				solids: preflighted.solids
-			}) : null;
+				solids: bodySolids(wall.geometry)
+			});
 			const { localPlacementId, productDefinitionShapeId } = preflighted.kind === "EXACT" ? writeExactBodyGeometry(w, wall.spec, preflighted.items, geomSubContextId, storeyPlacementId) : writeWallGeometry(w, wall.spec, geomSubContextId, storeyPlacementId);
 			const wallExpressId = writeWallEntity(w, wall.guid, `Wall ${i + 1}`, ownerHistoryId, localPlacementId, productDefinitionShapeId);
 			idMap.set(wall.localId, wallExpressId);
@@ -15342,9 +15402,12 @@ async function toIfc(model, meta) {
 			writeWallCommonPset(w, ownerHistoryId, wallExpressId, wall.spec);
 			writeManufacturerPset(w, ownerHistoryId, wallExpressId, wall.spec);
 			if (wall.spec.customProperties !== void 0) writeCustomPsets(w, ownerHistoryId, wallExpressId, wall.spec.customProperties);
-			if (preflighted.kind === "EXACT") {
-				if (exactQuantities !== null && exactQuantities.ok) writeExactWallBaseQuantities(w, ownerHistoryId, wallExpressId, exactQuantities.value);
-			} else writeWallBaseQuantities(w, ownerHistoryId, wallExpressId, wall.spec, openingsByWall.get(wall.localId) ?? [], densityByElement.get(wall.localId));
+			if (!bodyQuantities.ok) issues.push(issue("warning", "WALL_QUANTITY_OMITTED", "Wall quantities omitted because occupied material volume could not be measured", wall.localId, {
+				guid: wall.guid,
+				cause: bodyQuantities.error
+			}));
+			else if (wall.geometry.kind === "PARAMETRIC") writeWallBaseQuantities(w, ownerHistoryId, wallExpressId, wall.spec, openingsByWall.get(wall.localId) ?? [], bodyQuantities.value.netVolumeM3, densityByElement.get(wall.localId));
+			else writeWallBodyQuantities(w, ownerHistoryId, wallExpressId, bodyQuantities.value);
 		}
 		for (const [i, slab] of slabs.entries()) {
 			const containingId = findContainerOf(slab.localId, relationships);
@@ -15688,11 +15751,15 @@ async function toIfc(model, meta) {
 		for (const { ref, ids } of classByKey.values()) byClassification.set(ref, ids);
 		if (byClassification.size > 0) writeClassificationRefs(w, ownerHistoryId, byClassification);
 		writeTypeLayer(w, ownerHistoryId, model, idMap);
-		return w.save();
+		const saved = w.save();
+		return saved.ok ? ok({
+			bytes: saved.value,
+			issues
+		}) : saved;
 	} catch (_) {
-		_usingCtx$2.e = _;
+		_usingCtx$3.e = _;
 	} finally {
-		_usingCtx$2.d();
+		_usingCtx$3.d();
 	}
 }
 /**
@@ -15808,15 +15875,16 @@ function toOccurrences(elements, predefined) {
 async function toIfcValidated(model, meta) {
 	const integrity = checkReferentialIntegrity(model);
 	if (hasErrors(integrity)) return err(ifcError("INTEGRITY_FAILURE", "Model failed referential integrity check", integrity.issues.filter((i) => i.severity === "error")));
-	const bytesResult = await toIfc(model, meta);
-	if (!bytesResult.ok) return bytesResult;
-	const bytes = bytesResult.value;
+	const serialized = await serializeIfc(model, meta);
+	if (!serialized.ok) return serialized;
+	const { bytes } = serialized.value;
 	const geometry = collectGeometryIssues(model);
 	const schema = await checkSchema(bytes);
 	const roundTrip = await checkRoundTrip(bytes);
 	const gherkin = await checkGherkinRules(bytes);
 	const report = { issues: [
 		...integrity.issues,
+		...serialized.value.issues,
 		...geometry.issues,
 		...schema.issues,
 		...roundTrip.issues,
@@ -16409,13 +16477,13 @@ function reconstructExtrusion(reader, extrusionId, scale, worldTransform, diagno
 	];
 	const solidResult = (() => {
 		try {
-			var _usingCtx$1 = _usingCtx();
-			const face = _usingCtx$1.u(faceResult.value);
+			var _usingCtx$2 = _usingCtx();
+			const face = _usingCtx$2.u(faceResult.value);
 			return extrude(face, extrudeVec);
 		} catch (_) {
-			_usingCtx$1.e = _;
+			_usingCtx$2.e = _;
 		} finally {
-			_usingCtx$1.d();
+			_usingCtx$2.d();
 		}
 	})();
 	if (!solidResult.ok) {
@@ -17137,6 +17205,161 @@ function errMsg$1(e) {
 	return e instanceof Error ? e.message : String(e);
 }
 //#endregion
+//#region src/geometryCleanupDiagnostics.ts
+var diagnosticSchema = object({
+	operation: string(),
+	itemIndex: number().int().nonnegative(),
+	resourceKind: _enum(["SHAPE", "TRANSFORM"]),
+	localId: number().optional(),
+	cause: unknown()
+});
+var failedCleanup = object({
+	kind: literal("FAILED"),
+	diagnostics: array(unknown()).nonempty()
+});
+var errorMetadata = object({ cleanup: unknown().optional() });
+var cleanupAttempt = Symbol("geometryCleanupAttempt");
+var bodyOperation = _enum(["productBodyBounds", "measureProductBodyMaterial"]);
+function attemptIdentity(source) {
+	const identity = cleanupAttempt in source ? source[cleanupAttempt] : source;
+	return typeof identity === "object" && identity !== null ? identity : source;
+}
+function errorChildren(value) {
+	const children = [];
+	if (value instanceof AggregateError) {
+		const errors = value.errors;
+		children.push(...errors);
+	}
+	if ("cause" in value) children.push(value.cause);
+	if ("error" in value && "suppressed" in value) children.push(value.error, value.suppressed);
+	return children;
+}
+/** Keep the actual failed-attempt markers; their causes need not be unique. */
+function nativeCleanupAttempts(error) {
+	const attempts = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (typeof value !== "object" || value === null || seen.has(value)) return;
+		seen.add(value);
+		if (value instanceof GeometryCleanupError) attempts.push(value);
+		else errorChildren(value).forEach(visit);
+	};
+	visit(error);
+	return attempts;
+}
+/** Read prior owner attempts without retrying releases or merging distinct failures. */
+function reportedGeometryCleanup(error, operation, context = {}) {
+	const diagnostics = [];
+	const seenErrors = /* @__PURE__ */ new Set();
+	const seenAttempts = /* @__PURE__ */ new Set();
+	const add = (diagnostic, identity) => {
+		if (seenAttempts.has(identity)) return;
+		seenAttempts.add(identity);
+		diagnostics.push(Object.freeze({
+			operation: diagnostic.operation,
+			itemIndex: diagnostic.itemIndex,
+			resourceKind: diagnostic.resourceKind,
+			cause: diagnostic.cause,
+			...diagnostic.localId === void 0 ? {} : { localId: diagnostic.localId },
+			[cleanupAttempt]: identity
+		}));
+	};
+	const visit = (value) => {
+		if (typeof value !== "object" || value === null || seenErrors.has(value)) return;
+		seenErrors.add(value);
+		const metadata = errorMetadata.safeParse("metadata" in value ? value.metadata : void 0);
+		const reports = [metadata.success ? metadata.data.cleanup : void 0, "cleanup" in value ? value.cleanup : void 0];
+		const nativeAttempts = bodyOperation.safeParse("operation" in value ? value.operation : void 0).success ? nativeCleanupAttempts(value) : [];
+		const matched = /* @__PURE__ */ new Set();
+		const seenEntries = /* @__PURE__ */ new Set();
+		for (const report of reports) {
+			const parsed = failedCleanup.safeParse(report);
+			if (!parsed.success) continue;
+			for (const source of parsed.data.diagnostics) {
+				if (typeof source !== "object" || source === null || seenEntries.has(source)) continue;
+				const diagnostic = diagnosticSchema.safeParse(source);
+				if (!diagnostic.success) continue;
+				seenEntries.add(source);
+				let identity = attemptIdentity(source);
+				if (identity === source) {
+					const native = nativeAttempts.find((attempt) => !matched.has(attempt) && attempt.resourceKind === diagnostic.data.resourceKind && attempt.cause === diagnostic.data.cause);
+					if (native !== void 0) identity = native;
+				}
+				if (identity instanceof GeometryCleanupError) matched.add(identity);
+				add(diagnostic.data, identity);
+			}
+		}
+		if (value instanceof GeometryCleanupError) add({
+			operation,
+			itemIndex: context.itemIndex ?? 0,
+			resourceKind: value.resourceKind,
+			cause: value.cause
+		}, value);
+		else errorChildren(value).forEach(visit);
+	};
+	visit(error);
+	return diagnostics;
+}
+//#endregion
+//#region src/import/cutImportedSolids.ts
+/** Borrow World-placed inputs; own every disconnected result independently of the cut's cache. */
+function cutImportedSolids(host, opening) {
+	const context = { operation: "cutImportedSolids" };
+	const temporaries = [];
+	const outputs = [];
+	const build = () => {
+		const cutResult = cut(host, opening);
+		if (!cutResult.ok) return err(fromBrepError(cutResult.error, "VOID_CUT_FAILED", "Opening cut failed"));
+		temporaries.push({
+			resource: cutResult.value,
+			itemIndex: 0
+		});
+		const children = getKernel().iterShapes(cutResult.value.wrapped, "solid").map(createSolid);
+		temporaries.push(...children.map((resource, itemIndex) => ({
+			resource,
+			itemIndex
+		})));
+		for (const solid of children) {
+			const copied = clone(solid);
+			if (!copied.ok) return err(fromBrepError(copied.error, "VOID_COPY_FAILED", "Could not retain opening result"));
+			const candidate = copied.value;
+			temporaries.push({
+				resource: candidate,
+				itemIndex: temporaries.length
+			});
+			const validated = validSolid(candidate);
+			if (!validated.ok) return err(importError("VOID_INVALID_SOLID", "Opening result is not valid", validated.error));
+			outputs.push(validated.value);
+		}
+		return ok(outputs);
+	};
+	let result;
+	try {
+		result = build();
+	} catch (cause) {
+		result = err(importError("VOID_CUT_FAILED", "Opening cut failed", cause));
+	}
+	const survivors = new Set(result.ok ? outputs : []);
+	const cleanup = cleanupOwnedResources(temporaries.filter(({ resource }) => !survivors.has(resource)).reverse(), context);
+	const diagnostics = [...result.ok ? [] : reportedGeometryCleanup(result.error, context.operation), ...cleanup.kind === "FAILED" ? cleanup.diagnostics : []];
+	if (result.ok && diagnostics.length === 0) return result;
+	if (result.ok) {
+		const outputCleanup = cleanupOwnedResources(outputs.map((resource, itemIndex) => ({
+			resource,
+			itemIndex
+		})), context);
+		if (outputCleanup.kind === "FAILED") diagnostics.push(...outputCleanup.diagnostics);
+	}
+	const failure = result.ok ? importError("VOID_CLEANUP_FAILED", "Opening result cleanup failed") : result.error;
+	return err({
+		...failure,
+		metadata: {
+			...failure.metadata,
+			cleanup: cleanupReport(diagnostics)
+		}
+	});
+}
+//#endregion
 //#region src/import/dataRead.ts
 /** Narrows an unknown line attribute to the `{ type, value }` wrapper shape. */
 function asTyped(v) {
@@ -17492,7 +17715,7 @@ var ELEMENT_TYPES = [
 * fatal failures — bad bytes, unsupported schema, WASM open failure — return
 * `err`. Inspect {@link ImportedModel.diagnostics} for per-element quality.
 *
-* The web-ifc model handle is always closed in a `finally` block.
+* The web-ifc model handle is closed before handing reconstructed owners to the caller.
 */
 async function fromIfc(bytes, options = {}) {
 	const settings = { coordinateToOrigin: options.coordinateToOrigin ?? false };
@@ -17500,6 +17723,7 @@ async function fromIfc(bytes, options = {}) {
 	if (!readerResult.ok) return err(readerResult.error);
 	const reader = readerResult.value;
 	const elements = [];
+	let result;
 	try {
 		reader.buildGuidMap();
 		const diagnostics = [];
@@ -17526,13 +17750,23 @@ async function fromIfc(bytes, options = {}) {
 			diagnostics: report,
 			...applicationName !== void 0 ? { applicationName } : {}
 		};
-		return ok(model);
+		result = ok(model);
 	} catch (e) {
-		disposeElements(elements);
-		return err(importError("IMPORT_FAILED", "Unexpected failure during IFC import", e));
-	} finally {
+		result = err(importError("IMPORT_FAILED", "Unexpected failure during IFC import", e));
+	}
+	try {
 		reader.close();
+	} catch (cause) {
+		result = err(result.ok ? importError("IMPORT_CLOSE_FAILED", "Failed to close IFC reader", cause) : {
+			...result.error,
+			metadata: {
+				...result.error.metadata,
+				readerCloseCause: cause
+			}
+		});
 	}
+	if (!result.ok) return err(withCleanup(result.error, disposeElements(elements), "fromIfc"));
+	return result;
 }
 /**
 * Reads one product into an {@link ImportedElement}. Returns null only when the
@@ -17583,8 +17817,8 @@ function readElement(reader, expressId, category, scale, containment, typeEnums,
 			...fills !== void 0 ? { fills } : {}
 		};
 	} catch (e) {
-		if (geometry !== null) disposeGeometry(geometry);
-		diagnostics.push(issue("error", "ELEMENT_READ_FAILED", `Element ${expressId} reconstruction threw: ${errMsg(e)}`, expressId));
+		const failure = geometry === null ? e : withCleanup(importError("ELEMENT_READ_FAILED", "Element read failed", e), disposeGeometry(geometry), "readElement");
+		diagnostics.push(issue("error", "ELEMENT_READ_FAILED", `Element ${expressId} reconstruction threw: ${errMsg(e)}`, expressId, { cause: failure }));
 		return null;
 	}
 }
@@ -17600,36 +17834,79 @@ function findFills(reader, elementExpressId) {
 }
 /**
 * Reconstructs a host element's body geometry and, per IFC `IfcRelVoidsElement`
-* semantics, subtracts the reconstructed solid of every opening that voids it —
+* semantics, subtracts each opening's Body representation from a parametric host —
 * so a wall with a door hole comes back as the cut solid, matching the source
 * model. Falls back to the uncut solid (with a diagnostic) if a cut fails.
 */
 function reconstructGeometry(reader, expressId, scale, voidedBy, diagnostics) {
 	const base = toImportedGeometry(reader, expressId, scale, diagnostics);
 	if (base.fidelity !== "PARAMETRIC" || base.completeness !== "COMPLETE" || voidedBy.length === 0) return base;
-	const firstHost = base.solids[0];
-	if (firstHost === void 0) return base;
-	const hosts = [firstHost, ...base.solids.slice(1)];
-	for (const openingId of voidedBy) {
-		const opening = readBodyGeometry(reader, openingId, scale, diagnostics);
-		if (opening.kind !== "SOLID") continue;
-		try {
-			for (let hostIndex = 0; hostIndex < hosts.length; hostIndex++) {
+	if (base.solids[0] === void 0) return base;
+	const hosts = [...base.solids];
+	try {
+		for (const openingId of voidedBy) try {
+			var _usingCtx$1 = _usingCtx();
+			const opening = readBodyGeometry(reader, openingId, scale, diagnostics);
+			if (opening.kind !== "SOLID") continue;
+			const openingOwner = _usingCtx$1.u(ownOpening(opening.solid, openingId));
+			for (let hostIndex = 0; hostIndex < hosts.length;) {
 				const host = hosts[hostIndex];
-				if (host === void 0) continue;
-				const cutResult = cut(host, opening.solid);
+				if (host === void 0) break;
+				const cutResult = cutImportedSolids(host, openingOwner.solid);
 				if (!cutResult.ok) {
-					diagnostics.push(issue("warning", "VOID_SUBTRACTION_FAILED", `Opening ${openingId} could not be subtracted from element ${expressId}: ${cutResult.error.message}`, expressId));
+					diagnostics.push(issue("warning", "VOID_SUBTRACTION_FAILED", `Opening ${openingId} could not be subtracted from element ${expressId}: ${cutResult.error.message}`, expressId, { cause: cutResult.error }));
+					hostIndex++;
 					continue;
 				}
-				host[Symbol.dispose]();
-				hosts[hostIndex] = cutResult.value;
+				hosts.splice(hostIndex, 1, ...cutResult.value);
+				const cleanup = cleanupOwnedResources([{
+					resource: host,
+					itemIndex: hostIndex
+				}], { operation: "importOpening" });
+				if (cleanup.kind === "FAILED") diagnostics.push(issue("warning", "VOID_HOST_CLEANUP_FAILED", "Opening result retained, but previous host release failed", expressId, { cleanup }));
+				hostIndex += cutResult.value.length;
 			}
+		} catch (_) {
+			_usingCtx$1.e = _;
 		} finally {
-			opening.solid[Symbol.dispose]();
+			_usingCtx$1.d();
 		}
+		return completeImportedGeometry("PARAMETRIC", hosts, expressId, diagnostics);
+	} catch (cause) {
+		const failure = importError("GEOMETRY_RECONSTRUCTION_FAILED", "Opening reconstruction failed", cause);
+		const cleanup = cleanupOwnedResources(hosts.map((resource, itemIndex) => ({
+			resource,
+			itemIndex
+		})), { operation: "reconstructGeometry" });
+		throw Object.assign(new Error(failure.message, { cause }), {
+			code: failure.code,
+			metadata: withCleanup(failure, cleanup, "reconstructGeometry").metadata
+		});
 	}
-	return completeImportedGeometry("PARAMETRIC", hosts, expressId, diagnostics);
+}
+function ownOpening(solid, openingId) {
+	return {
+		solid,
+		[Symbol.dispose]() {
+			const cleanup = cleanupOwnedResources([{
+				resource: solid,
+				itemIndex: 0
+			}], { operation: "importOpeningTool" });
+			if (cleanup.kind === "FAILED") throw new Error(`Opening ${openingId} cleanup failed`, { cause: {
+				...importError("OPENING_CLEANUP_FAILED", "Temporary opening release failed"),
+				metadata: { cleanup }
+			} });
+		}
+	};
+}
+function withCleanup(error, cleanup, operation) {
+	return {
+		...error,
+		metadata: {
+			...error.metadata,
+			cleanup: cleanupReport([...reportedGeometryCleanup(error, operation), ...cleanup.kind === "FAILED" ? cleanup.diagnostics : []])
+		}
+	};
 }
 function toImportedGeometry(reader, expressId, scale, diagnostics) {
 	const body = readBodyItems(reader, expressId, scale, diagnostics);
@@ -17677,61 +17954,48 @@ function completeImportedGeometry(fidelity, solids, expressId, diagnostics) {
 		fidelity,
 		completeness: "COMPLETE",
 		solids,
-		solid: solids.length === 1 ? solids[0] : null,
+		solid: solids.length === 1 ? solids[0] ?? null : null,
 		...measureCompleteBody(solids, expressId, diagnostics)
 	};
 }
 function measureCompleteBody(solids, expressId, diagnostics) {
+	const unavailable = (cause, message = errMsg(cause)) => {
+		diagnostics.push(issue("warning", "BODY_AGGREGATE_MEASUREMENT_FAILED", `Complete Body aggregate measurement failed: ${message}`, expressId, { cause }));
+		return {
+			bounds: null,
+			volumeMm3: null
+		};
+	};
 	try {
-		const first = solids[0];
+		const [first, ...rest] = solids;
 		if (first === void 0) return {
 			bounds: null,
 			volumeMm3: null
 		};
-		const initial = getBounds(first);
-		let xMin = initial.xMin;
-		let xMax = initial.xMax;
-		let yMin = initial.yMin;
-		let yMax = initial.yMax;
-		let zMin = initial.zMin;
-		let zMax = initial.zMax;
-		let volumeMm3 = 0;
-		for (const solid of solids) {
-			const measured = measureVolume(solid);
-			if (!measured.ok) throw new Error(measured.error.message);
-			volumeMm3 += measured.value;
-			const itemBounds = getBounds(solid);
-			xMin = Math.min(xMin, itemBounds.xMin);
-			xMax = Math.max(xMax, itemBounds.xMax);
-			yMin = Math.min(yMin, itemBounds.yMin);
-			yMax = Math.max(yMax, itemBounds.yMax);
-			zMin = Math.min(zMin, itemBounds.zMin);
-			zMax = Math.max(zMax, itemBounds.zMax);
-		}
+		const items = [first, ...rest];
+		const bounds = productBodyBounds(items);
+		if (!bounds.ok) return unavailable(bounds.error, bounds.error.message);
+		const volume = measureProductBodyMaterial(items);
+		if (!volume.ok) return unavailable(volume.error, volume.error.message);
 		return {
-			bounds: {
-				xMin,
-				xMax,
-				yMin,
-				yMax,
-				zMin,
-				zMax
-			},
-			volumeMm3
+			bounds: bounds.value.bounds,
+			volumeMm3: volume.value
 		};
 	} catch (cause) {
-		diagnostics.push(issue("warning", "BODY_AGGREGATE_MEASUREMENT_FAILED", `Complete Body aggregate measurement failed: ${errMsg(cause)}`, expressId));
-		return {
-			bounds: null,
-			volumeMm3: null
-		};
+		return unavailable(cause);
 	}
 }
 function disposeGeometry(geometry) {
-	for (const solid of geometry.solids) solid[Symbol.dispose]();
+	return cleanupOwnedResources(geometry.solids.map((resource, itemIndex) => ({
+		resource,
+		itemIndex
+	})), { operation: "disposeImportedGeometry" });
 }
 function disposeElements(elements) {
-	for (const element of elements) disposeGeometry(element.geometry);
+	return cleanupOwnedResources(elements.flatMap(({ geometry }) => geometry.solids).map((resource, itemIndex) => ({
+		resource,
+		itemIndex
+	})), { operation: "disposeImportedElements" });
 }
 function toImportedPset(pset) {
 	return {