@bldrs-ai/conway 1.389.1221 → 1.394.1504

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

@@ -1,21 +1,65 @@
 import { ConwayGeometry, } from "../../index.js";
+import IfcStepModel from "../../ifc/ifc_step_model.js";
+import { WindowedStepBufferProvider } from "../../step/step_buffer_provider.js";
 import * as glmatrix from "gl-matrix";
+import { IDENTITY_MAT4, LARGE_COORDINATE_BUDGET_M, TRANSLATION_X, TRANSLATION_Y, TRANSLATION_Z, composeTransformF64, deriveCoordinationF64 } from "./coordination_f64.js";
 import { IfcProperties } from "./ifc_properties.js";
 import Logger from "../../logging/logger.js";
 import { ProgressTracker } from "../../core/progress.js";
 import { formatModelLine } from "../../core/progress_log.js";
+import { wasmHeapView, } from "../../core/wasm_heap.js";
 import { extractModelInfo } from "../../loaders/loading_utilities.js";
 import IfcStepParser from "../../ifc/ifc_step_parser.js";
 import ParsingBuffer from "../../parsing/parsing_buffer.js";
+import { BufferByteSource, StoreByteSource } from "../../step/parsing/byte_source.js";
+import { buildIndexStreamingAsync, } from "../../step/parsing/streaming_index_builder.js";
+import { ColumnarIndexSink } from "../../step/parsing/columnar_index.js";
+import { StorePreviewChannel } from "./store_preview_channel.js";
+import { ifcPreviewAdapter, StreamedPreviewChannel, } from "./streamed_preview_channel.js";
+import { emitSpatialStructureImposters } from "./spatial_imposter.js";
 import { ExtractResult } from "../../index.js";
 import { IfcGeometryExtraction } from "../../ifc/ifc_geometry_extraction.js";
 import { ParseResult } from "../../index.js";
+import { releaseScratchParsingBuffer } from "../../step/parsing/step_deserialization_functions.js";
 import Memory from "../../memory/memory.js";
 import { FromRawLineData } from "./ifc2x4_helper.js";
 import { shimIfcEntityMap, shimIfcEntityReverseMap } from "./shim_schema_mapping.js";
 import { EntityTypesIfcCount } from "../../ifc/ifc4_gen/entity_types_ifc.gen.js";
-import { IfcProduct, IfcRoot } from "../../ifc/ifc4_gen/index.js";
+import { IfcProduct, IfcRelAggregates, IfcRoot } from "../../ifc/ifc4_gen/index.js";
 import { CanonicalMeshType } from "../../index.js";
+// Batch size used when a whole-model consumer (streamAllMeshes) drains
+// a deferred model's remaining products synchronously.
+const DEFERRED_DRAIN_BATCH = 256;
+/* Moving-window size for the streamed columnar parse (matches the
+ * ifc_stream_open default; the window bounds parse-time scratch, not
+ * the source buffer, which the model keeps resident here). */
+// eslint-disable-next-line no-magic-numbers
+const STREAMED_PARSE_POOL_BYTES = 1024 * 1024;
+/* Store-backed open pays an await per window slide (`File.slice`).
+ * 1 MiB on an 860 MB IFC is ~1700 trips; 16 MiB is ~100. The window
+ * is scratch — it does not stay resident after parse. */
+// eslint-disable-next-line no-magic-numbers
+const STORE_PARSE_POOL_BYTES = 16 * 1024 * 1024;
+// eslint-disable-next-line no-magic-numbers
+const BYTES_PER_MIB = 1024 * 1024;
+/**
+ * The coordination frame spatial-structure imposters compose under.
+ *
+ * With COORDINATE_TO_ORIGIN on, that is whatever frame the preview
+ * channel latched (undefined when it never captured an instance — the
+ * imposter walk then derives an equivalent one itself). With it OFF the
+ * durable capture composes against a bare identity, so the plates must
+ * too, or they would be the only thing in the scene in metres and Y-up.
+ *
+ * @param settings The open's loader settings.
+ * @param previewCoordination The preview channel's latched frame.
+ * @return {ArrayLike<number> | undefined} The frame, or undefined to let
+ * the imposter walk derive one.
+ */
+function imposterCoordination(settings, previewCoordination) {
+    return settings?.COORDINATE_TO_ORIGIN === true ?
+        previewCoordination : IDENTITY_MAT4;
+}
 /**
  * The proxy for IFC from the shim.
  */
@@ -31,6 +75,44 @@ export class IfcApiProxyIfc {
         this.wasmModule = wasmModule;
         this.settings = settings;
         this.fs = undefined;
+        /** Was this model opened without extraction (DEFER_GEOMETRY)? */
+        this.deferredMode_ = false;
+        /** True once beginPhase('geometry') has fired for this deferred pump. */
+        this.geometryPhaseStarted_ = false;
+        /**
+         * Deferred capture watermarks: entity localID -> how many of its
+         * placed instances (in scene-walk order) have been captured. Shared
+         * (mapped) geometry attributes instances to an entity from OTHER
+         * products' extractions, so an entity's instance set grows across
+         * batches - the watermark makes each instance captured exactly once,
+         * in the same order the classic single walk would process it.
+         */
+        this.demandCapturedCounts_ = new Map();
+        /** Cursor into demandProducts_ — products before it are extracted. */
+        this.demandCursor_ = 0;
+        /** Wall-clock split of the store-backed batch pump (profile script). */
+        this.extractProfile_ = {
+            prefetchMs: 0,
+            extractMs: 0,
+            releaseMs: 0,
+            batches: 0,
+            lastPins: 0,
+            pinMax: 0,
+        };
+        /** Cursor into demandAggregates_ — items before it are extracted. */
+        this.demandAggregatesCursor_ = 0;
+        /**
+         * True while an adopted preview-channel coordination frame is still
+         * unvalidated against the durable walk's first geometry. A model can
+         * carry geometry in more than one frame (ISSUE_129: a local-scale
+         * annotation previews first while the body is georeferenced at
+         * ~8.3e6 m), so a frame anchored on the wrong unit leaves the body
+         * raw — the Share#1634 browser-vs-node divergence, which was really
+         * preview-vs-no-preview. streamNewMeshes_ clears this on its first
+         * geometry, re-deriving from it when the adopted frame fails the
+         * large-coordinate budget.
+         */
+        this.demandCoordinationFromPreview_ = false;
         this._isCoordinated = false;
         this.linearScalingFactor = 1;
         this.identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
@@ -43,12 +125,18 @@ export class IfcApiProxyIfc {
          * Contains all the logic and methods regarding properties, psets, qsets, etc.
          */
         this.properties = new IfcProperties(this);
+        /** Native geometry freed (releaseGeometry) — scene walks would touch
+         * freed objects, so mesh serving degrades to the accumulated maps. */
+        this.released_ = false;
         // The cooperative path (createAsync) parses/extracts before construction
         // so it can await mid-load; the classic OpenModel path does it here,
         // synchronously. Both share the tail below (mesh vectors, statistics).
         const loadState = precomputed ??
             IfcApiProxyIfc.parseAndExtract(modelID, data, new ConwayGeometry(wasmModule), settings);
         this.conwaywasm = loadState.conwaywasm;
+        this.conwayGeometry_ = loadState.conwayGeometry;
+        this.deferredMode_ = loadState.deferred === true;
+        this.progressTracker_ = loadState.tracker;
         const statistics = Logger.getStatistics(modelID);
         const { allTimeStart, stepHeader, model, scene, conwayGeometry, geometryTimeInMs: executionTimeInMs, } = loadState;
         // get linear scaling factor
@@ -124,6 +212,18 @@ export class IfcApiProxyIfc {
         ];
         // save settings
         this.settings = settings;
+        // Deferred opens whose preview channel already established the
+        // coordination frame: adopt it, so the durable capture skips its own
+        // derivation and places exactly where the preview did. (Internal
+        // only — getCoordinationMatrix stays identity, see
+        // demandCoordination_.)
+        if (this.deferredMode_ && loadState.previewCoordinationMatrix !== void 0) {
+            this.demandCoordination_ = loadState.previewCoordinationMatrix;
+            this._isCoordinated = true;
+            // Adopted, not derived: validate against the durable walk's first
+            // geometry before trusting it (see demandCoordinationFromPreview_).
+            this.demandCoordinationFromPreview_ = true;
+        }
         let FILE_NAME = stepHeader.headers.get("FILE_NAME");
         if (FILE_NAME !== void 0) {
             // strip start / end parenthesis
@@ -167,6 +267,62 @@ export class IfcApiProxyIfc {
         const loadState = await IfcApiProxyIfc.parseAndExtractAsync(modelID, data, new ConwayGeometry(wasmModule), settings);
         return new IfcApiProxyIfc(modelID, data, wasmModule, settings, loadState);
     }
+    /**
+     * Streamed-open construction (conway extension, used by
+     * OpenModelStreamed): the parse runs through the streaming columnar
+     * indexer, so the model's index is columnar from birth and the
+     * per-record object phase — the dominant JS-heap cost of the classic
+     * parse on large models — never exists. Geometry extraction is the
+     * same cooperative path OpenModelAsync uses, and everything
+     * downstream (meshes, properties, SpillModelSource) behaves
+     * identically to a classic open.
+     *
+     * @param modelID The model ID being opened.
+     * @param data The IFC data buffer.
+     * @param wasmModule The wasm module.
+     * @param settings Loader settings (ON_PROGRESS is honored).
+     * @return {Promise<IfcApiProxyIfc>} The constructed proxy.
+     */
+    static async createStreamed(modelID, data, wasmModule, settings) {
+        const loadState = await IfcApiProxyIfc.parseColumnarAndExtractAsync(modelID, data, new ConwayGeometry(wasmModule), settings);
+        return new IfcApiProxyIfc(modelID, data, wasmModule, settings, loadState);
+    }
+    /**
+     * Deferred-geometry streamed open (conway extension; slice A of
+     * Share's demand/tiled rendering — design doc
+     * demand-tiled-rendering.md): identical streamed columnar parse, but
+     * NO geometry extraction happens at open. The proxy registers with an
+     * empty scene wired to the demand-extraction seam; callers then pump
+     * {@link extractGeometryBatch} to extract products in file-order
+     * batches, receiving each batch's meshes incrementally — the scene,
+     * properties, and spatial structure work from the first batch.
+     *
+     * @param modelID The model ID being opened.
+     * @param data The IFC data buffer.
+     * @param wasmModule The wasm module.
+     * @param settings Loader settings (ON_PROGRESS is honored for parse).
+     * @return {Promise<IfcApiProxyIfc>} The constructed proxy.
+     */
+    static async createDeferred(modelID, data, wasmModule, settings) {
+        const loadState = await IfcApiProxyIfc.parseColumnarAndExtractAsync(modelID, data, new ConwayGeometry(wasmModule), settings, true);
+        return new IfcApiProxyIfc(modelID, data, wasmModule, settings, loadState);
+    }
+    /**
+     * M1b store-backed open: parse through a moving window over `store`
+     * and keep the model windowed from birth — the source is never held
+     * as one `ArrayBuffer`. Geometry extract pages product closures
+     * through {@link extractGeometryBatchAsync}.
+     *
+     * @param modelID The model ID being opened.
+     * @param store External store holding the source bytes.
+     * @param wasmModule The wasm module.
+     * @param settings Loader settings (ON_PROGRESS is honored).
+     * @return {Promise<IfcApiProxyIfc>} The constructed proxy.
+     */
+    static async createFromStore(modelID, store, wasmModule, settings) {
+        const loadState = await IfcApiProxyIfc.parseColumnarFromStore(modelID, store, new ConwayGeometry(wasmModule), settings, settings?.DEFER_GEOMETRY === true);
+        return new IfcApiProxyIfc(modelID, new Uint8Array(0), wasmModule, settings, loadState);
+    }
     /**
      * Log + record the header parse result on the model statistics.
      *
@@ -342,6 +498,334 @@ export class IfcApiProxyIfc {
             geometryTimeInMs: endTime - startTime,
         };
     }
+    /**
+     * Streamed twin of parseAndExtractAsync: the data parse runs through
+     * the streaming columnar indexer over a moving window instead of the
+     * per-record object parse, so the index is columnar from birth (no
+     * object phase). The source buffer stays resident behind the model —
+     * extraction and synchronous property reads behave exactly like a
+     * classic open, and `spillSourceToExternalStore` works afterwards as
+     * usual.
+     *
+     * The columnar build is cooperative (periodic event-loop yields, like
+     * the classic parseDataBlockAsync) with absolute byte-cursor progress
+     * ticks, and extraction is cooperative too — the streamed open keeps
+     * the repaint/no-stall property of OpenModelAsync (#301 §2). Throws
+     * when the streamed parse is anything but COMPLETE — the caller
+     * (OpenModelStreamed) falls back to the classic path, which tolerates
+     * recoverable parses.
+     *
+     * @param modelID The model ID being opened.
+     * @param data The IFC data buffer.
+     * @param conwaywasm The conway geometry wasm wrapper.
+     * @param settings Loader settings (ON_PROGRESS is honored).
+     * @return {Promise<IfcProxyLoadState>} Everything the constructor tail needs.
+     */
+    static async parseColumnarAndExtractAsync(modelID, data, conwaywasm, settings, deferGeometry = false) {
+        const tracker = IfcApiProxyIfc.makeTracker(settings);
+        const allTimeStart = Date.now();
+        const parser = IfcStepParser.Instance;
+        const bufferInput = new ParsingBuffer(data);
+        tracker?.beginPhase("headerParse", "bytes", data.length);
+        // Header parsed standalone first so the model line fires before the
+        // full parse, exactly like the classic path (the columnar build
+        // re-reads the tiny header internally; the cost is negligible).
+        const [stepHeader, result0] = parser.parseHeader(bufferInput);
+        Logger.createStatistics(modelID);
+        const statistics = Logger.getStatistics(modelID);
+        IfcApiProxyIfc.reportHeaderParseResult(result0, bufferInput, modelID);
+        const modelInfo = extractModelInfo(stepHeader, data.length);
+        Logger.info(formatModelLine(modelInfo));
+        settings?.ON_MODEL_INFO?.(modelInfo);
+        tracker?.beginPhase("dataParse", "bytes", data.length);
+        const parseTick = tracker !== void 0 ?
+            (cursorBytes) => tracker.update(cursorBytes) : void 0;
+        const parseStartTime = Date.now();
+        // Inline twin of buildColumnarIndexStreamingAsync — the sink is created
+        // here so the parse-time preview channel (slice A2) can watch it grow
+        // and snapshot prefix models between the parse's cooperative yields.
+        const sink = new ColumnarIndexSink();
+        const previewChannel = deferGeometry && settings?.ON_PREVIEW_MESH !== void 0 ?
+            new StreamedPreviewChannel(data, conwaywasm, sink, ifcPreviewAdapter(), settings.COORDINATE_TO_ORIGIN === true, settings.ON_PREVIEW_MESH) : void 0;
+        previewChannel?.start();
+        // Channel ticks ride the parse's own progress callback (see
+        // maybeTickInline) — timer ticks alone starve under the parse's
+        // scheduler-priority yields in browsers.
+        const parseProgress = previewChannel !== void 0 ?
+            (cursorBytes) => {
+                parseTick?.(cursorBytes);
+                previewChannel.maybeTickInline();
+            } : parseTick;
+        let result;
+        try {
+            ({ result } = await buildIndexStreamingAsync(new BufferByteSource(data), parser, STREAMED_PARSE_POOL_BYTES, void 0, sink, parseProgress));
+        }
+        finally {
+            previewChannel?.stop();
+        }
+        const columns = sink.finalize();
+        const parseEndTime = Date.now();
+        tracker?.endPhase(data.length);
+        if (result !== ParseResult.COMPLETE) {
+            Logger.warning(`[OpenModelStreamed]: streamed parse result ${result}`);
+            statistics?.setLoadStatus("PARSE_FAIL");
+            throw new Error("Streamed parse did not complete");
+        }
+        const model = new IfcStepModel(data, columns);
+        statistics?.setParseTime(parseEndTime - parseStartTime);
+        const conwayGeometry = new IfcGeometryExtraction(conwaywasm, model);
+        // Deferred mode (createDeferred): no extraction now — prime the
+        // per-product demand seam and hand back the (empty) live scene the
+        // batch pump populates. `scene` is the same object streamAllMeshes
+        // walks, so meshes appear to consumers as batches extract.
+        if (deferGeometry) {
+            conwayGeometry.prepareDemandExtraction();
+            if (settings?.ON_PREVIEW_MESH !== void 0) {
+                try {
+                    // After prepareDemandExtraction, not before: the plates are
+                    // composed under the coordination frame, whose scaling comes
+                    // from getLinearScalingFactor() — which reads 1 until the
+                    // extraction maps (and with them the unit assignment) are
+                    // prepared. Both calls run in the same synchronous stretch
+                    // after the parse, so nothing reaches the screen any later.
+                    await emitSpatialStructureImposters(model, settings.ON_PREVIEW_MESH, imposterCoordination(settings, previewChannel?.coordinationMatrix), conwayGeometry.getLinearScalingFactor());
+                }
+                catch {
+                    // Spatial imposters must never break a deferred open.
+                }
+            }
+            statistics?.setProductCount(model.typeCount(IfcProduct));
+            return {
+                conwaywasm,
+                deferred: true,
+                // Pin the durable pump's coordination to the preview channel's
+                // (derived from the same first instance with the same math), so
+                // preview payloads and durable meshes share one frame.
+                previewCoordinationMatrix: previewChannel?.coordinationMatrix,
+                allTimeStart,
+                stepHeader,
+                model,
+                scene: conwayGeometry.scene,
+                conwayGeometry,
+                geometryTimeInMs: 0,
+                tracker,
+            };
+        }
+        tracker?.beginPhase("geometry", "products");
+        const geometryTick = tracker !== void 0 ?
+            (completed, total) => {
+                tracker.setPhaseTotal(total);
+                tracker.update(completed);
+            } : void 0;
+        const startTime = Date.now();
+        const [extractionResult, scene] = await conwayGeometry.extractIFCGeometryDataAsync(geometryTick);
+        const endTime = Date.now();
+        tracker?.endPhase();
+        if (extractionResult !== ExtractResult.COMPLETE) {
+            Logger.error("[OpenModelStreamed]: Error extracting geometry, exiting...");
+            statistics?.setLoadStatus("FAIL");
+            throw new Error("Couldn't extract model");
+        }
+        statistics?.setProductCount(model.typeCount(IfcProduct));
+        statistics?.setGeometryTypeCounts(conwayGeometry.geometryTypeCounts);
+        return {
+            conwaywasm,
+            allTimeStart,
+            stepHeader,
+            model,
+            scene,
+            conwayGeometry,
+            geometryTimeInMs: endTime - startTime,
+        };
+    }
+    /**
+     * Windowed-from-birth twin of parseColumnarAndExtractAsync: the
+     * source stays in `store`, parse windows are filled through it, and
+     * the model never holds a resident copy. During parse a bounded
+     * prefix extract pages product closures from the store and emits
+     * placed meshes (same COORDINATE_TO_ORIGIN frame as durable). After
+     * the index exists, spatial-structure AABB plates go out too.
+     * Deferred opens page prep closures before prepareDemandExtraction;
+     * non-deferred opens drain the demand pump with per-product residency.
+     *
+     * @param modelID The model ID being opened.
+     * @param store External store holding the source bytes.
+     * @param conwaywasm The conway geometry wasm wrapper.
+     * @param settings Loader settings (ON_PROGRESS is honored).
+     * @param deferGeometry Skip extraction (Share demand pump).
+     * @return {Promise<IfcProxyLoadState>} Everything the constructor tail needs.
+     */
+    static async parseColumnarFromStore(modelID, store, conwaywasm, settings, deferGeometry = false) {
+        const tracker = IfcApiProxyIfc.makeTracker(settings);
+        const allTimeStart = Date.now();
+        const parser = IfcStepParser.Instance;
+        const fileSize = store.byteLength;
+        Logger.createStatistics(modelID);
+        const statistics = Logger.getStatistics(modelID);
+        tracker?.beginPhase("dataParse", "bytes", fileSize);
+        const parseTick = tracker !== void 0 ?
+            (cursorBytes) => tracker.update(cursorBytes) : void 0;
+        const parseStartTime = Date.now();
+        // Live sink so the store preview channel can snapshot a prefix
+        // mid-parse without a resident source buffer.
+        const sink = new ColumnarIndexSink();
+        const storePreview = settings?.ON_PREVIEW_MESH !== void 0 ?
+            new StorePreviewChannel(store, sink, conwaywasm, settings.COORDINATE_TO_ORIGIN === true, settings.ON_PREVIEW_MESH) : void 0;
+        const parseProgress = async (cursorBytes) => {
+            parseTick?.(cursorBytes);
+            await storePreview?.maybeTickAsync();
+        };
+        // One windowed pass: header comes out of the same slide as the
+        // data block so we do not hold a second 16 MiB prefix copy.
+        let result;
+        let stepHeader;
+        try {
+            ({ result, header: stepHeader } = await buildIndexStreamingAsync(new StoreByteSource(store), parser, STORE_PARSE_POOL_BYTES, void 0, sink, parseProgress));
+            if (storePreview !== void 0) {
+                await storePreview.flushAsync();
+            }
+        }
+        finally {
+            storePreview?.stop();
+        }
+        const columns = sink.finalize();
+        // Parse window is out of scope; drop the module scratch in case a
+        // numeric read during the slide left it pointed at that 16 MiB view.
+        releaseScratchParsingBuffer();
+        IfcApiProxyIfc.reportHeaderParseResult(result, new ParsingBuffer(new Uint8Array(0)), modelID);
+        const modelInfo = extractModelInfo(stepHeader, fileSize);
+        Logger.info(formatModelLine(modelInfo));
+        settings?.ON_MODEL_INFO?.(modelInfo);
+        const parseEndTime = Date.now();
+        tracker?.endPhase(fileSize);
+        if (result !== ParseResult.COMPLETE) {
+            Logger.warning(`[OpenModelStream]: streamed parse result ${result}`);
+            statistics?.setLoadStatus("PARSE_FAIL");
+            throw new Error("Streamed parse did not complete");
+        }
+        const provider = new WindowedStepBufferProvider(store);
+        const model = new IfcStepModel(void 0, columns, provider);
+        statistics?.setParseTime(parseEndTime - parseStartTime);
+        const conwayGeometry = new IfcGeometryExtraction(conwaywasm, model);
+        const prepPins = await conwayGeometry.ensureResidentForDemandPrep();
+        try {
+            conwayGeometry.prepareDemandExtraction();
+        }
+        finally {
+            model.releaseSourceViews(prepPins);
+            model.unpinLocalIDs(prepPins);
+        }
+        if (settings?.ON_PREVIEW_MESH !== void 0) {
+            try {
+                // Emitted after demand prep so getLinearScalingFactor() reports
+                // the model's real units — see the resident path's note.
+                await emitSpatialStructureImposters(model, settings.ON_PREVIEW_MESH, imposterCoordination(settings, storePreview?.coordinationMatrix), conwayGeometry.getLinearScalingFactor());
+            }
+            catch {
+                // Spatial imposters must never break a store-backed open.
+            }
+        }
+        if (deferGeometry) {
+            statistics?.setProductCount(model.typeCount(IfcProduct));
+            return {
+                conwaywasm,
+                deferred: true,
+                previewCoordinationMatrix: storePreview?.coordinationMatrix,
+                allTimeStart,
+                stepHeader,
+                model,
+                scene: conwayGeometry.scene,
+                conwayGeometry,
+                geometryTimeInMs: 0,
+                tracker,
+            };
+        }
+        tracker?.beginPhase("geometry", "products");
+        const startTime = Date.now();
+        const aggregateTargets = conwayGeometry.aggregateTargetLocalIDs();
+        let completed = 0;
+        tracker?.setPhaseTotal(model.typeCount(IfcProduct));
+        // eslint-disable-next-line no-magic-numbers
+        const EXTRACT_BATCH = 8;
+        const pending = [];
+        const flushProductBatch = async () => {
+            if (pending.length === 0) {
+                return;
+            }
+            const pins = new Set();
+            const leafSpans = [];
+            try {
+                await Promise.all(pending.map((localID) => conwayGeometry.ensureResidentForProductExtract(localID, pins, leafSpans)));
+                for (const localID of pending) {
+                    try {
+                        conwayGeometry.extractProductGeometryByLocalID(localID);
+                    }
+                    catch (error) {
+                        Logger.error(`Error extracting product localID ${localID}: ` +
+                            `${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    model.releaseSourceViews(pins);
+                    ++completed;
+                }
+            }
+            finally {
+                model.releaseSourceViews(pins);
+                model.unpinLocalIDs(pins);
+                for (const span of leafSpans) {
+                    model.unpinAddressRange(span.address, span.length);
+                }
+                pending.length = 0;
+            }
+            tracker?.update(completed, {
+                residentSourceMb: model.residentSourceBytes / BYTES_PER_MIB,
+            });
+        };
+        for (const product of model.types(IfcProduct)) {
+            if (aggregateTargets.has(product.localID)) {
+                continue;
+            }
+            pending.push(product.localID);
+            if (pending.length >= EXTRACT_BATCH) {
+                await flushProductBatch();
+            }
+        }
+        await flushProductBatch();
+        for (const relAggregate of model.types(IfcRelAggregates)) {
+            const leafSpans = [];
+            const pins = await conwayGeometry.ensureResidentForAggregateExtract(relAggregate, leafSpans);
+            try {
+                conwayGeometry.extractRelAggregateGeometry(relAggregate);
+            }
+            catch (error) {
+                Logger.error(`Error extracting aggregate ${relAggregate.expressID}: ` +
+                    `${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                model.releaseSourceViews(pins);
+                model.unpinLocalIDs(pins);
+                for (const span of leafSpans) {
+                    model.unpinAddressRange(span.address, span.length);
+                }
+            }
+            ++completed;
+            tracker?.update(completed, {
+                residentSourceMb: model.residentSourceBytes / BYTES_PER_MIB,
+            });
+        }
+        const endTime = Date.now();
+        tracker?.endPhase();
+        statistics?.setProductCount(model.typeCount(IfcProduct));
+        statistics?.setGeometryTypeCounts(conwayGeometry.geometryTypeCounts);
+        return {
+            conwaywasm,
+            allTimeStart,
+            stepHeader,
+            model,
+            scene: conwayGeometry.scene,
+            conwayGeometry,
+            geometryTimeInMs: endTime - startTime,
+        };
+    }
     /**
      *
      * @param input - FILE_HEADER from step header
@@ -412,8 +896,7 @@ export class IfcApiProxyIfc {
                     return clone;
                 }
                 else {
-                    Logger.error(`[GetGeometry]: Geometry Object not found for expressID: 
-          ${geometryExpressID}`);
+                    Logger.error(`[GetGeometry]: Geometry Object not found for expressID: \n          ${geometryExpressID}`);
                 }
             }
         }
@@ -506,6 +989,14 @@ export class IfcApiProxyIfc {
     get sourceIsExternal() {
         return this.model[0].isSourceExternal;
     }
+    /**
+     * Store-backed pump split (prefetch / extract / release).
+     *
+     * @return {object} Cumulative milliseconds and pin telemetry.
+     */
+    get extractProfile() {
+        return this.extractProfile_;
+    }
     /**
      * Release the resident source buffer and serve subsequent record
      * reads through fixed-size windows paged in from the given external
@@ -767,6 +1258,16 @@ export class IfcApiProxyIfc {
         /* eslint-enable no-unused-vars */
         return Array.from(coordinationMatrix);
     }
+    /**
+     * The coordination frame actually applied to emitted placements —
+     * the derived (or validated adopted) recenter, identity when no
+     * recenter ran. See ifc_api_model_passthrough.getAppliedCoordination.
+     *
+     * @return {Array<number>} column-major mat4
+     */
+    getAppliedCoordination() {
+        return [...(this.demandCoordination_ ?? this.identity)];
+    }
     /**
      *
      * @param ptr
@@ -793,8 +1294,15 @@ export class IfcApiProxyIfc {
      * @return {Float32Array | Uint32Array}
      */
     getSubArray(heap, startPtr, sizeBytes) {
-        // eslint-disable-next-line no-magic-numbers, no-mixed-operators
-        return heap.subarray(startPtr / 4, startPtr / 4 + sizeBytes).slice(0);
+        // `heap` stays in the signature because web-ifc's API puts it there, but
+        // it is now read only for its element type. The view itself is rebuilt
+        // over the module's CURRENT heap buffer: a caller-held HEAPF32/HEAPU32 can
+        // be bound to a pre-growth buffer on the MT build, and subarray() on such
+        // a view clamps the window silently and returns short data rather than
+        // failing (#485, and see core/wasm_heap.ts).
+        const arrayType = heap.constructor;
+        // slice(0) as before, so the result outlives the next call into wasm.
+        return wasmHeapView(this.wasmModule, arrayType, startPtr, sizeBytes).slice(0);
     }
     /**
      * Closes a model and frees all related memory
@@ -804,12 +1312,467 @@ export class IfcApiProxyIfc {
     closeModel() {
         // Null operation.
     }
+    /**
+     * Free this model's native geometry (conway extension): every
+     * canonical mesh the extraction produced plus the GetGeometry map.
+     * Call AFTER the consumer has built its own scene from the meshes —
+     * subsequent GetGeometry calls return an empty dummy. On a deferred
+     * model whose pump has not drained, this is a no-op (releasing would
+     * break the remaining extraction).
+     *
+     * The wasm heap never shrinks, but freed pages are reused: repeated
+     * loads in one tab plateau instead of stacking whole model scenes
+     * (the multi-load crash).
+     *
+     * @return {boolean} True when geometry was released.
+     */
+    releaseGeometry() {
+        if (this.deferredMode_ &&
+            this.demandProducts_ !== void 0 &&
+            (this.demandCursor_ < this.demandProducts_.length ||
+                this.demandAggregatesCursor_ <
+                    (this.demandAggregates_?.length ?? 0))) {
+            Logger.warning("[ReleaseModelGeometry]: deferred pump not drained \u2014 not releasing");
+            return false;
+        }
+        const model = this.model[0];
+        const localIDs = [];
+        for (const mesh of model.geometry) {
+            localIDs.push(mesh.localID);
+        }
+        for (const localID of localIDs) {
+            try {
+                model.geometry.delete(localID);
+            }
+            catch {
+                // Never let a free break a loaded model.
+            }
+        }
+        // The GetGeometry map holds references to the now-freed natives —
+        // clear it so lookups degrade to the dummy instead of touching them.
+        this.model[3].clear();
+        this.released_ = true;
+        return true;
+    }
+    /**
+     * Deferred-mode batch pump (conway extension; Share demand/tiled
+     * rendering slice A): extract the next `batchSize` products (file
+     * order) through the per-product demand seam and emit THIS BATCH's
+     * meshes through `meshCallback` — the incremental twin of
+     * streamAllMeshes. Placed-geometry math (coordination, scaling,
+     * centering) is identical; the shared meshMap is updated so
+     * getFlatMesh keeps working. Call repeatedly until `remaining` is 0.
+     *
+     * Requires a model opened with deferred geometry
+     * (`OpenModelStreamed(data, {..., DEFER_GEOMETRY: true})`); on a
+     * fully-extracted model this is a no-op returning remaining 0.
+     *
+     * @param batchSize Max products to extract this call (min 1).
+     * @param meshCallback Receives each newly-extracted product's mesh.
+     * @return {object} `{extracted, remaining}` — products processed this
+     * call and products still pending.
+     */
+    extractGeometryBatch(batchSize, meshCallback) {
+        // Fully-extracted opens have nothing to pump — re-running the
+        // per-product extraction on them would duplicate scene work.
+        if (!this.deferredMode_) {
+            return { extracted: 0, remaining: 0 };
+        }
+        if (this.model[0].isSourceExternal) {
+            throw new Error("ExtractGeometryBatch is synchronous and cannot page a windowed " +
+                "source \u2014 use ExtractGeometryBatchAsync");
+        }
+        this.ensureDemandWorklists_();
+        return this.pumpGeometryBatch_(batchSize, meshCallback);
+    }
+    /**
+     * Async twin of {@link extractGeometryBatch}: pages each product's
+     * `#ref` closure before extracting it, so a model opened through
+     * {@link IfcApiProxyIfc.createFromStore} (windowed from birth) can
+     * be pumped. Safe on a resident source (prefetch is a no-op).
+     *
+     * @param batchSize Max products to extract this call (min 1).
+     * @param meshCallback Receives each newly-extracted product's mesh.
+     * @return {Promise<object>} `{extracted, remaining}`.
+     */
+    async extractGeometryBatchAsync(batchSize, meshCallback) {
+        if (!this.deferredMode_) {
+            return { extracted: 0, remaining: 0 };
+        }
+        this.ensureDemandWorklists_();
+        if (!this.model[0].isSourceExternal) {
+            return this.pumpGeometryBatch_(batchSize, meshCallback);
+        }
+        const products = this.demandProducts_ ?? [];
+        const aggregates = this.demandAggregates_ ?? [];
+        const totalWork = products.length + aggregates.length;
+        const budget = Math.max(batchSize, 1);
+        let extracted = 0;
+        if (this.progressTracker_ !== void 0 && !this.geometryPhaseStarted_) {
+            this.progressTracker_.beginPhase("geometry", "products", totalWork);
+            this.geometryPhaseStarted_ = true;
+        }
+        const productEnd = Math.min(this.demandCursor_ + budget, products.length);
+        const batchIDs = products.slice(this.demandCursor_, productEnd);
+        if (batchIDs.length > 0) {
+            // One pin set for the batch so mapped geometry stays resident
+            // across the instances that share it.
+            const pins = new Set();
+            const leafSpans = [];
+            const profile = this.extractProfile_;
+            try {
+                const prefetchStart = Date.now();
+                await Promise.all(batchIDs.map((localID) => this.conwayGeometry_.ensureResidentForProductExtract(localID, pins, leafSpans)));
+                profile.prefetchMs += Date.now() - prefetchStart;
+                if (pins.size > profile.pinMax) {
+                    profile.pinMax = pins.size;
+                }
+                profile.lastPins = pins.size;
+                const extractStart = Date.now();
+                for (const localID of batchIDs) {
+                    try {
+                        if (this.conwayGeometry_.extractProductGeometryByLocalID(localID)) {
+                            ++extracted;
+                        }
+                    }
+                    catch (error) {
+                        Logger.error(`Error extracting product localID ${localID}: ` +
+                            `${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    // Drop JS views after each product; chunks stay pinned for
+                    // the rest of the batch so rematerialise is a cache hit.
+                    this.model[0].releaseSourceViews(pins);
+                }
+                profile.extractMs += Date.now() - extractStart;
+                this.demandCursor_ = productEnd;
+            }
+            finally {
+                const releaseStart = Date.now();
+                this.model[0].releaseSourceViews(pins);
+                this.model[0].unpinLocalIDs(pins);
+                for (const span of leafSpans) {
+                    this.model[0].unpinAddressRange(span.address, span.length);
+                }
+                profile.releaseMs += Date.now() - releaseStart;
+                profile.batches++;
+            }
+        }
+        if (this.demandCursor_ >= products.length &&
+            this.demandAggregatesCursor_ < aggregates.length) {
+            const aggregatesEnd = Math.min(this.demandAggregatesCursor_ + (budget - extracted), aggregates.length);
+            for (; this.demandAggregatesCursor_ < aggregatesEnd; ++this.demandAggregatesCursor_) {
+                const relAggregate = aggregates[this.demandAggregatesCursor_];
+                const leafSpans = [];
+                const pins = await this.conwayGeometry_.ensureResidentForAggregateExtract(relAggregate, leafSpans);
+                try {
+                    this.conwayGeometry_.extractRelAggregateGeometry(relAggregate);
+                    ++extracted;
+                }
+                catch (error) {
+                    Logger.error(`Error extracting aggregate ${relAggregate.expressID}: ` +
+                        `${error instanceof Error ? error.message : String(error)}`);
+                }
+                finally {
+                    this.model[0].releaseSourceViews(pins);
+                    this.model[0].unpinLocalIDs(pins);
+                    for (const span of leafSpans) {
+                        this.model[0].unpinAddressRange(span.address, span.length);
+                    }
+                }
+            }
+        }
+        if (meshCallback !== void 0) {
+            this.streamNewMeshes_(meshCallback);
+        }
+        const remaining = (products.length - this.demandCursor_) +
+            (aggregates.length - this.demandAggregatesCursor_);
+        const windowMb = this.model[0].residentSourceBytes / BYTES_PER_MIB;
+        if (this.progressTracker_ !== void 0) {
+            const completed = totalWork - remaining;
+            if (remaining === 0) {
+                this.progressTracker_.update(completed, { residentSourceMb: windowMb });
+                this.progressTracker_.endPhase(totalWork);
+            }
+            else {
+                this.progressTracker_.update(completed, { residentSourceMb: windowMb });
+            }
+        }
+        return { extracted, remaining };
+    }
+    /**
+     * Enumerate the deferred worklists once (file-order products, then
+     * rel-aggregates). Shared by the sync and async pumps.
+     */
+    ensureDemandWorklists_() {
+        if (this.demandProducts_ !== void 0) {
+            return;
+        }
+        // Aggregate-target products are extracted ONLY by the
+        // rel-aggregates pass below (with the relating object's master
+        // rel-voids), never by the per-product pass: extracting them here
+        // first would emit their instances with the uncut/placeholder
+        // content and the pass's later replacement would never reach an
+        // incremental consumer (it copies at delivery), while the pass's
+        // second scene instance would draw over the first (see
+        // aggregateTargetLocalIDs).
+        const aggregateTargets = this.conwayGeometry_.aggregateTargetLocalIDs();
+        const products = [];
+        for (const product of this.model[0].types(IfcProduct)) {
+            if (aggregateTargets.has(product.localID)) {
+                continue;
+            }
+            products.push(product.localID);
+        }
+        const aggregates = [];
+        for (const relAggregate of this.model[0].types(IfcRelAggregates)) {
+            aggregates.push(relAggregate);
+        }
+        this.demandProducts_ = products;
+        this.demandAggregates_ = aggregates;
+        this.demandCursor_ = 0;
+        this.demandAggregatesCursor_ = 0;
+    }
+    /**
+     * Synchronous extract of the next batch. Caller must have paged
+     * ranges if the source is windowed.
+     *
+     * @param batchSize Max products this call.
+     * @param meshCallback Optional mesh consumer.
+     * @return {object} `{extracted, remaining}`.
+     */
+    pumpGeometryBatch_(batchSize, meshCallback) {
+        const products = this.demandProducts_ ?? [];
+        const aggregates = this.demandAggregates_ ?? [];
+        const totalWork = products.length + aggregates.length;
+        if (this.progressTracker_ !== void 0 && !this.geometryPhaseStarted_) {
+            this.progressTracker_.beginPhase("geometry", "products", totalWork);
+            this.geometryPhaseStarted_ = true;
+        }
+        const budget = Math.max(batchSize, 1);
+        const end = Math.min(this.demandCursor_ + budget, products.length);
+        let extracted = 0;
+        for (; this.demandCursor_ < end; ++this.demandCursor_) {
+            const localID = products[this.demandCursor_];
+            if (this.conwayGeometry_.extractProductGeometryByLocalID(localID)) {
+                ++extracted;
+            }
+        }
+        // Classic parity: once the product walk completes, pump the
+        // whole-model walk's second (rel-aggregates master-voids) pass with
+        // the same per-call budget — batch-by-batch, not as one end-of-load
+        // stall — so aggregate parts stream in cut, exactly once, with
+        // final content (see demandAggregates_).
+        if (this.demandCursor_ >= products.length &&
+            this.demandAggregatesCursor_ < aggregates.length) {
+            const aggregatesEnd = Math.min(this.demandAggregatesCursor_ + (budget - extracted), aggregates.length);
+            for (; this.demandAggregatesCursor_ < aggregatesEnd; ++this.demandAggregatesCursor_) {
+                this.conwayGeometry_.extractRelAggregateGeometry(aggregates[this.demandAggregatesCursor_]);
+                ++extracted;
+            }
+        }
+        if (meshCallback !== void 0) {
+            this.streamNewMeshes_(meshCallback);
+        }
+        const remaining = (products.length - this.demandCursor_) +
+            (aggregates.length - this.demandAggregatesCursor_);
+        if (this.progressTracker_ !== void 0) {
+            const completed = totalWork - remaining;
+            if (remaining === 0) {
+                this.progressTracker_.endPhase(totalWork);
+            }
+            else {
+                this.progressTracker_.update(completed);
+            }
+        }
+        return {
+            extracted,
+            remaining,
+        };
+    }
+    /**
+     * Walk the scene and emit every not-yet-captured placed instance as
+     * per-entity DELTA FlatMeshes — the incremental core of
+     * streamAllMeshes with identical placed-geometry math, processed in
+     * walk order exactly once per instance (per-entity watermarks). An
+     * entity re-emits with only its NEW instances when shared/mapped
+     * geometry attributes more to it in later batches; consumers render
+     * deltas additively (the shared meshMap still accumulates each
+     * entity's FULL vector, so getFlatMesh stays whole-model correct).
+     *
+     * Also fixes a latent multi-call bug: the derived coordination
+     * matrix is remembered (demandCoordination_), so later batches place
+     * with the SAME coordination the first batch established
+     * (streamAllMeshes never needed this — it runs once). It is NOT
+     * exposed through getCoordinationMatrix, which keeps the classic
+     * identity contract consumers stamp onto assembled models.
+     *
+     * @param meshCallback Receives one delta FlatMesh per entity that
+     * gained instances this call.
+     */
+    streamNewMeshes_(meshCallback) {
+        // Released models: the scene's natives are freed — nothing new can
+        // exist to capture, and walking would touch freed objects.
+        if (this.released_) {
+            return;
+        }
+        const [model, scene, meshMap, geometryMaterialTransformMap] = this.model;
+        let coordinationMatrix = this.demandCoordination_ ?? glmatrix.mat4.create();
+        const seenThisPass = new Map();
+        const deltas = new Map();
+        // eslint-disable-next-line no-unused-vars
+        for (const [_, nativeTransform, geometry, material, entity] of scene.walk()) {
+            if (entity?.localID === void 0 || entity.expressID === void 0) {
+                continue;
+            }
+            // Per-entity walk position vs watermark: instances before the
+            // watermark were captured in an earlier call (append-only walk
+            // order makes the count a stable cursor).
+            const walkIndex = seenThisPass.get(entity.localID) ?? 0;
+            seenThisPass.set(entity.localID, walkIndex + 1);
+            if (walkIndex < (this.demandCapturedCounts_.get(entity.localID) ?? 0)) {
+                continue;
+            }
+            if (geometry.type !== CanonicalMeshType.BUFFER_GEOMETRY || geometry.temporary) {
+                continue;
+            }
+            const material_ = material ?? {
+                name: "",
+                // eslint-disable-next-line no-magic-numbers
+                baseColor: [0.8, 0.8, 0.8, 1],
+                // eslint-disable-next-line no-magic-numbers
+                legacyColor: [0.8, 0.8, 0.8, 1],
+                doubleSided: true,
+                blend: 0,
+            };
+            const validatePreviewFrame = this.demandCoordinationFromPreview_ &&
+                this.settings?.COORDINATE_TO_ORIGIN === true;
+            let nativePt;
+            if ((!this._isCoordinated || validatePreviewFrame) &&
+                this.settings?.COORDINATE_TO_ORIGIN) {
+                nativePt = geometry.geometry.getPoint(0);
+            }
+            // normalize() recenters the shared geometry buffer (side effect)
+            // and returns the local centre used to place it.
+            const center = geometry.geometry.normalize();
+            const expressID = model.getElementByLocalID(geometry.localID)?.expressID;
+            // Full-precision float64 placement straight from the wasm boundary
+            // (glm::dmat4). NOT re-truncated through a gl-matrix Float32Array —
+            // the recentre math runs in double precision (see coordination_f64).
+            const geometryTransform = nativeTransform?.getValues();
+            if (!this._isCoordinated && this.settings?.COORDINATE_TO_ORIGIN) {
+                const derived = deriveCoordinationF64(geometryTransform, nativePt, this.NormalizeMat, this.linearScalingFactor);
+                coordinationMatrix = derived;
+                // Persist for every later batch (internal only — see
+                // demandCoordination_'s identity-contract note).
+                this.demandCoordination_ = derived;
+                this._isCoordinated = true;
+            }
+            else if (validatePreviewFrame) {
+                // One-shot check of an adopted preview frame against the durable
+                // walk's first geometry: when the composed placement still lands
+                // beyond the large-coordinate budget, the preview anchored in a
+                // different frame than the model body (Share#1634) — re-derive
+                // from this geometry, the classic path's anchor. The throwaway
+                // preview scene may briefly disagree; the durable model must
+                // place like the classic open.
+                this.demandCoordinationFromPreview_ = false;
+                const probe = composeTransformF64(coordinationMatrix, geometryTransform, center);
+                const magnitude = Math.max(Math.abs(probe[TRANSLATION_X]), Math.abs(probe[TRANSLATION_Y]), Math.abs(probe[TRANSLATION_Z]));
+                if (magnitude > LARGE_COORDINATE_BUDGET_M) {
+                    const derived = deriveCoordinationF64(geometryTransform, nativePt, this.NormalizeMat, this.linearScalingFactor);
+                    coordinationMatrix = derived;
+                    this.demandCoordination_ = derived;
+                    Logger.info(`[deferred] preview coordination frame rejected (first durable ` +
+                        `placement at ${Math.round(magnitude)}m); re-derived from the durable anchor`);
+                }
+            }
+            const newTransformArr = composeTransformF64(coordinationMatrix, geometryTransform, center);
+            geometryMaterialTransformMap.set(expressID, [geometry.geometry, material_, newTransformArr]);
+            const color = {
+                x: material_.legacyColor[0],
+                y: material_.legacyColor[1],
+                z: material_.legacyColor[2],
+                w: material_.legacyColor[3],
+            };
+            const placed = {
+                color,
+                geometryExpressID: expressID,
+                flatTransformation: newTransformArr,
+            };
+            let mesh = meshMap.get(entity.expressID);
+            if (mesh === void 0) {
+                const placedArray = new Array();
+                const placedVector = {
+                    get: (index) => placedArray[index] ?? placed,
+                    size: () => placedArray.length,
+                    push: (parameter) => {
+                        placedArray.push(parameter);
+                    },
+                };
+                const flatMesh = {
+                    geometries: placedVector,
+                    expressID: entity.expressID,
+                };
+                mesh = [placedVector, flatMesh];
+                meshMap.set(entity.expressID, mesh);
+            }
+            mesh[0].push(placed);
+            mesh[1].geometries = mesh[0];
+            this.demandCapturedCounts_.set(entity.localID, (this.demandCapturedCounts_.get(entity.localID) ?? 0) + 1);
+            let delta = deltas.get(entity.expressID);
+            if (delta === void 0) {
+                delta = [];
+                deltas.set(entity.expressID, delta);
+            }
+            delta.push(placed);
+        }
+        const vectorFlatMesh = this.model[4];
+        for (const [expressID, placedList] of deltas) {
+            const placedVector = {
+                get: (index) => placedList[index] ?? placedList[0],
+                size: () => placedList.length,
+                push: (parameter) => {
+                    placedList.push(parameter);
+                },
+            };
+            const deltaMesh = { geometries: placedVector, expressID };
+            vectorFlatMesh.push(deltaMesh);
+            meshCallback(deltaMesh);
+        }
+    }
     /**
      *
      * @param modelID
      * @param meshCallback
      */
     streamAllMeshes(meshCallback) {
+        // Released models: the natives behind the scene are freed — serve
+        // the accumulated per-entity meshes instead of re-walking.
+        if (this.released_ && !this.deferredMode_) {
+            const [, , meshMap, , vectorFlatMesh] = this.model;
+            meshMap.forEach((mesh) => {
+                vectorFlatMesh.push(mesh[1]);
+                meshCallback(mesh[1]);
+            });
+            return;
+        }
+        // Deferred models: the delta capture has already populated (or will
+        // populate) the shared meshMap — re-running the classic walk would
+        // push every instance a second time. Pump any remainder to
+        // completion and serve the accumulated full per-entity meshes.
+        if (this.deferredMode_) {
+            const noCallback = void 0;
+            while (this.extractGeometryBatch(DEFERRED_DRAIN_BATCH, noCallback).remaining > 0) {
+                // draining
+            }
+            this.streamNewMeshes_(() => { });
+            const [, , meshMap, , vectorFlatMesh] = this.model;
+            meshMap.forEach((mesh) => {
+                vectorFlatMesh.push(mesh[1]);
+                meshCallback(mesh[1]);
+            });
+            return;
+        }
         const [model, scene, meshMap, geometryMaterialTransformMap, vectorFlatMesh] = this.model;
         let coordinationMatrix = this.model[5];
         // eslint-disable-next-line no-unused-vars
@@ -834,62 +1797,23 @@ export class IfcApiProxyIfc {
                 if (!this._isCoordinated && this.settings?.COORDINATE_TO_ORIGIN) {
                     nativePt = geometry.geometry.getPoint(0);
                 }
-                // extract center
-                const geomCenter = glmatrix.vec3.create();
+                // normalize() recenters the geometry buffer (side effect) and
+                // returns the local centre used to place it.
                 const center = geometry.geometry.normalize();
-                geomCenter[0] = center.x;
-                geomCenter[1] = center.y;
-                geomCenter[2] = center.z;
-                // Create a translation matrix from geom.min
-                const translationMatrixGeomMin = glmatrix.mat4.create();
-                glmatrix.mat4.fromTranslation(translationMatrixGeomMin, geomCenter);
                 // create PlacedGeometry
                 const expressID = model.getElementByLocalID(geometry.localID)?.expressID;
+                // Full-precision float64 placement straight from the wasm boundary
+                // (glm::dmat4) — never truncated through a gl-matrix Float32Array;
+                // the recentre math runs in double precision (see coordination_f64).
                 const geometryTransform = nativeTransform?.getValues();
-                let newMatrix;
-                if (geometryTransform !== void 0) {
-                    newMatrix = glmatrix.mat4.fromValues(geometryTransform[0], geometryTransform[1], geometryTransform[2], geometryTransform[3], geometryTransform[4], geometryTransform[5], geometryTransform[6], geometryTransform[7], geometryTransform[8], geometryTransform[9], geometryTransform[10], geometryTransform[11], geometryTransform[12], geometryTransform[13], geometryTransform[14], geometryTransform[15]);
-                }
-                else {
-                    // set to identity if no transform found
-                    newMatrix = glmatrix.mat4.create();
-                }
                 if (!this._isCoordinated && this.settings?.COORDINATE_TO_ORIGIN) {
-                    // coordinate the geometry to the origin
-                    const pt = [nativePt.x, nativePt.y, nativePt.z];
-                    // Transform the point by the matrix.
-                    const transformedPt = glmatrix.vec4.create();
-                    glmatrix.vec4.transformMat4(transformedPt, [pt[0], pt[1], pt[2], 1], newMatrix);
-                    // Create the translation matrix.
-                    coordinationMatrix = glmatrix.mat4.create();
-                    glmatrix.mat4.fromTranslation(coordinationMatrix, [-transformedPt[0], -transformedPt[1], -transformedPt[2]]);
-                    const scaleMatrix = glmatrix.mat4.create();
-                    // Create a 3D vector for scaling factors
-                    const scaleVec = glmatrix.vec3.fromValues(this.linearScalingFactor, this.linearScalingFactor, this.linearScalingFactor);
-                    // Scale the matrix
-                    glmatrix.mat4.scale(scaleMatrix, scaleMatrix, scaleVec);
-                    glmatrix.mat4.multiply(coordinationMatrix, this.NormalizeMat, coordinationMatrix);
-                    glmatrix.mat4.multiply(coordinationMatrix, scaleMatrix, coordinationMatrix);
+                    coordinationMatrix = deriveCoordinationF64(geometryTransform, nativePt, this.NormalizeMat, this.linearScalingFactor);
+                    // Persisted for getAppliedCoordination (Share#1634): report
+                    // the real applied frame, not the classic silent identity.
+                    this.demandCoordination_ = Array.from(coordinationMatrix);
                     this._isCoordinated = true;
                 }
-                // extract color
-                const newTransform = glmatrix.mat4.create();
-                // Create a 4x4 identity matrix
-                const scaleMatrix = glmatrix.mat4.create();
-                // Create a 3D vector for scaling factors
-                const scaleVec = glmatrix.vec3.fromValues(this.linearScalingFactor, this.linearScalingFactor, this.linearScalingFactor);
-                // Scale the matrix
-                glmatrix.mat4.scale(scaleMatrix, scaleMatrix, scaleVec);
-                // Perform the matrix multiplications
-                if (newMatrix !== void 0) {
-                    glmatrix.mat4.multiply(newTransform, coordinationMatrix, newMatrix);
-                    glmatrix.mat4.multiply(newTransform, newTransform, translationMatrixGeomMin);
-                }
-                else {
-                    glmatrix.mat4.multiply(newTransform, coordinationMatrix, newTransform);
-                    glmatrix.mat4.multiply(newTransform, newTransform, translationMatrixGeomMin);
-                }
-                const newTransformArr = Array.from(newTransform);
+                const newTransformArr = composeTransformF64(coordinationMatrix, geometryTransform, center);
                 geometryMaterialTransformMap.set(expressID, [geometry.geometry, material_, newTransformArr]);
                 if (entity?.localID !== void 0) {
                     if (entity?.expressID !== void 0) {
@@ -1003,62 +1927,23 @@ export class IfcApiProxyIfc {
                 if (!this._isCoordinated && this.settings?.COORDINATE_TO_ORIGIN) {
                     nativePt = geometry.geometry.getPoint(0);
                 }
-                // extract center
-                const geomCenter = glmatrix.vec3.create();
+                // normalize() recenters the geometry buffer (side effect) and
+                // returns the local centre used to place it.
                 const center = geometry.geometry.normalize();
-                geomCenter[0] = center.x;
-                geomCenter[1] = center.y;
-                geomCenter[2] = center.z;
-                // Create a translation matrix from geom.min
-                const translationMatrixGeomMin = glmatrix.mat4.create();
-                glmatrix.mat4.fromTranslation(translationMatrixGeomMin, geomCenter);
                 // create PlacedGeometry
                 const expressID = model.getElementByLocalID(geometry.localID)?.expressID;
+                // Full-precision float64 placement straight from the wasm boundary
+                // (glm::dmat4) — never truncated through a gl-matrix Float32Array;
+                // the recentre math runs in double precision (see coordination_f64).
                 const geometryTransform = nativeTransform?.getValues();
-                let newMatrix;
-                if (geometryTransform !== void 0) {
-                    newMatrix = glmatrix.mat4.fromValues(geometryTransform[0], geometryTransform[1], geometryTransform[2], geometryTransform[3], geometryTransform[4], geometryTransform[5], geometryTransform[6], geometryTransform[7], geometryTransform[8], geometryTransform[9], geometryTransform[10], geometryTransform[11], geometryTransform[12], geometryTransform[13], geometryTransform[14], geometryTransform[15]);
-                }
                 if (!this._isCoordinated && this.settings?.COORDINATE_TO_ORIGIN) {
-                    // coordinate the geometry to the origin
-                    // Assuming geom.GetPoint(0) returns a glm::dvec3, i.e., a 3D vector.
-                    // In TypeScript, you can represent it as number[] or Float64Array.
                     Logger.info("Setting up coordinationMatrix");
-                    // const nativePt = geometry.geometry.GetPoint(0)
-                    const pt = [nativePt.x, nativePt.y, nativePt.z];
-                    // Transform the point by the matrix.
-                    const transformedPt = glmatrix.vec4.create();
-                    glmatrix.vec4.transformMat4(transformedPt, [pt[0], pt[1], pt[2], 1], newMatrix);
-                    // Create the translation matrix.
-                    coordinationMatrix = glmatrix.mat4.create();
-                    glmatrix.mat4.fromTranslation(coordinationMatrix, [-transformedPt[0], -transformedPt[1], -transformedPt[2]]);
-                    const scaleMatrix = glmatrix.mat4.create();
-                    // Create a 3D vector for scaling factors
-                    const scaleVec = glmatrix.vec3.fromValues(this.linearScalingFactor, this.linearScalingFactor, this.linearScalingFactor);
-                    // Scale the matrix
-                    glmatrix.mat4.scale(scaleMatrix, scaleMatrix, scaleVec);
-                    glmatrix.mat4.multiply(coordinationMatrix, this.NormalizeMat, coordinationMatrix);
-                    glmatrix.mat4.multiply(coordinationMatrix, scaleMatrix, coordinationMatrix);
+                    coordinationMatrix = deriveCoordinationF64(geometryTransform, nativePt, this.NormalizeMat, this.linearScalingFactor);
+                    // Persisted for getAppliedCoordination (Share#1634).
+                    this.demandCoordination_ = Array.from(coordinationMatrix);
                     this._isCoordinated = true;
                 }
-                // extract color
-                const newTransform = glmatrix.mat4.create();
-                // Create a 4x4 identity matrix
-                const scaleMatrix = glmatrix.mat4.create();
-                // Create a 3D vector for scaling factors
-                const scaleVec = glmatrix.vec3.fromValues(this.linearScalingFactor, this.linearScalingFactor, this.linearScalingFactor);
-                // Scale the matrix
-                glmatrix.mat4.scale(scaleMatrix, scaleMatrix, scaleVec);
-                // Perform the matrix multiplications
-                if (newMatrix !== void 0) {
-                    glmatrix.mat4.multiply(newTransform, coordinationMatrix, newMatrix);
-                    glmatrix.mat4.multiply(newTransform, newTransform, translationMatrixGeomMin);
-                }
-                else {
-                    glmatrix.mat4.multiply(newTransform, coordinationMatrix, newTransform);
-                    glmatrix.mat4.multiply(newTransform, newTransform, translationMatrixGeomMin);
-                }
-                const newTransformArr = Array.from(newTransform);
+                const newTransformArr = composeTransformF64(coordinationMatrix, geometryTransform, center);
                 geometryMaterialTransformMap.set(expressID, [geometry.geometry, material_, newTransformArr]);
                 if (entity?.localID !== void 0) {
                     if (entity?.expressID !== void 0) {
@@ -1158,61 +2043,23 @@ export class IfcApiProxyIfc {
                 if (!this._isCoordinated && this.settings?.COORDINATE_TO_ORIGIN) {
                     nativePt = geometry.geometry.getPoint(0);
                 }
-                // extract center
-                const geomCenter = glmatrix.vec3.create();
+                // normalize() recenters the geometry buffer (side effect) and
+                // returns the local centre used to place it.
                 const center = geometry.geometry.normalize();
-                geomCenter[0] = center.x;
-                geomCenter[1] = center.y;
-                geomCenter[2] = center.z;
-                // Create a translation matrix from geom.min
-                const translationMatrixGeomMin = glmatrix.mat4.create();
-                glmatrix.mat4.fromTranslation(translationMatrixGeomMin, geomCenter);
                 // create PlacedGeometry
                 const expressID = model.getElementByLocalID(geometry.localID)?.expressID;
+                // Full-precision float64 placement straight from the wasm boundary
+                // (glm::dmat4) — never truncated through a gl-matrix Float32Array;
+                // the recentre math runs in double precision (see coordination_f64).
                 const geometryTransform = nativeTransform?.getValues();
-                let newMatrix;
-                if (geometryTransform !== void 0) {
-                    newMatrix = glmatrix.mat4.fromValues(geometryTransform[0], geometryTransform[1], geometryTransform[2], geometryTransform[3], geometryTransform[4], geometryTransform[5], geometryTransform[6], geometryTransform[7], geometryTransform[8], geometryTransform[9], geometryTransform[10], geometryTransform[11], geometryTransform[12], geometryTransform[13], geometryTransform[14], geometryTransform[15]);
-                }
                 if (!this._isCoordinated && this.settings?.COORDINATE_TO_ORIGIN) {
-                    // coordinate the geometry to the origin
-                    // Assuming geom.GetPoint(0) returns a glm::dvec3, i.e., a 3D vector.
-                    // In TypeScript, you can represent it as number[] or Float64Array.
                     Logger.info("Setting up coordinationMatrix");
-                    const pt = [nativePt.x, nativePt.y, nativePt.z];
-                    // Transform the point by the matrix.
-                    const transformedPt = glmatrix.vec4.create();
-                    glmatrix.vec4.transformMat4(transformedPt, [pt[0], pt[1], pt[2], 1], newMatrix);
-                    // Create the translation matrix.
-                    coordinationMatrix = glmatrix.mat4.create();
-                    glmatrix.mat4.fromTranslation(coordinationMatrix, [-transformedPt[0], -transformedPt[1], -transformedPt[2]]);
-                    const scaleMatrix = glmatrix.mat4.create();
-                    // Create a 3D vector for scaling factors
-                    const scaleVec = glmatrix.vec3.fromValues(this.linearScalingFactor, this.linearScalingFactor, this.linearScalingFactor);
-                    // Scale the matrix
-                    glmatrix.mat4.scale(scaleMatrix, scaleMatrix, scaleVec);
-                    glmatrix.mat4.multiply(coordinationMatrix, this.NormalizeMat, coordinationMatrix);
-                    glmatrix.mat4.multiply(coordinationMatrix, scaleMatrix, coordinationMatrix);
+                    coordinationMatrix = deriveCoordinationF64(geometryTransform, nativePt, this.NormalizeMat, this.linearScalingFactor);
+                    // Persisted for getAppliedCoordination (Share#1634).
+                    this.demandCoordination_ = Array.from(coordinationMatrix);
                     this._isCoordinated = true;
                 }
-                // extract color
-                const newTransform = glmatrix.mat4.create();
-                // Create a 4x4 identity matrix
-                const scaleMatrix = glmatrix.mat4.create();
-                // Create a 3D vector for scaling factors
-                const scaleVec = glmatrix.vec3.fromValues(this.linearScalingFactor, this.linearScalingFactor, this.linearScalingFactor);
-                // Scale the matrix
-                glmatrix.mat4.scale(scaleMatrix, scaleMatrix, scaleVec);
-                // Perform the matrix multiplications
-                if (newMatrix !== void 0) {
-                    glmatrix.mat4.multiply(newTransform, coordinationMatrix, newMatrix);
-                    glmatrix.mat4.multiply(newTransform, newTransform, translationMatrixGeomMin);
-                }
-                else {
-                    glmatrix.mat4.multiply(newTransform, coordinationMatrix, newTransform);
-                    glmatrix.mat4.multiply(newTransform, newTransform, translationMatrixGeomMin);
-                }
-                const newTransformArr = Array.from(newTransform);
+                const newTransformArr = composeTransformF64(coordinationMatrix, geometryTransform, center);
                 geometryMaterialTransformMap.set(expressID, [geometry.geometry, material_, newTransformArr]);
                 if (entity?.localID !== void 0) {
                     if (entity?.expressID !== void 0) {