@bldrs-ai/conway 1.516.1463 → 1.519.1471

package/compiled/examples/browser-bundled.cjs

@@ -30,7 +30,7 @@ var import_node_process = require("node:process");
 var readline = __toESM(require("node:readline"), 1);
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.516.1463";
+var versionString = "Conway v1.519.1471";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/examples/cli-bundled.cjs

@@ -14965,7 +14965,7 @@ ${t5.join("\n")}` : "";
 var import_process = require("process");
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.516.1463";
+var versionString = "Conway v1.519.1471";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {

package/compiled/examples/cli-step-bundled.cjs

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.516.1463";
+var versionString = "Conway v1.519.1471";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {

package/compiled/examples/validator-bundled.cjs

@@ -944,7 +944,7 @@ var EntityTypesIfcCount = 909;
 var entity_types_ifc_gen_default = EntityTypesIfc;
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.516.1463";
+var versionString = "Conway v1.519.1471";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/src/compat/web-ifc/spatial_imposter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spatial_imposter.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/spatial_imposter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,0BAA0B,CAAA;AAgBxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAKpE,gEAAgE;AAChE,eAAO,MAAM,sBAAsB;;;;;CAA+B,CAAA;AAqBlE,+DAA+D;AAC/D,MAAM,WAAW,KAAK;IACpB,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B;AA0BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAE,IAAI,EAAE,KAAK,GAAI,MAAM,EAAE,CAerD;AAqCD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAE,QAAQ,EAAE,MAAM,GAAI,MAAM,CAGlE;AAGD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GAAI,OAAO,CAW5B;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC3B,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,GAAG,GAAE,MAAqB,EAC1B,OAAO,GAAE,MAAmB,GAAI,OAAO,CAiB1C;AAGD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAE,GAAG,KAAK,EAAE,CAAE,KAAK,GAAG,SAAS,CAAE,EAAE,GAAI,KAAK,GAAG,SAAS,CA4BhF;AAmKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAsB,6BAA6B,CAC/C,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,CAAE,IAAI,EAAE,kBAAkB,KAAM,IAAI,EAC5C,kBAAkB,CAAC,EAAE,SAAS,CAAE,MAAM,CAAE,EACxC,mBAAmB,GAAE,MAAU,GAAI,OAAO,CAAE,MAAM,CAAE,CAwdvD"}
+{"version":3,"file":"spatial_imposter.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/spatial_imposter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,0BAA0B,CAAA;AAgBxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAKpE,gEAAgE;AAChE,eAAO,MAAM,sBAAsB;;;;;CAA+B,CAAA;AAqBlE,+DAA+D;AAC/D,MAAM,WAAW,KAAK;IACpB,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B;AA0BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAE,IAAI,EAAE,KAAK,GAAI,MAAM,EAAE,CAerD;AA6DD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAE,QAAQ,EAAE,MAAM,GAAI,MAAM,CAGlE;AAGD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GAAI,OAAO,CAW5B;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC3B,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,GAAG,GAAE,MAAqB,EAC1B,OAAO,GAAE,MAAmB,GAAI,OAAO,CAiB1C;AAGD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAE,GAAG,KAAK,EAAE,CAAE,KAAK,GAAG,SAAS,CAAE,EAAE,GAAI,KAAK,GAAG,SAAS,CA4BhF;AAoWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAsB,6BAA6B,CAC/C,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,CAAE,IAAI,EAAE,kBAAkB,KAAM,IAAI,EAC5C,kBAAkB,CAAC,EAAE,SAAS,CAAE,MAAM,CAAE,EACxC,mBAAmB,GAAE,MAAU,GAAI,OAAO,CAAE,MAAM,CAAE,CAkevD"}

package/compiled/src/compat/web-ifc/spatial_imposter.js

@@ -83,7 +83,33 @@ const PRODUCT_PLACEMENT = [5, 5, 3];
 const LOCAL_PLACEMENT_REL_TO = [0, 0, 1];
 const LOCAL_PLACEMENT_RELATIVE = [1, 0, 1];
 const PLACEMENT_LOCATION = [0, 0, 2];
+const PLACEMENT_AXIS = [1, 1, 3];
+const PLACEMENT_REF_DIRECTION = [2, 1, 3];
 const STOREY_ELEVATION = [9, 9, 6];
+const IDENTITY_PLACEMENT = [
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+];
+/** Column-major indices of a 4x4's translation component. */
+const TRANSLATION = [12, 13, 14];
+/** Column-major index of the local +Z axis' world Z component. */
+const LOCAL_Z_WORLD_Z = 10;
+/** Cross-product magnitude below which two unit axes are parallel. */
+const MIN_AXIS_CROSS = 1e-9;
 const SPACE_TYPES = new Set([
     EntityTypesIfc.IFCSPACE,
     EntityTypesIfc.IFCSPATIALZONE,
@@ -192,15 +218,188 @@ async function ensure_(model, localID) {
     await model.ensureResidentByLocalID(localID);
 }
 /**
- * World translation of an IfcLocalPlacement chain (rotation ignored —
- * enough for the axis-aligned storey plates this first pass draws).
+ * @param v A vector.
+ * @return {[number, number, number] | undefined} `v` scaled to unit
+ * length, or undefined when it has none (zero / non-finite input).
+ */
+function normalize3_(v) {
+    const length = Math.hypot(v[0], v[1], v[2]);
+    return Number.isFinite(length) && length > 0 ?
+        [v[0] / length, v[1] / length, v[2] / length] : void 0;
+}
+/**
+ * @param a Left vector.
+ * @param b Right vector.
+ * @return {[number, number, number]} `a` x `b`.
+ */
+function cross3_(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],
+    ];
+}
+/**
+ * The `DirectionRatios` of an IfcDirection referenced from `field` of
+ * `entity`, or undefined when the field is absent.
+ *
+ * @param model The model.
+ * @param entity The referring entity.
+ * @param field The (index, min, max) field triple.
+ * @return {Promise<[number, number, number] | undefined>} The ratios.
+ */
+async function directionRatios_(model, entity, field) {
+    const directionID = entity.extractReferenceLocalID(field[0], field[1], field[2], true);
+    if (directionID === null) {
+        return;
+    }
+    await ensure_(model, directionID);
+    const direction = model.getElementByLocalID(directionID);
+    const ratios = direction?.DirectionRatios;
+    if (ratios === void 0 || ratios.length < 2) {
+        return;
+    }
+    return [ratios[0], ratios[1], ratios[2] ?? 0];
+}
+/**
+ * The local +X reference to use when a placement states an `Axis` but no
+ * `RefDirection`: world +X, unless that is (nearly) parallel to the
+ * stated axis, in which case world +Y.
+ *
+ * IFC's own `IfcFirstProjAxis` makes exactly this substitution, and
+ * without it a lie-down placement — `Axis = (1,0,0)`, RefDirection
+ * omitted, which is how a wall-mounted or rotated-into-plan element is
+ * commonly written — has its Axis cross the defaulted (1,0,0) to zero
+ * and falls all the way back to the world frame, discarding a perfectly
+ * well-formed rotation. conway-geom divides by that zero cross product
+ * and returns NaN, so matching the C++ settles nothing here; keeping the
+ * stated Axis is strictly better than dropping it.
+ *
+ * @param zAxis The normalized local +Z.
+ * @return {[number, number, number]} A reference not parallel to it.
+ */
+function defaultRefDirection_(zAxis) {
+    // |cross(zAxis, worldX)| — world +X stays the default (which is what
+    // the IFC default says, and what the overwhelmingly common
+    // zAxis = (0,0,1) needs) until it degenerates.
+    return Math.hypot(zAxis[1], zAxis[2]) > MIN_AXIS_CROSS ?
+        [1, 0, 0] : [0, 1, 0];
+}
+/**
+ * The 4x4 an IfcAxis2Placement denotes: Location as the translation,
+ * and — on the 3D form only — Axis as local +Z and RefDirection as local
+ * +X, both defaulting to the world axes when absent per the IFC
+ * defaults.
+ *
+ * The 2D form has to be handled, not assumed away.
+ * `IfcLocalPlacement.RelativePlacement` is
+ * `IfcAxis2Placement2D | IfcAxis2Placement3D`, and the two disagree on
+ * every field past Location: offset 1 is `Axis` on the 3D entity but
+ * `RefDirection` on the 2D one, and offset 2 does not exist there at
+ * all, so reading it throws "too few fields in record". That throw would
+ * escape to {@link placementTransform_}'s catch, which memoizes
+ * `undefined` for the placement — and a memoized undefined is not merely
+ * a lost sample: every descendant placement then takes the
+ * no-parent branch and is composed in LOCAL coordinates, silently
+ * reparenting a whole subtree to the origin. So the direction fields are
+ * read only once the type is confirmed 3D, which also restores the
+ * pre-#517 behaviour for 2D links (translation only).
+ *
+ * Deliberately the same construction as conway-geom's
+ * `GetAxis2Placement3D` (ConwayGeometryProcessor.cpp) — normalize the
+ * two references, `y = normalize(z x x)`, then re-derive
+ * `x = normalize(y x z)` so a non-perpendicular RefDirection is
+ * projected rather than skewing the frame. It has to match: the plates
+ * are previewing meshes the durable pipeline places with that function,
+ * and a second convention here (Gram-Schmidt on x, say) would rotate
+ * them apart on any file whose RefDirection is off-perpendicular.
+ *
+ * One deviation, on degenerate input: where the C++ divides by a zero
+ * cross product and yields NaN, this falls back to the identity axes. A
+ * NaN transform reaching Share is an invisible or scene-destroying box,
+ * and the imposter path's standing rule is that a preview must never
+ * break open.
+ *
+ * @param model The model.
+ * @param axisLocalID The IfcAxis2Placement3D's local ID.
+ * @return {Promise<Mat4>} The placement, identity if unreadable.
+ */
+async function axisPlacementMatrix_(model, axisLocalID) {
+    await ensure_(model, axisLocalID);
+    const placement = model.getElementByLocalID(axisLocalID);
+    if (placement === void 0) {
+        return IDENTITY_PLACEMENT.slice();
+    }
+    let translation = [0, 0, 0];
+    const locationID = placement.extractReferenceLocalID(PLACEMENT_LOCATION[0], PLACEMENT_LOCATION[1], PLACEMENT_LOCATION[2], false);
+    if (locationID !== null) {
+        await ensure_(model, locationID);
+        const point = model.getElementByLocalID(locationID);
+        const coords = point?.Coordinates;
+        if (coords !== void 0 && coords.length >= 2) {
+            translation = [coords[0], coords[1], coords[2] ?? 0];
+        }
+    }
+    const is3D = model.typeIDOf(axisLocalID) === EntityTypesIfc.IFCAXIS2PLACEMENT3D;
+    const axisRatios = is3D ?
+        await directionRatios_(model, placement, PLACEMENT_AXIS) : void 0;
+    const refRatios = is3D ?
+        await directionRatios_(model, placement, PLACEMENT_REF_DIRECTION) : void 0;
+    let zAxis = (axisRatios !== void 0 ? normalize3_(axisRatios) : void 0) ?? [0, 0, 1];
+    let refAxis = (refRatios !== void 0 ? normalize3_(refRatios) : void 0) ??
+        defaultRefDirection_(zAxis);
+    let yAxis = normalize3_(cross3_(zAxis, refAxis));
+    if (yAxis === void 0) {
+        // Axis and RefDirection are parallel (or garbage): nothing here
+        // determines a frame, so keep the translation and drop back to world
+        // axes. Only reachable with an explicit RefDirection now — an Axis
+        // on its own gets a perpendicular default instead of being thrown
+        // away with it (see defaultRefDirection_).
+        zAxis = [0, 0, 1];
+        refAxis = [1, 0, 0];
+        yAxis = [0, 1, 0];
+    }
+    const xAxis = normalize3_(cross3_(yAxis, zAxis)) ?? refAxis;
+    return [
+        xAxis[0],
+        xAxis[1],
+        xAxis[2],
+        0,
+        yAxis[0],
+        yAxis[1],
+        yAxis[2],
+        0,
+        zAxis[0],
+        zAxis[1],
+        zAxis[2],
+        0,
+        translation[0],
+        translation[1],
+        translation[2],
+        1,
+    ];
+}
+/**
+ * The composed world transform of an IfcLocalPlacement chain: every
+ * link's IfcAxis2Placement3D built out in full and multiplied
+ * `parent * local`, which is exactly conway-geom's `GetLocalPlacement`.
+ *
+ * Rotation used to be dropped here — the chain summed Location
+ * translations and nothing else (conway#514's shortcut). That is correct
+ * only while every ancestor placement is axis-aligned, and Revit
+ * routinely rotates the site or building placement to true north, so on
+ * a real export every sampled origin landed unrotated in raw model space
+ * while the durable meshes beside it did not: the plate cloud read as a
+ * rotated ghost of the building (conway#517).
  *
  * @param model The model.
  * @param placementLocalID IfcObjectPlacement local ID.
- * @param cache Memo.
- * @return {Promise<[number, number, number] | undefined>} World origin.
+ * @param cache Memo of composed transforms, keyed by placement local ID.
+ * A placement re-entered while it is being composed (a cyclic RelativeTo)
+ * reads back undefined and stops the recursion.
+ * @return {Promise<Mat4 | undefined>} The world transform.
  */
-async function placementOrigin_(model, placementLocalID, cache) {
+async function placementTransform_(model, placementLocalID, cache) {
     if (cache.has(placementLocalID)) {
         return cache.get(placementLocalID);
     }
@@ -216,37 +415,16 @@ async function placementOrigin_(model, placementLocalID, cache) {
             return;
         }
         const relativeID = entity.extractReferenceLocalID(LOCAL_PLACEMENT_RELATIVE[0], LOCAL_PLACEMENT_RELATIVE[1], LOCAL_PLACEMENT_RELATIVE[2], false);
-        let local = [0, 0, 0];
-        if (relativeID !== null) {
-            await ensure_(model, relativeID);
-            const relative = model.getElementByLocalID(relativeID);
-            if (relative !== void 0) {
-                const locationID = relative.extractReferenceLocalID(PLACEMENT_LOCATION[0], PLACEMENT_LOCATION[1], PLACEMENT_LOCATION[2], false);
-                if (locationID !== null) {
-                    await ensure_(model, locationID);
-                    const point = model.getElementByLocalID(locationID);
-                    const coords = point?.Coordinates;
-                    if (coords !== void 0 && coords.length >= 2) {
-                        local = [coords[0], coords[1], coords[2] ?? 0];
-                    }
-                }
-            }
-        }
+        const local = relativeID !== null ?
+            await axisPlacementMatrix_(model, relativeID) :
+            IDENTITY_PLACEMENT.slice();
         const parentID = entity.extractReferenceLocalID(LOCAL_PLACEMENT_REL_TO[0], LOCAL_PLACEMENT_REL_TO[1], LOCAL_PLACEMENT_REL_TO[2], true);
         if (parentID === null) {
             cache.set(placementLocalID, local);
             return local;
         }
-        const parent = await placementOrigin_(model, parentID, cache);
-        if (parent === void 0) {
-            cache.set(placementLocalID, local);
-            return local;
-        }
-        const world = [
-            parent[0] + local[0],
-            parent[1] + local[1],
-            parent[2] + local[2],
-        ];
+        const parent = await placementTransform_(model, parentID, cache);
+        const world = parent === void 0 ? local : mat4MultiplyF64(parent, local);
         cache.set(placementLocalID, world);
         return world;
     }
@@ -254,7 +432,19 @@ async function placementOrigin_(model, placementLocalID, cache) {
         return;
     }
 }
-async function productOrigin_(model, localID, cache) {
+/**
+ * @param transform A composed world transform.
+ * @return {[number, number, number]} Its translation column, i.e. where
+ * the placement's own origin lands in world space.
+ */
+function originOf_(transform) {
+    return [
+        transform[TRANSLATION[0]],
+        transform[TRANSLATION[1]],
+        transform[TRANSLATION[2]],
+    ];
+}
+async function productTransform_(model, localID, cache) {
     await ensure_(model, localID);
     const entity = model.getElementByLocalID(localID);
     if (entity === void 0) {
@@ -264,7 +454,7 @@ async function productOrigin_(model, localID, cache) {
     if (placementID === null) {
         return;
     }
-    return placementOrigin_(model, placementID, cache);
+    return placementTransform_(model, placementID, cache);
 }
 /**
  * Walk the IFC spatial tree and emit AABB imposters for Share.
@@ -463,13 +653,16 @@ export async function emitSpatialStructureImposters(model, onMesh, coordinationM
             queue.push(childID);
         }
     }
-    const originCache = new Map();
+    const placementCache = new Map();
     for (const node of nodes.values()) {
         try {
             // IfcProject is an IfcContext, not an IfcProduct — field 5 is
             // not ObjectPlacement.
             if (node.typeID !== EntityTypesIfc.IFCPROJECT) {
-                node.origin = await productOrigin_(model, node.localID, originCache);
+                node.placement =
+                    await productTransform_(model, node.localID, placementCache);
+                node.origin = node.placement !== void 0 ?
+                    originOf_(node.placement) : void 0;
             }
             if (STOREY_TYPES.has(node.typeID)) {
                 await ensure_(model, node.localID);
@@ -492,9 +685,9 @@ export async function emitSpatialStructureImposters(model, onMesh, coordinationM
         const origins = [];
         for (let i = 0; i < products.length && origins.length < PRODUCT_SAMPLE; i += stride) {
             try {
-                const origin = await productOrigin_(model, products[i], originCache);
-                if (origin !== void 0) {
-                    origins.push(origin);
+                const transform = await productTransform_(model, products[i], placementCache);
+                if (transform !== void 0) {
+                    origins.push(originOf_(transform));
                 }
             }
             catch {
@@ -564,7 +757,7 @@ export async function emitSpatialStructureImposters(model, onMesh, coordinationM
             // own placement Z; the two only part on files that leave every
             // storey placement on the datum.
             const storeyZ0 = STOREY_TYPES.has(node.typeID) && node.elevation !== void 0 ?
-                storeyDatumZ_(localID, nodes, parentOf) + node.elevation : void 0;
+                storeyFloorZ_(localID, node.elevation, nodes, parentOf) : void 0;
             if (node.origin !== void 0) {
                 // The placement point contributes this node's XY footprint. For
                 // a storey with an Elevation its Z is the DATUM, not its
@@ -597,7 +790,12 @@ export async function emitSpatialStructureImposters(model, onMesh, coordinationM
                 // elevation), but a file that parks every storey placement on
                 // the building datum and carries the height only in Elevation
                 // would then collapse all of its plates onto one Z. Storey
-                // HEIGHTS stay on elevation deltas — datum-invariant either way.
+                // HEIGHTS stay on elevation deltas — datum-invariant either way,
+                // though on a datum tilted out of plumb they over-thicken the
+                // plate by 1/cos(tilt) (the floor Z is tilt-correct; see
+                // storeyFloorZ_). Left alone: the sample-derived height fallback
+                // is already a world-Z span, so one scale cannot serve both, and
+                // a tilted building has no horizontal storeys to plate anyway.
                 const z0 = storeyZ0 ?? node.origin?.[2] ?? box.min[2];
                 const z1 = height !== void 0 ? z0 + height : box.max[2];
                 box = {
@@ -659,33 +857,44 @@ export async function emitSpatialStructureImposters(model, onMesh, coordinationM
     return emitted;
 }
 /**
- * World Z of the datum an IfcBuildingStorey's `Elevation` is measured
- * from — the nearest ancestor with a resolved placement, i.e. the
- * IfcBuilding in a well-formed file.
+ * World Z of an IfcBuildingStorey's floor: `Elevation` measured up the
+ * datum's own +Z from the datum's world origin, where the datum is the
+ * nearest ancestor with a resolved placement (the IfcBuilding in a
+ * well-formed file).
+ *
+ * Elevation is a length along the datum's Z, not along world Z, so the
+ * datum's whole transform is needed and not just its height — on a
+ * building tilted out of plumb the two differ by `cos(tilt)`. Only the
+ * Z component is taken, because that is all the banding uses: the plate
+ * keeps the XY footprint its placement and contained samples give it.
+ * A tilted building's storeys are not horizontal anyway, so the
+ * axis-aligned plate is an approximation there by construction — this
+ * just stops it being an approximation on the *height* as well.
  *
- * Zero when nothing up the chain resolved one, which reads Elevation as
- * world-relative. That is the pre-fix behaviour and the only remaining
- * fallback: a storey whose ancestors have no usable placement gives us
- * nothing better to anchor on.
+ * Falls back to a world-relative Elevation (datum at zero, +Z up) when
+ * nothing up the chain resolved a placement: the pre-fix behaviour, and
+ * the only thing left to anchor on.
  *
  * @param localID The storey.
+ * @param elevation The storey's `Elevation`, in source units.
  * @param nodes All walked nodes.
  * @param parentOf Child -> parent.
- * @return {number} The datum's world Z.
+ * @return {number} The floor's world Z.
  */
-function storeyDatumZ_(localID, nodes, parentOf) {
+function storeyFloorZ_(localID, elevation, nodes, parentOf) {
     let id = parentOf.get(localID);
     // Bounded rather than while-truthy: parentOf is built by a BFS and so
     // should be acyclic, but this module treats the aggregate graph as
     // untrusted everywhere else too (see `computing` in aabbOf).
     for (let hops = 0; id !== void 0 && hops <= nodes.size; ++hops) {
-        const originZ = nodes.get(id)?.origin?.[2];
-        if (originZ !== void 0) {
-            return originZ;
+        const placement = nodes.get(id)?.placement;
+        if (placement !== void 0) {
+            return placement[TRANSLATION[2]] +
+                elevation * placement[LOCAL_Z_WORLD_Z];
         }
         id = parentOf.get(id);
     }
-    return 0;
+    return elevation;
 }
 /**
  * The durable coordination frame, derived the way the preview channels
@@ -699,9 +908,9 @@ function storeyDatumZ_(localID, nodes, parentOf) {
  * Best-effort by construction, and the failure has two shapes. Beyond
  * LARGE_COORDINATE_BUDGET_M both sides snap to COORDINATION_SNAP_M and
  * agree as long as the spatial root and the first geometry share a grid
- * cell. Worse: the anchor comes from `placementOrigin_`, which sums
- * IfcLocalPlacement translations and never looks at geometry — so a file
- * that keeps identity placements and bakes absolute coordinates into the
+ * cell. Worse: the anchor comes from `placementTransform_`, which reads
+ * IfcLocalPlacement chains and never looks at geometry — so a file that
+ * keeps identity placements and bakes absolute coordinates into the
  * vertices (civil/GIS exports do this) has a root box near zero and gets
  * no recentre at all, while the durable walk anchors tens of km out and
  * does. That is a full site-offset, not a one-cell disagreement. Whenever