brepjs-bim 0.23.0 → 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
@@ -183,7 +183,7 @@ function fromBrepError(inner, code, message) {
 	};
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.143.0/helpers/esm/usingCtx.js
+//#region \0@oxc-project+runtime@0.146.0/helpers/esm/usingCtx.js
 function _usingCtx() {
 	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
 		var n = Error();
@@ -8756,7 +8756,7 @@ function writeWallGeometry(w, spec, geomSubContextId, parentPlacementId) {
 			value: "AREA"
 		},
 		ProfileName: null,
-		Position: w.ref(writeAxis2Placement2D$1(w)),
+		Position: w.ref(writeAxis2Placement2D$1(w, [thicknessM / 2, heightM / 2])),
 		XDim: w.mkType(WebIFC.IFCPOSITIVELENGTHMEASURE, thicknessM),
 		YDim: w.mkType(WebIFC.IFCPOSITIVELENGTHMEASURE, heightM)
 	});
@@ -8977,12 +8977,12 @@ function writeRoofGeometry(w, spec, solid, geomSubContextId, parentPlacementId)
 		usedFallback: false
 	};
 }
-function writeAxis2Placement2D$1(w) {
+function writeAxis2Placement2D$1(w, location = [0, 0]) {
 	const originId = w.nextId();
 	w.writeLine({
 		expressID: originId,
 		type: WebIFC.IFCCARTESIANPOINT,
-		Coordinates: [w.mkType(WebIFC.IFCLENGTHMEASURE, 0), w.mkType(WebIFC.IFCLENGTHMEASURE, 0)]
+		Coordinates: [w.mkType(WebIFC.IFCLENGTHMEASURE, location[0]), w.mkType(WebIFC.IFCLENGTHMEASURE, location[1])]
 	});
 	const id = w.nextId();
 	w.writeLine({
@@ -11487,11 +11487,10 @@ function writeOpeningGeometry(w, guid, openingSpec, wallSpec, wallPlacementId, g
 	const offsetAlongWallM = toIfcLengthM(openingSpec.offsetAlongWall);
 	const offsetFromFloorM = toIfcLengthM(openingSpec.offsetFromFloor);
 	const thicknessM = toIfcLengthM(wallSpec.thickness);
-	const wallHeightM = toIfcLengthM(wallSpec.height);
 	const placement3DId = writeAxis2Placement3D(w, [
 		offsetAlongWallM + widthM / 2,
-		thicknessM / 2,
-		-wallHeightM / 2 + offsetFromFloorM + heightM / 2
+		thicknessM,
+		offsetFromFloorM + heightM / 2
 	], [
 		0,
 		-1,
@@ -12367,6 +12366,24 @@ var SUPPORTED_SCHEMAS = [
 * MUST call {@link SpfReader.close} (it always issues `CloseModel`, preventing
 * WASM handle leaks). The handle is `using`-friendly via `Symbol.dispose`.
 */
+var IFC_Z_UP_TRANSFORMATION = [
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	-1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1
+];
 function deleteVector(vec) {
 	vec.delete?.();
 }
@@ -12399,6 +12416,7 @@ var SpfReader = class SpfReader {
 			if (modelId >= 0) api.CloseModel(modelId);
 			return err(importError("OPEN_MODEL_FAILED", "web-ifc OpenModel returned an invalid model id"));
 		}
+		api.SetGeometryTransformation(modelId, IFC_Z_UP_TRANSFORMATION);
 		const schemaRaw = api.GetModelSchema(modelId);
 		if (!SUPPORTED_SCHEMAS.includes(schemaRaw)) {
 			api.CloseModel(modelId);
@@ -14047,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.
@@ -14057,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);
@@ -14098,12 +14156,14 @@ function reconstructExtrusion(reader, extrusionId, scale, worldTransform, diagno
 		diagnostics.push(issue("warning", faceResult.error.code, faceResult.error.message, extrusionId));
 		return NONE;
 	}
+	const profileFrame = readProfilePosition(reader, sweptArea.value, scale);
 	const depthMm = depth * scale * 1e3;
-	const extrudeDir = readDirection(reader, ext["ExtrudedDirection"]) ?? [
+	const sweptDir = readDirection(reader, ext["ExtrudedDirection"]) ?? [
 		0,
 		0,
 		1
 	];
+	const extrudeDir = profileFrame === null ? sweptDir : rotateByTranspose(profileFrame.linear, sweptDir);
 	const extrudeVec = [
 		extrudeDir[0] * depthMm,
 		extrudeDir[1] * depthMm,
@@ -14125,7 +14185,11 @@ function reconstructExtrusion(reader, extrusionId, scale, worldTransform, diagno
 		return NONE;
 	}
 	const localFrame = readAxis2Placement3D(reader, ext["Position"], scale);
-	const placed = placeSolid(solidResult.value, localFrame, worldTransform);
+	const placed = placeSolid(solidResult.value, [
+		worldTransform,
+		localFrame,
+		profileFrame
+	]);
 	if (!placed.ok) {
 		diagnostics.push(issue("warning", placed.error.code, placed.error.message, extrusionId));
 		return NONE;
@@ -14153,16 +14217,19 @@ function reconstructRevolution(reader, revolutionId, scale, worldTransform, diag
 		return NONE;
 	}
 	const axis1 = reader.getLine(axisRef.value);
-	const center = (axis1 === null ? void 0 : readPoint(reader, axis1["Location"], scale)) ?? [
+	const sweptCenter = (axis1 === null ? void 0 : readPoint(reader, axis1["Location"], scale)) ?? [
 		0,
 		0,
 		0
 	];
-	const direction = (axis1 === null ? void 0 : readDirection(reader, axis1["Axis"])) ?? [
+	const sweptDirection = (axis1 === null ? void 0 : readDirection(reader, axis1["Axis"])) ?? [
 		0,
 		0,
 		1
 	];
+	const profileFrame = readProfilePosition(reader, sweptArea.value, scale);
+	const center = profileFrame === null ? sweptCenter : inverseRigidPoint(profileFrame, sweptCenter);
+	const direction = profileFrame === null ? sweptDirection : rotateByTranspose(profileFrame.linear, sweptDirection);
 	const revolved = (() => {
 		try {
 			var _usingCtx3 = _usingCtx();
@@ -14189,40 +14256,72 @@ function reconstructRevolution(reader, revolutionId, scale, worldTransform, diag
 		return NONE;
 	}
 	const localFrame = readAxis2Placement3D(reader, rev["Position"], scale);
-	const placed = placeSolid(revolved.value, localFrame, worldTransform);
+	const placed = placeSolid(revolved.value, [
+		worldTransform,
+		localFrame,
+		profileFrame
+	]);
 	if (!placed.ok) {
 		diagnostics.push(issue("warning", placed.error.code, placed.error.message, revolutionId));
 		return NONE;
 	}
 	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 stl = packBinaryStl(mesh.vertices, mesh.indices, 1e3);
-	let solid = null;
+	const stl = packBinaryStl(mesh.vertices, mesh.indices, scaleToMm);
+	let solid = sewMeshToSolid(mesh, scaleToMm, itemExpressId, diagnostics);
 	try {
-		const cast = castShape(getKernel().importSTL(stl.buffer));
-		if (isSolid(cast)) {
-			const valid = validSolid(cast);
-			if (valid.ok) solid = valid.value;
-			else cast[Symbol.dispose]();
-		} else cast[Symbol.dispose]();
+		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)}`, productExpressId));
+		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 via STL round-trip", 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,
@@ -14230,43 +14329,122 @@ function reconstructTessellated(reader, productExpressId, diagnostics) {
 		diagnostic: "TESSELLATED_LOSSY"
 	};
 }
-function collectMesh(reader, productExpressId) {
-	const vertices = [];
-	const indices = [];
-	let base = 0;
+/** 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. In-place kernels share the slot.
+*/
+function castFreshResult(raw) {
+	const cast = castShape(raw);
+	const rawId = raw.id;
+	const castId = cast.wrapped.id;
+	if (!(rawId !== void 0 && castId !== void 0 ? rawId === castId : cast.wrapped === raw)) getKernel().dispose(raw);
+	return cast;
+}
+function sewMeshToSolid(mesh, scaleToMm, itemExpressId, diagnostics) {
+	const kernel = getKernel();
+	const { vertices, indices } = mesh;
+	const point = (index) => [
+		(vertices[index * 3] ?? 0) * scaleToMm,
+		(vertices[index * 3 + 1] ?? 0) * scaleToMm,
+		(vertices[index * 3 + 2] ?? 0) * scaleToMm
+	];
+	const triangles = [];
+	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;
+	try {
+		const cast = castFreshResult(kernel.sewAndSolidify(triangles, MESH_SEW_TOLERANCE_MM));
+		const valid = isSolid(cast) ? validSolid(cast) : null;
+		if (valid !== null && valid.ok) return valid.value;
+		cast[Symbol.dispose]();
+		return null;
+	} 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);
+	}
+}
+/** 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 {
-			flatMesh.delete();
+			releaseEmbind(flatMesh.geometries);
+			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);
@@ -14429,19 +14607,99 @@ function profileToFace(profile) {
 	if (!face.ok) return err(importError("GEOMETRY_RECONSTRUCTION_FAILED", `Profile face build failed: ${face.error.message}`));
 	return ok(face.value);
 }
-function placeSolid(solid, localFrame, worldTransform) {
-	let current = solid;
-	for (const transform of [localFrame, worldTransform]) {
-		if (transform === null || isIdentity(transform)) continue;
-		const applied = applyMatrix(current, transform);
-		if (!applied.ok) {
-			current[Symbol.dispose]();
-			return err(importError("PLACEMENT_READ_FAILED", `Placement transform failed: ${applied.error.message}`));
-		}
-		current[Symbol.dispose]();
-		current = applied.value;
-	}
-	return ok(current);
+/**
+* IfcParameterizedProfileDef.Position places the profile inside the swept
+* solid's XY plane; the writers rely on it to corner-anchor centred rectangle
+* profiles. Absent on arbitrary (polyline) profiles.
+*/
+function readProfilePosition(reader, profileExpressId, scale) {
+	const def = reader.getLine(profileExpressId);
+	const positionRef = def === null ? void 0 : asRef(def["Position"]);
+	if (positionRef === void 0) return null;
+	const position = reader.getLine(positionRef.value);
+	if (position === null) return null;
+	const [x, y] = readPoint2D(reader, position["Location"], scale) ?? [0, 0];
+	const [dx, dy] = readDirection2D(reader, position["RefDirection"]) ?? [1, 0];
+	const len = Math.hypot(dx, dy);
+	const c = len < 1e-12 ? 1 : dx / len;
+	const s = len < 1e-12 ? 0 : dy / len;
+	return {
+		linear: [
+			c,
+			-s,
+			0,
+			s,
+			c,
+			0,
+			0,
+			0,
+			1
+		],
+		translation: [
+			x,
+			y,
+			0
+		]
+	};
+}
+/**
+* Applies the placement chain (outermost first) as one composed rigid motion.
+* A second applyMatrix on an already-transformed solid can fail BRepCheck on
+* occt-wasm, so the frames are never applied one after another.
+*/
+function placeSolid(solid, frames) {
+	let composed = null;
+	for (const frame of frames) {
+		if (frame === null) continue;
+		composed = composed === null ? frame : composeRigid(composed, frame);
+	}
+	if (composed === null || isIdentity(composed)) return ok(solid);
+	const applied = applyMatrix(solid, composed);
+	solid[Symbol.dispose]();
+	if (!applied.ok) return err(importError("PLACEMENT_READ_FAILED", `Placement transform failed: ${applied.error.message}`));
+	return ok(applied.value);
+}
+/** `outer ∘ inner`: the motion that applies `inner` first, then `outer`. */
+function composeRigid(outer, inner) {
+	const [a00, a01, a02, a10, a11, a12, a20, a21, a22] = outer.linear;
+	const [b00, b01, b02, b10, b11, b12, b20, b21, b22] = inner.linear;
+	const [tx, ty, tz] = inner.translation;
+	const [ux, uy, uz] = outer.translation;
+	return {
+		linear: [
+			a00 * b00 + a01 * b10 + a02 * b20,
+			a00 * b01 + a01 * b11 + a02 * b21,
+			a00 * b02 + a01 * b12 + a02 * b22,
+			a10 * b00 + a11 * b10 + a12 * b20,
+			a10 * b01 + a11 * b11 + a12 * b21,
+			a10 * b02 + a11 * b12 + a12 * b22,
+			a20 * b00 + a21 * b10 + a22 * b20,
+			a20 * b01 + a21 * b11 + a22 * b21,
+			a20 * b02 + a21 * b12 + a22 * b22
+		],
+		translation: [
+			a00 * tx + a01 * ty + a02 * tz + ux,
+			a10 * tx + a11 * ty + a12 * tz + uy,
+			a20 * tx + a21 * ty + a22 * tz + uz
+		]
+	};
+}
+/** Rᵀ·v for a rigid frame's rotation part. */
+function rotateByTranspose(linear, v) {
+	return [
+		linear[0] * v[0] + linear[3] * v[1] + linear[6] * v[2],
+		linear[1] * v[0] + linear[4] * v[1] + linear[7] * v[2],
+		linear[2] * v[0] + linear[5] * v[1] + linear[8] * v[2]
+	];
+}
+/** Maps a point from the frame's parent space into the frame: Rᵀ·(p − t). */
+function inverseRigidPoint(frame, p) {
+	const t = frame.translation;
+	return rotateByTranspose(frame.linear, [
+		p[0] - t[0],
+		p[1] - t[1],
+		p[2] - t[2]
+	]);
 }
 function finalizeSolid(solid, entity, diagnostics) {
 	if (!isSolid(solid)) {
@@ -14558,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);
@@ -14590,6 +14849,24 @@ function readPolylinePoints(reader, ref, scale) {
 	}
 	return out.length >= 3 ? out : void 0;
 }
+function readPoint2D(reader, ref, scale) {
+	const pointRef = asRef(ref);
+	if (pointRef === void 0) return void 0;
+	const pt = reader.getLine(pointRef.value);
+	if (pt === null) return void 0;
+	const coords = asMeasureArray(pt["Coordinates"]);
+	if (coords.length < 2) return void 0;
+	return [(coords[0] ?? 0) * scale * 1e3, (coords[1] ?? 0) * scale * 1e3];
+}
+function readDirection2D(reader, ref) {
+	const dirRef = asRef(ref);
+	if (dirRef === void 0) return void 0;
+	const dir = reader.getLine(dirRef.value);
+	if (dir === null) return void 0;
+	const ratios = asMeasureArray(dir["DirectionRatios"]);
+	if (ratios.length < 2) return void 0;
+	return [ratios[0] ?? 0, ratios[1] ?? 0];
+}
 function readPoint(reader, ref, scale) {
 	const pointRef = asRef(ref);
 	if (pointRef === void 0) return void 0;
@@ -14616,6 +14893,9 @@ function readDirection(reader, ref) {
 		ratios[2] ?? 0
 	];
 }
+function releaseEmbind(value) {
+	value.delete?.();
+}
 function asRef(value) {
 	if (value !== null && typeof value === "object" && "value" in value) {
 		const v = value.value;
@@ -14650,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]);
@@ -14990,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
@@ -15038,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 = [];
@@ -15046,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);
@@ -15066,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();
@@ -15077,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) {
@@ -15088,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);
@@ -15114,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;
 	}
@@ -15135,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,
@@ -15248,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
@@ -28832,13 +29214,25 @@ function specLocalShift(el) {
 		0
 	];
 }
+/** Skip the resolver occurrence wrappers already owned by `cumulativeFrame`,
+*  then recover only the Body's outer literal Datum translations. An unexpected
+*  wrapper shape returns zero rather than risking an occurrence transform twice. */
+function bodyLocalTranslation(el, occurrenceTransformDepth) {
+	let body = el.geometry;
+	for (let i = 0; i < occurrenceTransformDepth; i++) {
+		if (body.kind !== "Translate" && body.kind !== "Rotate") return ZERO_TRANSLATION;
+		body = body.target;
+	}
+	return peelTranslates(body).total;
+}
 /** World frame of an element's own body: the walk's cumulative frame (all
 *  authored transforms, ancestors + own) composed with the body's authored axes
-*  (`axisX`/`axisZ` props) and its local origin (`origin` prop + centring
-*  shift). Under no rotation this reduces to `composedOrigin` + shift. */
-function elementBodyFrame(el, cumulativeFrame) {
+*  (`axisX`/`axisZ` props) and its local origin (`origin` prop + literal Body
+*  Datum + centring shift). Under no rotation this reduces to `composedOrigin`
+*  + shift. */
+function elementBodyFrame(el, cumulativeFrame, occurrenceTransformDepth) {
 	return frameMul(frameMul(cumulativeFrame, frameFromPlacement({
-		origin: authoredSpecOrigin(el),
+		origin: addTranslation(authoredSpecOrigin(el), bodyLocalTranslation(el, occurrenceTransformDepth)),
 		axisX: authoredAxisX(el),
 		axisZ: authoredAxisZ(el)
 	})), translationFrame(specLocalShift(el)));
@@ -28857,10 +29251,10 @@ function civilNodeFrame(el, cumulativeFrame) {
 *  `axisZ` are recomputed from the element's world frame relative to its spatial
 *  container. Stair/ramp flights, which carry their own per-flight frame, are
 *  each re-placed the same way. */
-function rotatedRoutedInput(flatInput, el, cumulativeFrame, spatialFrame) {
+function rotatedRoutedInput(flatInput, el, cumulativeFrame, occurrenceTransformDepth, spatialFrame) {
 	const toSpatial = frameInverse(spatialFrame);
 	if (Array.isArray(flatInput["flights"])) {
-		const elementFrame = elementBodyFrame(el, cumulativeFrame);
+		const elementFrame = elementBodyFrame(el, cumulativeFrame, occurrenceTransformDepth);
 		const flights = flatInput["flights"];
 		return {
 			...flatInput,
@@ -28901,7 +29295,7 @@ function rotatedRoutedInput(flatInput, el, cumulativeFrame, spatialFrame) {
 			})
 		};
 	}
-	const placed = decomposeFrame(frameMul(toSpatial, elementBodyFrame(el, cumulativeFrame)));
+	const placed = decomposeFrame(frameMul(toSpatial, elementBodyFrame(el, cumulativeFrame, occurrenceTransformDepth)));
 	return {
 		...flatInput,
 		origin: placed.origin,
@@ -29066,6 +29460,7 @@ function familiesToBim(root, options) {
 	const walk = (el, state) => {
 		const rotatedHere = state.rotated || hasRotateOp(el);
 		const cumulativeTranslationHere = addTranslation(state.cumulativeTranslation, authoredTranslation(el));
+		const occurrenceTransformDepthHere = state.occurrenceTransformDepth + el.localTransforms.length;
 		const cumulativeFrameHere = frameMul(state.cumulativeFrame, frameFromOps(el.localTransforms));
 		let proxiedHere = false;
 		let nextRotated = rotatedHere;
@@ -29129,7 +29524,7 @@ function familiesToBim(root, options) {
 			}
 			const routedInput = el.semantics?.kind === "product" ? civilProductSpecInput(el) : ("input" in route ? route.input : specInput)(el);
 			const rotatedBase = Array.isArray(routedInput["flights"]) ? specInput(el) : routedInput;
-			const placedInput = rotatedHere ? rotatedRoutedInput(rotatedBase, el, cumulativeFrameHere, state.spatialFrame) : usesAuthoredCivilHierarchy ? relativeSpecInput(routedInput, state.projectedSpatialTranslation) : routedInput;
+			const placedInput = rotatedHere ? rotatedRoutedInput(rotatedBase, el, cumulativeFrameHere, occurrenceTransformDepthHere, state.spatialFrame) : usesAuthoredCivilHierarchy ? relativeSpecInput(routedInput, state.projectedSpatialTranslation) : routedInput;
 			const parsed = route.parse(placedInput);
 			if (!parsed.ok) return parsed;
 			const added = route.add(model, parsed.value, el.keyPath);
@@ -29166,6 +29561,7 @@ function familiesToBim(root, options) {
 				rotated: nextRotated,
 				cumulativeTranslation: cumulativeTranslationHere,
 				projectedSpatialTranslation: nextProjectedSpatialTranslation,
+				occurrenceTransformDepth: occurrenceTransformDepthHere,
 				cumulativeFrame: nextCumulativeFrame,
 				spatialFrame: nextSpatialFrame
 			});
@@ -29179,6 +29575,7 @@ function familiesToBim(root, options) {
 		rotated: false,
 		cumulativeTranslation: ZERO_TRANSLATION,
 		projectedSpatialTranslation: ZERO_TRANSLATION,
+		occurrenceTransformDepth: 0,
 		cumulativeFrame: IDENTITY_FRAME,
 		spatialFrame: IDENTITY_FRAME
 	});