brepjs-bim 0.23.1 → 0.23.2

package/dist/brepjs-bim.js

@@ -1,4 +1,4 @@
-import { addHoles, applyMatrix, autoHeal, box, castShape, clone, convexHull, cut, err, extrude, fuse, getKernel, getSolids, isClosedWire, isOk, isPlanarWire, isSolid, isValid, isValidSolid, measureVolume, mesh, ok, outerWire, polygon, revolve, rotate, translate, validSolid } from "brepjs";
+import { addHoles, applyMatrix, autoHeal, box, castShape, clone, convexHull, cut, err, extrude, fuse, getBounds, getKernel, getSolids, isClosedWire, isOk, isPlanarWire, isSolid, isValid, isValidSolid, measureVolume, mesh, ok, outerWire, polygon, revolve, rotate, translate, validSolid } from "brepjs";
 import * as WebIFC from "web-ifc";
 import { Handle, IfcAPI } from "web-ifc";
 //#region src/identity/ifcGuid.ts
@@ -14065,6 +14065,7 @@ function buildElementContainmentMap(reader) {
 //#endregion
 //#region src/import/geometryRead.ts
 var NONE = { kind: "NONE" };
+var testHooks$1 = null;
 /**
 * Reconstructs the `Body` (SweptSolid) representation of a product into a brepjs
 * solid, falling back to tessellated mesh import when no parametric path exists.
@@ -14075,27 +14076,66 @@ var NONE = { kind: "NONE" };
 * single bad element never aborts a model import.
 */
 function readBodyGeometry(reader, productExpressId, scale, diagnostics) {
+	const body = readBodyItems(reader, productExpressId, scale, diagnostics);
+	const selected = body.items.find((item) => item.kind !== "NONE") ?? NONE;
+	for (const item of body.items) if (item !== selected && item.kind === "SOLID") item.solid[Symbol.dispose]();
+	return selected;
+}
+/** Reconstructs each supported IFC Body item independently in representation order. */
+function readBodyItems(reader, productExpressId, scale, diagnostics) {
 	const product = reader.getLine(productExpressId);
-	if (product === null) return NONE;
+	if (product === null) return {
+		hasBody: false,
+		itemCount: 0,
+		items: []
+	};
 	const representationRef = asRef(product["Representation"]);
-	if (representationRef === void 0) return NONE;
+	if (representationRef === void 0) return {
+		hasBody: false,
+		itemCount: 0,
+		items: []
+	};
 	const productShape = reader.getLine(representationRef.value);
 	const representations = productShape === null ? void 0 : asRefArray(productShape["Representations"]);
-	if (representations === void 0) return NONE;
-	const bodyItemId = findBodyItem(reader, representations);
-	if (bodyItemId === void 0) return NONE;
+	if (representations === void 0) return {
+		hasBody: false,
+		itemCount: 0,
+		items: []
+	};
+	const bodyItemIds = findBodyItems(reader, representations);
+	if (bodyItemIds === null) return {
+		hasBody: false,
+		itemCount: 0,
+		items: []
+	};
 	const worldTransform = readWorldTransform(reader, product, scale);
-	const itemType = reader.getLineType(bodyItemId);
-	try {
-		if (itemType === WebIFC.IFCEXTRUDEDAREASOLID) return reconstructExtrusion(reader, bodyItemId, scale, worldTransform, diagnostics);
-		if (itemType === WebIFC.IFCREVOLVEDAREASOLID) return reconstructRevolution(reader, bodyItemId, scale, worldTransform, diagnostics);
-		if (isTessellatedType(itemType)) return reconstructTessellated(reader, productExpressId, diagnostics);
-	} catch (e) {
-		diagnostics.push(issue("warning", "GEOMETRY_RECONSTRUCTION_FAILED", `Body geometry reconstruction threw: ${errMsg$1(e)}`, productExpressId));
-		return NONE;
+	const itemTypes = new Map(bodyItemIds.map((id) => [id, reader.getLineType(id)]));
+	const streamedItemIds = new Set(bodyItemIds.filter((id) => isStreamedTessellatedType(itemTypes.get(id))));
+	let streamedMeshes = /* @__PURE__ */ new Map();
+	if (streamedItemIds.size > 0) try {
+		streamedMeshes = collectItemMeshes(reader, productExpressId, streamedItemIds);
+	} catch (cause) {
+		diagnostics.push(issue("warning", "GEOMETRY_RECONSTRUCTION_FAILED", `Body tessellation stream failed: ${errMsg$1(cause)}`, productExpressId));
 	}
-	diagnostics.push(issue("warning", "UNSUPPORTED_REPRESENTATION_ITEM", `Unsupported body representation item type ${itemType}; geometry skipped`, productExpressId));
-	return NONE;
+	const items = bodyItemIds.map((bodyItemId) => {
+		const itemType = itemTypes.get(bodyItemId);
+		try {
+			if (itemType === WebIFC.IFCEXTRUDEDAREASOLID) return reconstructExtrusion(reader, bodyItemId, scale, worldTransform, diagnostics);
+			if (itemType === WebIFC.IFCREVOLVEDAREASOLID) return reconstructRevolution(reader, bodyItemId, scale, worldTransform, diagnostics);
+			if (itemType === WebIFC.IFCTRIANGULATEDFACESET) return reconstructTriangulatedItem(reader, bodyItemId, scale, worldTransform, diagnostics);
+			if (isStreamedTessellatedType(itemType)) return reconstructStreamedTessellatedItem(streamedMeshes.get(bodyItemId), bodyItemId, diagnostics);
+		} catch (cause) {
+			diagnostics.push(issue("warning", "GEOMETRY_RECONSTRUCTION_FAILED", `Body item ${bodyItemId} reconstruction threw: ${errMsg$1(cause)}`, bodyItemId, { productExpressId }));
+			return NONE;
+		}
+		diagnostics.push(issue("warning", "UNSUPPORTED_REPRESENTATION_ITEM", `Unsupported Body item ${bodyItemId} type ${itemType}; geometry skipped`, bodyItemId, { productExpressId }));
+		return NONE;
+	});
+	return {
+		hasBody: true,
+		itemCount: bodyItemIds.length,
+		items
+	};
 }
 function reconstructExtrusion(reader, extrusionId, scale, worldTransform, diagnostics) {
 	const ext = reader.getLine(extrusionId);
@@ -14227,22 +14267,61 @@ function reconstructRevolution(reader, revolutionId, scale, worldTransform, diag
 	}
 	return finalizeSolid(placed.value, revolutionId, diagnostics);
 }
-function reconstructTessellated(reader, productExpressId, diagnostics) {
-	const mesh = collectMesh(reader, productExpressId);
+function reconstructTriangulatedItem(reader, itemExpressId, scale, worldTransform, diagnostics) {
+	const faceSet = reader.getLine(itemExpressId);
+	const coordinatesRef = faceSet === null ? void 0 : asRef(faceSet["Coordinates"]);
+	const rawPoints = (coordinatesRef === void 0 ? null : reader.getLine(coordinatesRef.value))?.["CoordList"];
+	const rawTriangles = faceSet?.["CoordIndex"];
+	return reconstructTessellatedMesh(readTriangulatedMesh(rawPoints, rawTriangles, scale, worldTransform), 1, itemExpressId, diagnostics);
+}
+function reconstructStreamedTessellatedItem(mesh, itemExpressId, diagnostics) {
+	return reconstructTessellatedMesh(mesh ?? null, 1e3, itemExpressId, diagnostics);
+}
+function reconstructTessellatedMesh(mesh, scaleToMm, itemExpressId, diagnostics) {
 	if (mesh === null || mesh.indices.length === 0) {
-		diagnostics.push(issue("warning", "GEOMETRY_RECONSTRUCTION_FAILED", "Tessellated geometry yielded no triangles", productExpressId));
+		diagnostics.push(issue("warning", "GEOMETRY_RECONSTRUCTION_FAILED", "Tessellated geometry yielded no triangles", itemExpressId));
 		return NONE;
 	}
-	const solid = sewMeshToSolid(mesh, 1e3, productExpressId, diagnostics);
+	const stl = packBinaryStl(mesh.vertices, mesh.indices, scaleToMm);
+	let solid = sewMeshToSolid(mesh, scaleToMm, itemExpressId, diagnostics);
+	try {
+		if (solid === null) {
+			const cast = castFreshResult(getKernel().importSTL(new Uint8Array(stl).buffer));
+			if (isSolid(cast)) {
+				const valid = validSolid(cast);
+				if (valid.ok) solid = valid.value;
+				else cast[Symbol.dispose]();
+			} else {
+				const solids = getSolids(cast);
+				if (solids.length === 1 && solids[0] !== void 0) {
+					const copied = clone(solids[0]);
+					if (copied.ok) {
+						const valid = validSolid(copied.value);
+						if (valid.ok) solid = valid.value;
+						else copied.value[Symbol.dispose]();
+					}
+				}
+				cast[Symbol.dispose]();
+			}
+		}
+	} catch (e) {
+		diagnostics.push(issue("info", "TESSELLATION_NOT_MANIFOLD", `STL round-trip failed: ${errMsg$1(e)}`, itemExpressId));
+	}
 	if (solid !== null) {
-		diagnostics.push(issue("info", "TESSELLATED_MANIFOLD", "Tessellated mesh recovered as a closed solid by sewing its triangles", productExpressId));
+		try {
+			testHooks$1?.afterItemSolid?.(itemExpressId, solid);
+		} catch (cause) {
+			solid[Symbol.dispose]();
+			throw cause;
+		}
+		diagnostics.push(issue("info", "TESSELLATED_MANIFOLD", "Tessellated mesh recovered as a closed solid", itemExpressId));
 		return {
 			kind: "SOLID",
 			solid,
 			lossy: true
 		};
 	}
-	diagnostics.push(issue("info", "TESSELLATION_NOT_MANIFOLD", "Tessellated mesh is not closed/manifold; returning raw triangle data (lossy)", productExpressId));
+	diagnostics.push(issue("info", "TESSELLATION_NOT_MANIFOLD", "Tessellated mesh is not closed/manifold; returning raw triangle data (lossy)", itemExpressId));
 	return {
 		kind: "MESH",
 		vertices: mesh.vertices,
@@ -14250,12 +14329,11 @@ function reconstructTessellated(reader, productExpressId, diagnostics) {
 		diagnostic: "TESSELLATED_LOSSY"
 	};
 }
-/** Loose enough to weld float32 vertices web-ifc emits per face, in mm. */
+/** Loose enough to weld float32 vertices emitted per face, expressed in millimetres. */
 var MESH_SEW_TOLERANCE_MM = .001;
 /**
 * Brands a fresh kernel result and releases its pre-downcast arena slot when
-* the cast moved to a new one (occt-wasm); in-place kernels share the slot and
-* are left alone. Mirrors brepjs's internal castResultShape.
+* the cast moved to a new one. In-place kernels share the slot.
 */
 function castFreshResult(raw) {
 	const cast = castShape(raw);
@@ -14264,12 +14342,7 @@ function castFreshResult(raw) {
 	if (!(rawId !== void 0 && castId !== void 0 ? rawId === castId : cast.wrapped === raw)) getKernel().dispose(raw);
 	return cast;
 }
-/**
-* Sews the streamed triangles into a closed solid through the kernel's mesh
-* builder, the same path brepjs's mesh importers use. Null when the mesh is
-* open or the kernel rejects it.
-*/
-function sewMeshToSolid(mesh, scaleToMm, productExpressId, diagnostics) {
+function sewMeshToSolid(mesh, scaleToMm, itemExpressId, diagnostics) {
 	const kernel = getKernel();
 	const { vertices, indices } = mesh;
 	const point = (index) => [
@@ -14278,8 +14351,8 @@ function sewMeshToSolid(mesh, scaleToMm, productExpressId, diagnostics) {
 		(vertices[index * 3 + 2] ?? 0) * scaleToMm
 	];
 	const triangles = [];
-	for (let t = 0; t + 2 < indices.length; t += 3) {
-		const face = kernel.buildTriFace(point(indices[t] ?? 0), point(indices[t + 1] ?? 0), point(indices[t + 2] ?? 0));
+	for (let index = 0; index + 2 < indices.length; index += 3) {
+		const face = kernel.buildTriFace(point(indices[index] ?? 0), point(indices[index + 1] ?? 0), point(indices[index + 2] ?? 0));
 		if (face !== null) triangles.push(face);
 	}
 	if (triangles.length === 0) return null;
@@ -14289,38 +14362,45 @@ function sewMeshToSolid(mesh, scaleToMm, productExpressId, diagnostics) {
 		if (valid !== null && valid.ok) return valid.value;
 		cast[Symbol.dispose]();
 		return null;
-	} catch (e) {
-		diagnostics.push(issue("info", "TESSELLATION_NOT_MANIFOLD", `Mesh sewing failed: ${errMsg$1(e)}`, productExpressId));
+	} catch (cause) {
+		diagnostics.push(issue("info", "TESSELLATION_NOT_MANIFOLD", `Mesh sewing failed: ${errMsg$1(cause)}`, itemExpressId));
 		return null;
 	} finally {
 		for (const face of triangles) kernel.dispose(face);
 	}
 }
-function collectMesh(reader, productExpressId) {
-	const vertices = [];
-	const indices = [];
-	let base = 0;
+/** Streams a product once, then separates web-ifc geometry by Body item express ID. */
+function collectItemMeshes(reader, productExpressId, itemExpressIds) {
+	const byItem = /* @__PURE__ */ new Map();
+	const soleItemExpressId = itemExpressIds.size === 1 ? [...itemExpressIds][0] : void 0;
 	reader.streamMeshes([productExpressId], (flatMesh) => {
 		try {
 			const geometries = flatMesh.geometries;
-			for (let g = 0; g < geometries.size(); g++) {
-				const placed = geometries.get(g);
-				const geom = reader.getGeometry(placed.geometryExpressID);
+			for (let geometryIndex = 0; geometryIndex < geometries.size(); geometryIndex++) {
+				const placed = geometries.get(geometryIndex);
+				const itemExpressId = itemExpressIds.has(placed.geometryExpressID) ? placed.geometryExpressID : soleItemExpressId;
+				if (itemExpressId === void 0) continue;
+				const accumulator = byItem.get(itemExpressId) ?? {
+					vertices: [],
+					indices: []
+				};
+				byItem.set(itemExpressId, accumulator);
+				const geometry = reader.getGeometry(placed.geometryExpressID);
 				try {
-					const verts = reader.getVertexArray(geom.GetVertexData(), geom.GetVertexDataSize());
-					const idx = reader.getIndexArray(geom.GetIndexData(), geom.GetIndexDataSize());
-					const m = placed.flatTransformation;
-					const vertexCount = verts.length / 6;
-					for (let v = 0; v < vertexCount; v++) {
-						const x = verts[v * 6] ?? 0;
-						const y = verts[v * 6 + 1] ?? 0;
-						const z = verts[v * 6 + 2] ?? 0;
-						vertices.push((m[0] ?? 1) * x + (m[4] ?? 0) * y + (m[8] ?? 0) * z + (m[12] ?? 0), (m[1] ?? 0) * x + (m[5] ?? 1) * y + (m[9] ?? 0) * z + (m[13] ?? 0), (m[2] ?? 0) * x + (m[6] ?? 0) * y + (m[10] ?? 1) * z + (m[14] ?? 0));
+					const vertices = reader.getVertexArray(geometry.GetVertexData(), geometry.GetVertexDataSize());
+					const indices = reader.getIndexArray(geometry.GetIndexData(), geometry.GetIndexDataSize());
+					const transform = placed.flatTransformation;
+					const base = accumulator.vertices.length / 3;
+					const vertexCount = vertices.length / 6;
+					for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+						const x = vertices[vertexIndex * 6] ?? 0;
+						const y = vertices[vertexIndex * 6 + 1] ?? 0;
+						const z = vertices[vertexIndex * 6 + 2] ?? 0;
+						accumulator.vertices.push((transform[0] ?? 1) * x + (transform[4] ?? 0) * y + (transform[8] ?? 0) * z + (transform[12] ?? 0), (transform[1] ?? 0) * x + (transform[5] ?? 1) * y + (transform[9] ?? 0) * z + (transform[13] ?? 0), (transform[2] ?? 0) * x + (transform[6] ?? 0) * y + (transform[10] ?? 1) * z + (transform[14] ?? 0));
 					}
-					for (let i = 0; i < idx.length; i++) indices.push(base + (idx[i] ?? 0));
-					base += vertexCount;
+					for (let index = 0; index < indices.length; index++) accumulator.indices.push(base + (indices[index] ?? 0));
 				} finally {
-					geom.delete();
+					geometry.delete();
 				}
 			}
 		} finally {
@@ -14328,12 +14408,62 @@ function collectMesh(reader, productExpressId) {
 			releaseEmbind(flatMesh);
 		}
 	});
-	if (vertices.length === 0) return null;
+	return new Map([...byItem].map(([itemExpressId, mesh]) => [itemExpressId, {
+		vertices: new Float32Array(mesh.vertices),
+		indices: new Uint32Array(mesh.indices)
+	}]));
+}
+function readTriangulatedMesh(rawPoints, rawTriangles, scale, worldTransform) {
+	if (!Array.isArray(rawPoints) || !Array.isArray(rawTriangles)) return null;
+	const vertices = [];
+	const indices = [];
+	const lengthFactor = scale * 1e3;
+	for (const rawPoint of rawPoints) {
+		if (!Array.isArray(rawPoint) || rawPoint.length < 3) return null;
+		const placed = transformPoint([
+			(readMeasure(rawPoint[0]) ?? 0) * lengthFactor,
+			(readMeasure(rawPoint[1]) ?? 0) * lengthFactor,
+			(readMeasure(rawPoint[2]) ?? 0) * lengthFactor
+		], worldTransform);
+		vertices.push(placed[0], placed[1], placed[2]);
+	}
+	for (const rawTriangle of rawTriangles) {
+		if (!Array.isArray(rawTriangle) || rawTriangle.length < 3) return null;
+		indices.push((readMeasure(rawTriangle[0]) ?? 1) - 1, (readMeasure(rawTriangle[1]) ?? 1) - 1, (readMeasure(rawTriangle[2]) ?? 1) - 1);
+	}
 	return {
 		vertices: new Float32Array(vertices),
 		indices: new Uint32Array(indices)
 	};
 }
+function transformPoint(point, transform) {
+	if (transform === null) return point;
+	const m = transform.linear;
+	return [
+		(m[0] ?? 1) * point[0] + (m[1] ?? 0) * point[1] + (m[2] ?? 0) * point[2] + transform.translation[0],
+		(m[3] ?? 0) * point[0] + (m[4] ?? 1) * point[1] + (m[5] ?? 0) * point[2] + transform.translation[1],
+		(m[6] ?? 0) * point[0] + (m[7] ?? 0) * point[1] + (m[8] ?? 1) * point[2] + transform.translation[2]
+	];
+}
+function packBinaryStl(vertices, indices, scaleToMm) {
+	const triCount = Math.floor(indices.length / 3);
+	const buffer = /* @__PURE__ */ new ArrayBuffer(84 + triCount * 50);
+	const view = new DataView(buffer);
+	view.setUint32(80, triCount, true);
+	let offset = 84;
+	for (let t = 0; t < triCount; t++) {
+		offset += 12;
+		for (let c = 0; c < 3; c++) {
+			const vi = (indices[t * 3 + c] ?? 0) * 3;
+			view.setFloat32(offset, (vertices[vi] ?? 0) * scaleToMm, true);
+			view.setFloat32(offset + 4, (vertices[vi + 1] ?? 0) * scaleToMm, true);
+			view.setFloat32(offset + 8, (vertices[vi + 2] ?? 0) * scaleToMm, true);
+			offset += 12;
+		}
+		offset += 2;
+	}
+	return new Uint8Array(buffer);
+}
 var PARAMETRIC_PROFILE_BUILDERS = /* @__PURE__ */ new Map([
 	[WebIFC.IFCRECTANGLEPROFILEDEF, (f) => ({
 		kind: "RECTANGULAR",
@@ -14686,15 +14816,16 @@ function isIdentity(t) {
 	for (let i = 0; i < 9; i++) if (Math.abs((t.linear[i] ?? 0) - (expected[i] ?? 0)) > 1e-9) return false;
 	return Math.abs(t.translation[0]) < 1e-9 && Math.abs(t.translation[1]) < 1e-9 && Math.abs(t.translation[2]) < 1e-9;
 }
-function findBodyItem(reader, representations) {
+function findBodyItems(reader, representations) {
 	for (const repRef of representations) {
 		const rep = reader.getLine(repRef.value);
 		if (rep === null) continue;
 		if (readLabel(rep["RepresentationIdentifier"]) !== "Body") continue;
 		const items = asRefArray(rep["Items"]);
-		if (items === void 0 || items.length === 0) continue;
-		return items[0]?.value;
+		if (items === void 0) return [];
+		return items.map((item) => item.value);
 	}
+	return null;
 }
 function readPolylinePoints(reader, ref, scale) {
 	const curveRef = asRef(ref);
@@ -14799,8 +14930,8 @@ function readLabel(value) {
 		if (typeof v === "string") return v;
 	}
 }
-function isTessellatedType(type) {
-	return type === WebIFC.IFCTRIANGULATEDFACESET || type === WebIFC.IFCPOLYGONALFACESET || type === WebIFC.IFCFACEBASEDSURFACEMODEL;
+function isStreamedTessellatedType(type) {
+	return type === WebIFC.IFCPOLYGONALFACESET || type === WebIFC.IFCFACEBASEDSURFACEMODEL;
 }
 function normalize(v) {
 	const len = Math.hypot(v[0], v[1], v[2]);
@@ -15139,6 +15270,7 @@ function readOwnerHistory(reader, ownerHistoryExpressId) {
 }
 //#endregion
 //#region src/import/fromIfc.ts
+var testHooks = null;
 /**
 * Each enumerated physical-element IFC type and the {@link ImportedElementCategory}
 * it maps to. Curtain-wall sub-components (IfcPlate/IfcMember) and stair/ramp
@@ -15187,6 +15319,7 @@ async function fromIfc(bytes, options = {}) {
 	const readerResult = await SpfReader.create(bytes, settings);
 	if (!readerResult.ok) return err(readerResult.error);
 	const reader = readerResult.value;
+	const elements = [];
 	try {
 		reader.buildGuidMap();
 		const diagnostics = [];
@@ -15195,13 +15328,13 @@ async function fromIfc(bytes, options = {}) {
 		const spatialRoot = buildSpatialTree(reader, scale);
 		const containment = buildElementContainmentMap(reader);
 		const typeEnums = buildTypePredefinedMap(reader);
-		const elements = [];
 		const byExpressId = /* @__PURE__ */ new Map();
 		for (const [type, category] of ELEMENT_TYPES) for (const expressId of reader.getLinesOfType(type)) {
 			const element = readElement(reader, expressId, category, scale, containment, typeEnums, options.skipGeometry ?? false, diagnostics);
 			if (element === null) continue;
 			elements.push(element);
 			byExpressId.set(element.expressId, element);
+			testHooks?.afterElement?.(element, elements.length);
 		}
 		const report = appendIssues(emptyReport(), diagnostics);
 		const applicationName = readApplicationName(reader);
@@ -15215,6 +15348,7 @@ async function fromIfc(bytes, options = {}) {
 		};
 		return ok(model);
 	} catch (e) {
+		disposeElements(elements);
 		return err(importError("IMPORT_FAILED", "Unexpected failure during IFC import", e));
 	} finally {
 		reader.close();
@@ -15226,6 +15360,7 @@ async function fromIfc(bytes, options = {}) {
 * sub-read failure is isolated by its own reader and never aborts the element.
 */
 function readElement(reader, expressId, category, scale, containment, typeEnums, skipGeometry, diagnostics) {
+	let geometry = null;
 	try {
 		const line = reader.getLine(expressId);
 		if (line === null) {
@@ -15237,10 +15372,15 @@ function readElement(reader, expressId, category, scale, containment, typeEnums,
 		const predefinedType = readPredefinedType(line) ?? typeEnums.get(expressId);
 		const voidedBy = readVoids(reader, expressId).map((v) => v.openingExpressId);
 		const fills = findFills(reader, expressId);
-		const geometry = skipGeometry ? {
+		geometry = skipGeometry ? {
 			fidelity: "NONE",
-			solid: null
+			completeness: "NONE",
+			solids: [],
+			solid: null,
+			bounds: null,
+			volumeMm3: null
 		} : reconstructGeometry(reader, expressId, scale, voidedBy, diagnostics);
+		testHooks?.afterGeometry?.(expressId, geometry);
 		const psets = readPsets(reader, expressId).map(toImportedPset);
 		const material = readMaterial(reader, expressId, scale);
 		const classification = readClassification(reader, expressId);
@@ -15263,6 +15403,7 @@ 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));
 		return null;
 	}
@@ -15284,42 +15425,134 @@ function findFills(reader, elementExpressId) {
 * model. Falls back to the uncut solid (with a diagnostic) if a cut fails.
 */
 function reconstructGeometry(reader, expressId, scale, voidedBy, diagnostics) {
-	const base = toImportedGeometry(readBodyGeometry(reader, expressId, scale, diagnostics));
-	if (base.fidelity !== "PARAMETRIC" || base.solid === null || voidedBy.length === 0) return base;
-	let host = base.solid;
+	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;
-		const cutResult = cut(host, opening.solid);
-		opening.solid[Symbol.dispose]();
-		if (!cutResult.ok) {
-			diagnostics.push(issue("warning", "VOID_SUBTRACTION_FAILED", `Opening ${openingId} could not be subtracted from element ${expressId}: ${cutResult.error.message}`, expressId));
-			continue;
-		}
-		host[Symbol.dispose]();
-		host = cutResult.value;
-	}
+		try {
+			for (let hostIndex = 0; hostIndex < hosts.length; hostIndex++) {
+				const host = hosts[hostIndex];
+				if (host === void 0) continue;
+				const cutResult = cut(host, opening.solid);
+				if (!cutResult.ok) {
+					diagnostics.push(issue("warning", "VOID_SUBTRACTION_FAILED", `Opening ${openingId} could not be subtracted from element ${expressId}: ${cutResult.error.message}`, expressId));
+					continue;
+				}
+				host[Symbol.dispose]();
+				hosts[hostIndex] = cutResult.value;
+			}
+		} finally {
+			opening.solid[Symbol.dispose]();
+		}
+	}
+	return completeImportedGeometry("PARAMETRIC", hosts, expressId, diagnostics);
+}
+function toImportedGeometry(reader, expressId, scale, diagnostics) {
+	const body = readBodyItems(reader, expressId, scale, diagnostics);
+	const solids = [];
+	let hasTessellatedSolid = false;
+	let lossyMesh = null;
+	for (const item of body.items) if (item.kind === "SOLID") {
+		solids.push(item.solid);
+		hasTessellatedSolid ||= item.lossy;
+	} else if (item.kind === "MESH") {
+		const meshAccumulator = lossyMesh ?? {
+			vertices: [],
+			indices: []
+		};
+		lossyMesh = meshAccumulator;
+		const vertexOffset = meshAccumulator.vertices.length / 3;
+		for (const vertex of item.vertices) meshAccumulator.vertices.push(vertex);
+		for (const index of item.indices) meshAccumulator.indices.push(vertexOffset + index);
+	}
+	const completeness = body.hasBody && body.itemCount > 0 && solids.length === body.itemCount ? "COMPLETE" : solids.length > 0 ? "PARTIAL" : "NONE";
+	if (completeness === "PARTIAL") diagnostics.push(issue("warning", "PARTIAL_BODY_RECONSTRUCTION", `Reconstructed ${solids.length} of ${body.itemCount} Body items`, expressId, {
+		reconstructedItems: solids.length,
+		bodyItems: body.itemCount
+	}));
+	else if (completeness === "NONE" && body.hasBody) diagnostics.push(issue("warning", "BODY_RECONSTRUCTION_NONE", `The Product has ${body.itemCount} Body item(s), but none reconstructed as solids`, expressId, { bodyItems: body.itemCount }));
+	const fidelity = lossyMesh !== null ? "TESSELLATED_LOSSY" : hasTessellatedSolid ? "TESSELLATED_MANIFOLD" : solids.length > 0 ? "PARAMETRIC" : "NONE";
+	const aggregate = completeness === "COMPLETE" ? measureCompleteBody(solids, expressId, diagnostics) : {
+		bounds: null,
+		volumeMm3: null
+	};
 	return {
-		fidelity: "PARAMETRIC",
-		solid: host
+		fidelity,
+		completeness,
+		solids,
+		solid: completeness === "COMPLETE" && solids.length === 1 ? solids[0] ?? null : null,
+		...aggregate,
+		...lossyMesh !== null ? {
+			meshVertices: new Float32Array(lossyMesh.vertices),
+			meshIndices: new Uint32Array(lossyMesh.indices)
+		} : {}
 	};
 }
-function toImportedGeometry(result) {
-	if (result.kind === "SOLID") return {
-		fidelity: result.lossy ? "TESSELLATED_MANIFOLD" : "PARAMETRIC",
-		solid: result.solid
-	};
-	if (result.kind === "MESH") return {
-		fidelity: "TESSELLATED_LOSSY",
-		solid: null,
-		meshVertices: result.vertices,
-		meshIndices: result.indices
-	};
+function completeImportedGeometry(fidelity, solids, expressId, diagnostics) {
 	return {
-		fidelity: "NONE",
-		solid: null
+		fidelity,
+		completeness: "COMPLETE",
+		solids,
+		solid: solids.length === 1 ? solids[0] : null,
+		...measureCompleteBody(solids, expressId, diagnostics)
 	};
 }
+function measureCompleteBody(solids, expressId, diagnostics) {
+	try {
+		const first = solids[0];
+		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);
+		}
+		return {
+			bounds: {
+				xMin,
+				xMax,
+				yMin,
+				yMax,
+				zMin,
+				zMax
+			},
+			volumeMm3
+		};
+	} catch (cause) {
+		diagnostics.push(issue("warning", "BODY_AGGREGATE_MEASUREMENT_FAILED", `Complete Body aggregate measurement failed: ${errMsg(cause)}`, expressId));
+		return {
+			bounds: null,
+			volumeMm3: null
+		};
+	}
+}
+function disposeGeometry(geometry) {
+	for (const solid of geometry.solids) solid[Symbol.dispose]();
+}
+function disposeElements(elements) {
+	for (const element of elements) disposeGeometry(element.geometry);
+}
 function toImportedPset(pset) {
 	return {
 		name: pset.name,
@@ -15397,7 +15630,7 @@ function errMsg(e) {
 * with the model (it is not reclaimed automatically when the model is GC'd).
 */
 function disposeImportedModel(model) {
-	for (const el of model.elements) el.geometry.solid?.[Symbol.dispose]();
+	for (const el of model.elements) for (const solid of el.geometry.solids) solid[Symbol.dispose]();
 }
 //#endregion
 //#region src/specs/materialSpec.ts

package/dist/import/fromIfc.d.ts

@@ -1,6 +1,6 @@
 import { Result } from 'brepjs';
 import { BimError } from '../errors/bimError.js';
-import { ImportedModel } from './importedModel.js';
+import { ImportedModel, ImportedElement, ImportedGeometry } from './importedModel.js';
 export type { ImportedModel } from './importedModel.js';
 export interface FromIfcOptions {
     /** Activate web-ifc's large-coordinate recentering on open. Default false. */
@@ -8,6 +8,12 @@ export interface FromIfcOptions {
     /** Skip body-geometry reconstruction for fast metadata-only reads. Default false. */
     readonly skipGeometry?: boolean | undefined;
 }
+export interface FromIfcTestHooks {
+    readonly afterGeometry?: ((expressId: number, geometry: ImportedGeometry) => void) | undefined;
+    readonly afterElement?: ((element: ImportedElement, accumulatedCount: number) => void) | undefined;
+}
+/** Package-internal deterministic failure seam for import ownership tests. */
+export declare function setFromIfcTestHooksForTesting(hooks: FromIfcTestHooks | null): void;
 /**
  * Reads an IFC STEP-SPF byte buffer into an {@link ImportedModel}: schema, unit
  * scale, spatial tree, and one {@link ImportedElement} per physical product

package/dist/import/geometryRead.d.ts

@@ -7,7 +7,7 @@ import { SpfReader } from './spfReader.js';
  * Outcome of reconstructing a single product's body geometry.
  *
  * - `SOLID` — a brepjs ValidSolid was rebuilt (parametrically from a swept
- *   solid, or by a manifold STL round-trip of a tessellated mesh).
+ *   solid, or by sewing a manifold tessellated mesh).
  * - `MESH` — geometry exists but could not be turned into a closed solid;
  *   raw triangle data is returned and flagged lossy via `diagnostic`.
  * - `NONE` — the product carries no recognised body representation.
@@ -24,6 +24,16 @@ export type GeometryResult = {
 } | {
     readonly kind: 'NONE';
 };
+export interface BodyGeometryItems {
+    readonly hasBody: boolean;
+    readonly itemCount: number;
+    readonly items: readonly GeometryResult[];
+}
+export interface GeometryReadTestHooks {
+    readonly afterItemSolid?: ((itemExpressId: number, solid: ValidSolid) => void) | undefined;
+}
+/** Package-internal deterministic failure seam for import ownership tests. */
+export declare function setGeometryReadTestHooksForTesting(hooks: GeometryReadTestHooks | null): void;
 /**
  * Reconstructs the `Body` (SweptSolid) representation of a product into a brepjs
  * solid, falling back to tessellated mesh import when no parametric path exists.
@@ -34,6 +44,8 @@ export type GeometryResult = {
  * single bad element never aborts a model import.
  */
 export declare function readBodyGeometry(reader: SpfReader, productExpressId: number, scale: number, diagnostics: ValidationIssue[]): GeometryResult;
+/** Reconstructs each supported IFC Body item independently in representation order. */
+export declare function readBodyItems(reader: SpfReader, productExpressId: number, scale: number, diagnostics: ValidationIssue[]): BodyGeometryItems;
 /**
  * Reads an IfcProfileDef into a brepjs Profile (mm). Mirrors the writer's
  * profile-def emission (geometryWriter.writeProfile / profileDefWriter).