brepjs-bim 0.22.0 → 0.23.1

package/dist/brepjs-bim.js

@@ -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();
@@ -7182,7 +7182,7 @@ function placementToMatrix(f) {
 		f.axisX[2] - dot * z[2]
 	];
 	const x = lengthSq(projX) < 1e-12 ? normalize$1(orthogonal$2(z)) : normalize$1(projX);
-	const y = cross$1(z, x);
+	const y = cross$2(z, x);
 	return {
 		linear: [
 			x[0],
@@ -7202,7 +7202,27 @@ function placementToMatrix(f) {
 		]
 	};
 }
-function cross$1(a, b) {
+/** Decomposes a column-major matrix into origin (mm) + IFC axes (Z, X). */
+function decomposePlacement(m) {
+	return {
+		axisX: normalize$1([
+			m[0],
+			m[1],
+			m[2]
+		]),
+		axisZ: normalize$1([
+			m[8],
+			m[9],
+			m[10]
+		]),
+		origin: [
+			m[12],
+			m[13],
+			m[14]
+		]
+	};
+}
+function cross$2(a, b) {
 	return [
 		a[1] * b[2] - a[2] * b[1],
 		a[2] * b[0] - a[0] * b[2],
@@ -7226,11 +7246,11 @@ function normalize$1(v) {
 	];
 }
 function orthogonal$2(v) {
-	return Math.abs(v[0]) < .9 ? cross$1(v, [
+	return Math.abs(v[0]) < .9 ? cross$2(v, [
 		1,
 		0,
 		0
-	]) : cross$1(v, [
+	]) : cross$2(v, [
 		0,
 		1,
 		0
@@ -8736,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)
 	});
@@ -8957,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({
@@ -11467,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,
@@ -12347,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?.();
 }
@@ -12379,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);
@@ -14078,12 +14116,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,
@@ -14105,7 +14145,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;
@@ -14133,16 +14177,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();
@@ -14169,7 +14216,11 @@ 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;
@@ -14182,20 +14233,9 @@ function reconstructTessellated(reader, productExpressId, diagnostics) {
 		diagnostics.push(issue("warning", "GEOMETRY_RECONSTRUCTION_FAILED", "Tessellated geometry yielded no triangles", productExpressId));
 		return NONE;
 	}
-	const stl = packBinaryStl(mesh.vertices, mesh.indices, 1e3);
-	let solid = null;
-	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]();
-	} catch (e) {
-		diagnostics.push(issue("info", "TESSELLATION_NOT_MANIFOLD", `STL round-trip failed: ${errMsg$1(e)}`, productExpressId));
-	}
+	const solid = sewMeshToSolid(mesh, 1e3, productExpressId, diagnostics);
 	if (solid !== null) {
-		diagnostics.push(issue("info", "TESSELLATED_MANIFOLD", "Tessellated mesh recovered as a closed solid via STL round-trip", productExpressId));
+		diagnostics.push(issue("info", "TESSELLATED_MANIFOLD", "Tessellated mesh recovered as a closed solid by sewing its triangles", productExpressId));
 		return {
 			kind: "SOLID",
 			solid,
@@ -14210,6 +14250,52 @@ function reconstructTessellated(reader, productExpressId, diagnostics) {
 		diagnostic: "TESSELLATED_LOSSY"
 	};
 }
+/** Loose enough to weld float32 vertices web-ifc emits per face, in mm. */
+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.
+*/
+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;
+}
+/**
+* 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) {
+	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 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));
+		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 (e) {
+		diagnostics.push(issue("info", "TESSELLATION_NOT_MANIFOLD", `Mesh sewing failed: ${errMsg$1(e)}`, productExpressId));
+		return null;
+	} finally {
+		for (const face of triangles) kernel.dispose(face);
+	}
+}
 function collectMesh(reader, productExpressId) {
 	const vertices = [];
 	const indices = [];
@@ -14238,7 +14324,8 @@ function collectMesh(reader, productExpressId) {
 				}
 			}
 		} finally {
-			flatMesh.delete();
+			releaseEmbind(flatMesh.geometries);
+			releaseEmbind(flatMesh);
 		}
 	});
 	if (vertices.length === 0) return null;
@@ -14247,25 +14334,6 @@ function collectMesh(reader, productExpressId) {
 		indices: new Uint32Array(indices)
 	};
 }
-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",
@@ -14409,19 +14477,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)) {
@@ -14476,17 +14624,17 @@ function readAxis2Placement3D(reader, ref, scale) {
 		refDir[2] - dotXZ * zN[2]
 	];
 	const xRawLenSq = xRaw[0] * xRaw[0] + xRaw[1] * xRaw[1] + xRaw[2] * xRaw[2];
-	const orthoZ = Math.abs(zN[0]) < .9 ? cross(zN, [
+	const orthoZ = Math.abs(zN[0]) < .9 ? cross$1(zN, [
 		1,
 		0,
 		0
-	]) : cross(zN, [
+	]) : cross$1(zN, [
 		0,
 		1,
 		0
 	]);
 	const xN = xRawLenSq < 1e-12 ? normalize(orthoZ) : normalize(xRaw);
-	const yN = cross(zN, xN);
+	const yN = cross$1(zN, xN);
 	return {
 		linear: [
 			xN[0],
@@ -14570,6 +14718,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;
@@ -14596,6 +14762,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;
@@ -14646,7 +14815,7 @@ function normalize(v) {
 		v[2] / len
 	];
 }
-function cross(a, b) {
+function cross$1(a, b) {
 	return [
 		a[1] * b[2] - a[2] * b[1],
 		a[2] * b[0] - a[0] * b[2],
@@ -27908,6 +28077,217 @@ function assignNum(target, key, value) {
 	if (value !== void 0) target[key] = Number(value);
 }
 //#endregion
+//#region src/placementFrame.ts
+var IDENTITY_FRAME = [
+	1,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	0,
+	1
+];
+var DEFAULT_AXIS = [
+	0,
+	0,
+	1
+];
+var ORIGIN = [
+	0,
+	0,
+	0
+];
+/** Column-major 4x4 multiply: `a . b` (apply b first, then a). */
+function frameMul(a, b) {
+	const out = new Array(16).fill(0);
+	for (let col = 0; col < 4; col++) for (let row = 0; row < 4; row++) {
+		let sum = 0;
+		for (let k = 0; k < 4; k++) sum += (a[k * 4 + row] ?? 0) * (b[col * 4 + k] ?? 0);
+		out[col * 4 + row] = sum;
+	}
+	return out;
+}
+function translationFrame(v) {
+	return [
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		v[0],
+		v[1],
+		v[2],
+		1
+	];
+}
+function normalizeAxis(axis) {
+	const len = Math.sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
+	if (len < 1e-12) return DEFAULT_AXIS;
+	return [
+		axis[0] / len,
+		axis[1] / len,
+		axis[2] / len
+	];
+}
+function cross(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+/**
+* Builds a frame from an authored `(origin, axisX, axisZ)` placement, using the
+* same IFC orthonormalization as `placementToMatrix`/`readAxis2Placement3D`:
+* z = normalize(axisZ); x = normalize(axisX projected perpendicular to z);
+* y = z x. Lets a civil node authored with explicit axis props enter the same
+* frame pipeline as a `tRotate` chain.
+*/
+function frameFromPlacement(f) {
+	const z = normalizeAxis(f.axisZ);
+	const dot = z[0] * f.axisX[0] + z[1] * f.axisX[1] + z[2] * f.axisX[2];
+	const x = normalizeAxis([
+		f.axisX[0] - dot * z[0],
+		f.axisX[1] - dot * z[1],
+		f.axisX[2] - dot * z[2]
+	]);
+	const y = cross(z, x);
+	return [
+		x[0],
+		x[1],
+		x[2],
+		0,
+		y[0],
+		y[1],
+		y[2],
+		0,
+		z[0],
+		z[1],
+		z[2],
+		0,
+		f.origin[0],
+		f.origin[1],
+		f.origin[2],
+		1
+	];
+}
+/**
+* Rotation by `angleDeg` about `axis` (default +Z) through pivot `at` (default
+* origin), matching `csg.rotate` (Rodrigues; right-handed about the axis). With
+* a pivot the motion is `T(at) . R . T(-at)`, i.e. `p -> at + R(p - at)`.
+*/
+function rotationFrame(angleDeg, axis = DEFAULT_AXIS, at = ORIGIN) {
+	const [x, y, z] = normalizeAxis(axis);
+	const t = angleDeg * Math.PI / 180;
+	const c = Math.cos(t);
+	const s = Math.sin(t);
+	const C = 1 - c;
+	const r00 = c + x * x * C;
+	const r01 = x * y * C - z * s;
+	const r02 = x * z * C + y * s;
+	const r10 = y * x * C + z * s;
+	const r11 = c + y * y * C;
+	const r12 = y * z * C - x * s;
+	const r20 = z * x * C - y * s;
+	const r21 = z * y * C + x * s;
+	const r22 = c + z * z * C;
+	const rat0 = r00 * at[0] + r01 * at[1] + r02 * at[2];
+	const rat1 = r10 * at[0] + r11 * at[1] + r12 * at[2];
+	const rat2 = r20 * at[0] + r21 * at[1] + r22 * at[2];
+	return [
+		r00,
+		r10,
+		r20,
+		0,
+		r01,
+		r11,
+		r21,
+		0,
+		r02,
+		r12,
+		r22,
+		0,
+		at[0] - rat0,
+		at[1] - rat1,
+		at[2] - rat2,
+		1
+	];
+}
+function opFrame(op) {
+	if (op.op === "translate") return translationFrame(op.v);
+	return rotationFrame(op.angleDeg, op.axis ?? DEFAULT_AXIS, op.at ?? ORIGIN);
+}
+/**
+* Composes an authored `TransformOp` chain into one frame, matching families'
+* `applyOps`: `ops[0]` is innermost (applied first). For `[A, B]` the composed
+* motion is `B . A`, so a point transforms as `B(A(p))`.
+*/
+function frameFromOps(ops) {
+	let m = IDENTITY_FRAME;
+	for (const op of ops) m = frameMul(opFrame(op), m);
+	return m;
+}
+/** Rigid inverse of `[R | t]`: `[R^T | -R^T t]`. */
+function frameInverse(f) {
+	const t0 = f[12] ?? 0;
+	const t1 = f[13] ?? 0;
+	const t2 = f[14] ?? 0;
+	const inv0 = -(f[0] * t0 + f[1] * t1 + f[2] * t2);
+	const inv1 = -(f[4] * t0 + f[5] * t1 + f[6] * t2);
+	const inv2 = -(f[8] * t0 + f[9] * t1 + f[10] * t2);
+	return [
+		f[0],
+		f[4],
+		f[8],
+		0,
+		f[1],
+		f[5],
+		f[9],
+		0,
+		f[2],
+		f[6],
+		f[10],
+		0,
+		inv0,
+		inv1,
+		inv2,
+		1
+	];
+}
+/** Decomposes a frame into origin (mm) + IFC axes (axisX, axisZ). */
+function decomposeFrame(f) {
+	return decomposePlacement(f);
+}
+/** Translation column of a frame. */
+function frameOrigin(f) {
+	return [
+		f[12] ?? 0,
+		f[13] ?? 0,
+		f[14] ?? 0
+	];
+}
+/** True when the rotation part is the identity (within tolerance): a pure
+*  translation, so the existing translation-only placement path suffices. */
+function isPureTranslation(f, eps = 1e-9) {
+	return Math.abs((f[0] ?? 1) - 1) < eps && Math.abs((f[5] ?? 1) - 1) < eps && Math.abs((f[10] ?? 1) - 1) < eps && Math.abs(f[1] ?? 0) < eps && Math.abs(f[2] ?? 0) < eps && Math.abs(f[4] ?? 0) < eps && Math.abs(f[6] ?? 0) < eps && Math.abs(f[8] ?? 0) < eps && Math.abs(f[9] ?? 0) < eps;
+}
+//#endregion
 //#region src/familiesAdapter.ts
 /**
 * brepjs-families -> BimModel adapter. Consumes a resolved element tree and
@@ -28129,6 +28509,36 @@ function centreOrigin(base, shift) {
 		origin[2] + shift[2]
 	];
 }
+function synthesizedProfile(el) {
+	if (el.semantics?.kind !== "product" || el.props["profile"] !== void 0) return void 0;
+	const length = semanticDimension(el, "length");
+	const width = semanticDimension(el, "width");
+	const height = semanticDimension(el, "height");
+	if (el.semantics.category === "beam" && width !== void 0 && height !== void 0) return {
+		profile: {
+			kind: "RECTANGULAR",
+			width,
+			height
+		},
+		shift: [
+			0,
+			width / 2,
+			height / 2
+		]
+	};
+	if (el.semantics.category === "column" && length !== void 0 && width !== void 0) return {
+		profile: {
+			kind: "RECTANGULAR",
+			width: length,
+			height: width
+		},
+		shift: [
+			length / 2,
+			width / 2,
+			0
+		]
+	};
+}
 /**
 * Adapts target-independent civil envelope dimensions onto existing typed BIM
 * spec inputs. Reference infrastructure Families intentionally author domain
@@ -28143,18 +28553,7 @@ function civilProductSpecInput(el) {
 	const height = semanticDimension(el, "height");
 	switch (el.semantics.category) {
 		case "beam": {
-			const synthesized = base["profile"] === void 0 && width !== void 0 && height !== void 0 ? {
-				profile: {
-					kind: "RECTANGULAR",
-					width,
-					height
-				},
-				shift: [
-					0,
-					width / 2,
-					height / 2
-				]
-			} : void 0;
+			const synthesized = synthesizedProfile(el);
 			return {
 				...base,
 				...synthesized !== void 0 ? {
@@ -28166,18 +28565,7 @@ function civilProductSpecInput(el) {
 			};
 		}
 		case "column": {
-			const synthesized = base["profile"] === void 0 && length !== void 0 && width !== void 0 ? {
-				profile: {
-					kind: "RECTANGULAR",
-					width: length,
-					height: width
-				},
-				shift: [
-					length / 2,
-					width / 2,
-					0
-				]
-			} : void 0;
+			const synthesized = synthesizedProfile(el);
 			return {
 				...base,
 				...synthesized !== void 0 ? {
@@ -28244,12 +28632,12 @@ function peelTranslates(node) {
 		moved
 	};
 }
-/** True when the element's rendered local transform carries a rotation. The spec path
-*  folds only translations into IfcLocalPlacement (walls orient via `axisX`),
-*  so a tRotate placement would export un-rotated while the viewport shows it
-*  rotated — reject instead of diverging. Rotations a family render bakes
-*  into its own body geometry (e.g. a circular beam oriented along axisX) are
-*  fine: the spec rebuilds that body parametrically from props. */
+/** True when the element's rendered local transform carries a rotation, which
+*  switches the walk to the rigid-frame placement path (the composed rotation
+*  folds into origin + axisX + axisZ). Only authored `transform` rotations
+*  count: a rotation a family render bakes into its own body geometry (e.g. a
+*  circular beam oriented along axisX) stays in the body, which the spec
+*  rebuilds parametrically from props. */
 function hasRotateOp(el) {
 	return el.localTransforms.some((op) => op.op === "rotate");
 }
@@ -28364,7 +28752,7 @@ function materializeOwnedSolid(el, evaluator, errors) {
 /** Materialize an unrouted element's IR and add it as a proxy. The body is
 *  authoritative for a proxy (no parametric spec to diverge from), so baked
 *  transforms — rotations included — are fine here. */
-function addProxyElement(model, el, evaluator, projectedSpatialTranslation) {
+function addProxyElement(model, el, evaluator, spatialFrame) {
 	const body = materializeOwnedSolid(el, evaluator, {
 		evalCode: "FAMILIES_PROXY_EVAL_FAILED",
 		notSolidCode: "FAMILIES_PROXY_NOT_SOLID",
@@ -28372,7 +28760,7 @@ function addProxyElement(model, el, evaluator, projectedSpatialTranslation) {
 		routeName: "proxy"
 	});
 	if (!body.ok) return body;
-	const localized = localizeOwnedSolid(el, body.value, projectedSpatialTranslation, "FAMILIES_PROXY_LOCALIZE_FAILED", "spatial parent");
+	const localized = localizeBodyToFrame(el, body.value, spatialFrame, "FAMILIES_PROXY_LOCALIZE_FAILED", "spatial parent");
 	if (!localized.ok) return localized;
 	const nameAttr = el.attributes["name"];
 	const materialProp = el.props["materialName"];
@@ -28535,8 +28923,9 @@ var DEFAULT_AXIS_Z = [
 function axisEquals(value, axis) {
 	return Array.isArray(value) && value.length === 3 && value.every((component, i) => typeof component === "number" && component === axis[i]);
 }
-/** Civil descendant relativization is translation-only, so a civil frame with
-*  non-default axes would rotate the exported hierarchy away from the IR. */
+/** True when a civil node authors non-default `axisX`/`axisZ` props: like a
+*  tRotate, this puts the node (and its subtree) on the rigid-frame placement
+*  path so descendants relativize against the rotated parent frame. */
 function hasRotatedAxes(el) {
 	const axisX = el.props["axisX"];
 	const axisZ = el.props["axisZ"];
@@ -28575,6 +28964,131 @@ function authoredTranslation(el) {
 	}
 	return total;
 }
+function authoredAxisX(el) {
+	const v = el.props["axisX"];
+	return Array.isArray(v) && v.length === 3 ? v : DEFAULT_AXIS_X;
+}
+function authoredAxisZ(el) {
+	const v = el.props["axisZ"];
+	return Array.isArray(v) && v.length === 3 ? v : DEFAULT_AXIS_Z;
+}
+/** The placement shift that centres a synthesized beam/column cross-section on
+*  its axis, in the element's own (body) frame. Zero for every other route. */
+function specLocalShift(el) {
+	return synthesizedProfile(el)?.shift ?? [
+		0,
+		0,
+		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 + literal Body
+*  Datum + centring shift). Under no rotation this reduces to `composedOrigin`
+*  + shift. */
+function elementBodyFrame(el, cumulativeFrame, occurrenceTransformDepth) {
+	return frameMul(frameMul(cumulativeFrame, frameFromPlacement({
+		origin: addTranslation(authoredSpecOrigin(el), bodyLocalTranslation(el, occurrenceTransformDepth)),
+		axisX: authoredAxisX(el),
+		axisZ: authoredAxisZ(el)
+	})), translationFrame(specLocalShift(el)));
+}
+/** World frame of a civil spatial node: cumulative transforms composed with any
+*  authored `origin`/`axisX`/`axisZ` props (identity when default). */
+function civilNodeFrame(el, cumulativeFrame) {
+	return frameMul(cumulativeFrame, frameFromPlacement({
+		origin: authoredSpecOrigin(el),
+		axisX: authoredAxisX(el),
+		axisZ: authoredAxisZ(el)
+	}));
+}
+/** Places a routed element's spec input through the composed placement frame:
+*  the flat spec input keeps its dimensions/profile/psets, but `origin`/`axisX`/
+*  `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, occurrenceTransformDepth, spatialFrame) {
+	const toSpatial = frameInverse(spatialFrame);
+	if (Array.isArray(flatInput["flights"])) {
+		const elementFrame = elementBodyFrame(el, cumulativeFrame, occurrenceTransformDepth);
+		const flights = flatInput["flights"];
+		return {
+			...flatInput,
+			origin: [
+				0,
+				0,
+				0
+			],
+			axisX: [
+				1,
+				0,
+				0
+			],
+			axisZ: [
+				0,
+				0,
+				1
+			],
+			flights: flights.map((flight) => {
+				if (typeof flight !== "object" || flight === null) return flight;
+				const f = flight;
+				const world = frameMul(elementFrame, frameFromPlacement({
+					origin: f["origin"] ?? [
+						0,
+						0,
+						0
+					],
+					axisX: f["axisX"] ?? DEFAULT_AXIS_X,
+					axisZ: f["axisZ"] ?? DEFAULT_AXIS_Z
+				}));
+				const placed = decomposeFrame(frameMul(toSpatial, world));
+				return {
+					...f,
+					origin: placed.origin,
+					axisX: placed.axisX,
+					axisZ: placed.axisZ
+				};
+			})
+		};
+	}
+	const placed = decomposeFrame(frameMul(toSpatial, elementBodyFrame(el, cumulativeFrame, occurrenceTransformDepth)));
+	return {
+		...flatInput,
+		origin: placed.origin,
+		axisX: placed.axisX,
+		axisZ: placed.axisZ
+	};
+}
+/** Moves an owned world-baked body into its spatial container's local frame.
+*  A pure translation keeps the fast `translate` path (identical to the prior
+*  behaviour); a rotated container applies the inverse frame via `applyMatrix`. */
+function localizeBodyToFrame(el, body, spatialFrame, errorCode, frameName) {
+	if (isPureTranslation(spatialFrame)) return localizeOwnedSolid(el, body, frameOrigin(spatialFrame), errorCode, frameName);
+	const inverse = decomposeFrame(frameInverse(spatialFrame));
+	try {
+		const localized = applyMatrix(body, placementToMatrix(inverse));
+		if (!localized.ok) {
+			body[Symbol.dispose]();
+			return err(specError(errorCode, `familiesToBim: '${el.keyPath}' could not move its body into the ${frameName} frame`, localized.error));
+		}
+		body[Symbol.dispose]();
+		return ok(localized.value);
+	} catch (cause) {
+		body[Symbol.dispose]();
+		return err(specError(errorCode, `familiesToBim: '${el.keyPath}' could not move its body into the ${frameName} frame`, cause));
+	}
+}
 function civilSpatialInput(el, localTranslation) {
 	const semantics = el.semantics;
 	const composition = semantics !== void 0 && "composition" in semantics ? CIVIL_COMPOSITION[semantics.composition] : void 0;
@@ -28587,22 +29101,36 @@ function civilSpatialInput(el, localTranslation) {
 		...composition !== void 0 ? { compositionType: composition } : {}
 	};
 }
+/** Relativizes a civil node's world frame against its parent civil frame into
+*  the origin/axisX/axisZ the spatial specs consume. */
+function civilSpatialFrameInput(el, nodeFrame, parentFrame) {
+	const semantics = el.semantics;
+	const composition = semantics !== void 0 && "composition" in semantics ? CIVIL_COMPOSITION[semantics.composition] : void 0;
+	const local = decomposeFrame(frameMul(frameInverse(parentFrame), nodeFrame));
+	return {
+		name: semanticName(el),
+		origin: local.origin,
+		axisX: local.axisX,
+		axisZ: local.axisZ,
+		...composition !== void 0 ? { compositionType: composition } : {}
+	};
+}
 function civilParentAccepts(kind, parent) {
 	if (kind === "site") return parent === "project";
 	if (kind === "bridge") return parent === "site";
 	return parent === "bridge" || parent === "bridge-part";
 }
-function addCivilSpatialOccurrence(model, el, kind, localTranslation) {
+function addCivilSpatialOccurrence(model, el, kind, input) {
 	if (kind === "site") {
 		if (el.semantics?.role !== "transport-site") return unsupportedCivilRole(el, "Site");
-		const parsed = parseSiteSpec(civilSpatialInput(el, localTranslation));
+		const parsed = parseSiteSpec(input);
 		return parsed.ok ? model.addSite(parsed.value, { stableKey: el.keyPath }) : parsed;
 	}
 	if (kind === "bridge") {
 		const predefinedType = lookup(BRIDGE_ROLE, el.semantics?.role ?? "");
 		if (predefinedType === void 0) return unsupportedCivilRole(el, "Bridge");
 		const parsed = parseBridgeSpec({
-			...civilSpatialInput(el, localTranslation),
+			...input,
 			predefinedType
 		});
 		return parsed.ok ? model.addBridge(parsed.value, { stableKey: el.keyPath }) : parsed;
@@ -28611,7 +29139,7 @@ function addCivilSpatialOccurrence(model, el, kind, localTranslation) {
 	const predefinedType = lookup(BRIDGE_PART_ROLE, el.semantics?.role ?? "");
 	if (predefinedType === void 0) return unsupportedCivilRole(el, "Bridge Part");
 	const parsed = parseBridgePartSpec({
-		...civilSpatialInput(el, localTranslation),
+		...input,
 		predefinedType,
 		usageType: subdivision !== void 0 ? CIVIL_USAGE[subdivision] : "NOTDEFINED"
 	});
@@ -28638,7 +29166,7 @@ function relativeSpecInput(input, projectedSpatialTranslation) {
 		origin: relativeOrigin(input["origin"])
 	};
 }
-function addEarthworksFillElement(model, el, evaluator, projectedSpatialTranslation) {
+function addEarthworksFillElement(model, el, evaluator, spatialFrame) {
 	if (el.semantics?.kind !== "product") return err(specError("FAMILIES_UNSUPPORTED_CIVIL_SEMANTICS", `familiesToBim: '${el.keyPath}' is not authored as a civil Product`));
 	const predefinedType = lookup(EARTHWORKS_FILL_ROLE, el.semantics.role);
 	if (predefinedType === void 0) return unsupportedCivilRole(el, "Earthworks Fill");
@@ -28649,7 +29177,7 @@ function addEarthworksFillElement(model, el, evaluator, projectedSpatialTranslat
 		routeName: "Earthworks Fill"
 	});
 	if (!body.ok) return body;
-	const localized = localizeOwnedSolid(el, body.value, projectedSpatialTranslation, "FAMILIES_EARTHWORKS_LOCALIZE_FAILED", "Bridge Part");
+	const localized = localizeBodyToFrame(el, body.value, spatialFrame, "FAMILIES_EARTHWORKS_LOCALIZE_FAILED", "Bridge Part");
 	if (!localized.ok) return localized;
 	const specProps = collectSpecProps(el);
 	const authoredMaterial = el.props["materialName"];
@@ -28699,10 +29227,15 @@ 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;
 		let nextSpatialStructureId = state.spatialStructureId;
 		let nextCivilParent = state.civilParent;
 		let nextProjectedSpatialTranslation = state.projectedSpatialTranslation;
+		let nextCumulativeFrame = cumulativeFrameHere;
+		let nextSpatialFrame = state.spatialFrame;
 		const archetype = archetypeFor(el);
 		const effectiveArchetype = el.semantics?.kind === "product" ? civilProductArchetype(el) : archetype;
 		const route = specRoute(effectiveArchetype);
@@ -28711,15 +29244,19 @@ function familiesToBim(root, options) {
 			if (!usesAuthoredCivilHierarchy || !civilParentAccepts(civilKind, state.civilParent) || state.spatialStructureId === null) return err(specError("FAMILIES_INVALID_CIVIL_HIERARCHY", `familiesToBim: civil '${civilKind}' at '${el.keyPath}' cannot occur under '${state.civilParent}'`));
 			const keyed = requireKeyed(el);
 			if (!keyed.ok) return keyed;
-			if (rotatedHere || hasRotatedAxes(el)) return err(specError("FAMILIES_UNSUPPORTED_TRANSFORM", `familiesToBim: civil spatial element '${el.keyPath}' carries a rotated frame — descendants are relativized by translation only, so bake the orientation into child geometry`));
 			if (el.geometry.kind !== "Empty") return err(specError("FAMILIES_UNSUPPORTED_CIVIL_SEMANTICS", `familiesToBim: civil spatial element '${el.keyPath}' carries its own geometry — Site/Bridge/Bridge Part export no body, so author it as a child Product (e.g. Earthworks Fill)`));
-			const localTranslation = subtractTranslation(cumulativeTranslationHere, state.projectedSpatialTranslation);
-			const added = addCivilSpatialOccurrence(model, el, civilKind, localTranslation);
+			const nodeFrame = civilNodeFrame(el, cumulativeFrameHere);
+			const rotatedFrame = rotatedHere || hasRotatedAxes(el);
+			const input = rotatedFrame ? civilSpatialFrameInput(el, nodeFrame, state.spatialFrame) : civilSpatialInput(el, subtractTranslation(cumulativeTranslationHere, state.projectedSpatialTranslation));
+			const added = addCivilSpatialOccurrence(model, el, civilKind, input);
 			if (!added.ok) return added;
 			model.aggregate(state.spatialStructureId, added.value);
 			idByKeyPath.set(el.keyPath, added.value);
 			nextSpatialStructureId = added.value;
 			nextCivilParent = civilKind;
+			nextRotated = rotatedFrame;
+			nextCumulativeFrame = nodeFrame;
+			nextSpatialFrame = nodeFrame;
 			nextProjectedSpatialTranslation = addTranslation(cumulativeTranslationHere, authoredSpecOrigin(el));
 		} else if (isCivilSpatialIntent(el)) return err(specError("FAMILIES_UNSUPPORTED_CIVIL_SEMANTICS", `familiesToBim: unsupported civil '${el.semantics?.kind ?? "unknown"}' category '${el.semantics?.category ?? ""}' at '${el.keyPath}'`));
 		else if (archetype === "storey") {
@@ -28740,21 +29277,22 @@ function familiesToBim(root, options) {
 			if (bodyEvaluator === void 0) return err(specError("FAMILIES_EARTHWORKS_EVALUATOR_REQUIRED", `familiesToBim: Earthworks Fill '${el.keyPath}' needs bodyEvaluator to materialize its exact Product Body`));
 			const keyed = requireKeyed(el);
 			if (!keyed.ok) return keyed;
-			const added = addEarthworksFillElement(model, el, bodyEvaluator, state.projectedSpatialTranslation);
+			const added = addEarthworksFillElement(model, el, bodyEvaluator, state.spatialFrame);
 			if (!added.ok) return added;
 			model.placeIn(added.value, nextSpatialStructureId);
 			idByKeyPath.set(el.keyPath, added.value);
 		} else if (route !== void 0) {
 			const keyed = requireKeyed(el);
 			if (!keyed.ok) return keyed;
-			if (rotatedHere) return err(specError("FAMILIES_UNSUPPORTED_TRANSFORM", `familiesToBim: '${el.keyPath}' carries a rotated placement — the spec path folds only translations into IfcLocalPlacement; orient walls via axisX instead of tRotate`));
 			const voids = el.props["voids"];
 			if (Array.isArray(voids)) {
 				const openings = el.children.filter((c) => c.type === "Opening").length;
 				if (voids.length > openings) return err(specError("FAMILIES_ANONYMOUS_VOID", `familiesToBim: '${el.keyPath}' has ${voids.length - openings} anonymous void(s) the IFC body cannot carry — use a fill-role family (Door/Window) for each void`));
 			}
 			const routedInput = el.semantics?.kind === "product" ? civilProductSpecInput(el) : ("input" in route ? route.input : specInput)(el);
-			const parsed = route.parse(usesAuthoredCivilHierarchy ? relativeSpecInput(routedInput, state.projectedSpatialTranslation) : routedInput);
+			const rotatedBase = Array.isArray(routedInput["flights"]) ? specInput(el) : 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);
 			if (!added.ok) return added;
@@ -28771,7 +29309,7 @@ function familiesToBim(root, options) {
 			const keyed = requireKeyed(el);
 			if (!keyed.ok) return keyed;
 			if (nextSpatialStructureId === null || usesAuthoredCivilHierarchy && state.civilParent !== "bridge-part") return err(specError(usesAuthoredCivilHierarchy ? "FAMILIES_INVALID_CIVIL_HIERARCHY" : "FAMILIES_NO_STOREY", usesAuthoredCivilHierarchy ? `familiesToBim: physical product '${el.keyPath}' needs a Bridge Part ancestor` : `familiesToBim: '${el.keyPath}' has no Storey ancestor — IFC elements need spatial containment; a container family needs archetype: 'storey' to be recognised under any name`));
-			const added = addProxyElement(model, el, options.proxyEvaluator, state.projectedSpatialTranslation);
+			const added = addProxyElement(model, el, options.proxyEvaluator, state.spatialFrame);
 			if (!added.ok) return added;
 			model.placeIn(added.value, nextSpatialStructureId);
 			idByKeyPath.set(el.keyPath, added.value);
@@ -28787,9 +29325,12 @@ function familiesToBim(root, options) {
 			const r = walk(child, {
 				spatialStructureId: nextSpatialStructureId,
 				civilParent: nextCivilParent,
-				rotated: rotatedHere,
+				rotated: nextRotated,
 				cumulativeTranslation: cumulativeTranslationHere,
-				projectedSpatialTranslation: nextProjectedSpatialTranslation
+				projectedSpatialTranslation: nextProjectedSpatialTranslation,
+				occurrenceTransformDepth: occurrenceTransformDepthHere,
+				cumulativeFrame: nextCumulativeFrame,
+				spatialFrame: nextSpatialFrame
 			});
 			if (!r.ok) return r;
 		}
@@ -28800,7 +29341,10 @@ function familiesToBim(root, options) {
 		civilParent: "project",
 		rotated: false,
 		cumulativeTranslation: ZERO_TRANSLATION,
-		projectedSpatialTranslation: ZERO_TRANSLATION
+		projectedSpatialTranslation: ZERO_TRANSLATION,
+		occurrenceTransformDepth: 0,
+		cumulativeFrame: IDENTITY_FRAME,
+		spatialFrame: IDENTITY_FRAME
 	});
 	if (!walked.ok) {
 		model[Symbol.dispose]();