@bldrs-ai/conway 1.389.1221 → 1.394.1504

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

@@ -1,18 +1,37 @@
 import { ConwayGeometry, } from "../../index.js";
 import * as glmatrix from "gl-matrix";
+import { LARGE_COORDINATE_BUDGET_M, TRANSLATION_X, TRANSLATION_Y, TRANSLATION_Z, composeTransformF64, deriveCoordinationF64 } from "./coordination_f64.js";
 import Logger from "../../logging/logger.js";
 import ParsingBuffer from "../../parsing/parsing_buffer.js";
 import { ExtractResult } from "../../index.js";
 import { ParseResult } from "../../index.js";
 import Memory from "../../memory/memory.js";
 import { CanonicalMeshType } from "../../index.js";
+import AP214StepModel from "../../AP214E3_2010/ap214_step_model.js";
 import { AP214GeometryExtraction } from "../../AP214E3_2010/ap214_geometry_extraction.js";
 import AP214StepParser from "../../AP214E3_2010/ap214_step_parser.js";
 import { AP214Properties } from "./ap214_properties.js";
 import { EntityTypesAP214Count } from "../../AP214E3_2010/AP214E3_2010_gen/entity_types_ap214.gen.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 { BufferByteSource } from "../../step/parsing/byte_source.js";
+import { ColumnarIndexSink } from "../../step/parsing/columnar_index.js";
+import { buildIndexStreamingAsync, } from "../../step/parsing/streaming_index_builder.js";
+import { ap214PreviewAdapter, StreamedPreviewChannel, } from "./streamed_preview_channel.js";
+/* Moving-window size for the streamed columnar parse (matches the IFC
+ * proxy; 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;
+// Units drained per call when a whole-model consumer (streamAllMeshes)
+// finishes a deferred model synchronously.
+const DEFERRED_DRAIN_BATCH_AP214 = 256;
+// Divisor mapping consumer batch sizes (tuned for IFC's per-product
+// granularity) onto AP214's chunkier per-part units — see
+// extractGeometryBatch.
+const AP214_UNITS_PER_PRODUCT_BATCH = 16;
 /**
  */
 export class IfcApiProxyAP214 {
@@ -81,6 +100,20 @@ export class IfcApiProxyAP214 {
         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;
+        /** Has finishDemandExtraction run (deferred models, once)? */
+        this.demandFinished_ = false;
+        /**
+         * Deferred capture watermarks: entity localID -> how many of its
+         * placed instances (scene-walk order) have been captured — mirrors
+         * the IFC proxy's delta capture; see its demandCapturedCounts_ note.
+         */
+        this.demandCapturedCounts_ = new Map();
+        /** Unvalidated adopted preview frame — see the IFC proxy twin. */
+        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];
@@ -93,12 +126,18 @@ export class IfcApiProxyAP214 {
          * Contains all the logic and methods regarding properties, psets, qsets, etc.
          */
         this.properties = new AP214Properties(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 ??
             IfcApiProxyAP214.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
@@ -174,6 +213,17 @@ export class IfcApiProxyAP214 {
         ];
         // save settings
         this.settings = settings;
+        // Deferred opens whose preview channel already established the
+        // coordination frame: adopt it so the durable capture places
+        // exactly where the preview did (internal only — see
+        // demandCoordination_).
+        if (this.deferredMode_ && loadState.previewCoordinationMatrix !== void 0) {
+            this.demandCoordination_ = loadState.previewCoordinationMatrix;
+            this._isCoordinated = true;
+            // Adopted, not derived — validated against the durable walk's
+            // first geometry (see the IFC proxy's demandCoordinationFromPreview_).
+            this.demandCoordinationFromPreview_ = true;
+        }
         let FILE_NAME = stepHeader.headers.get("FILE_NAME");
         if (FILE_NAME !== void 0) {
             // strip start / end parenthesis
@@ -220,6 +270,152 @@ export class IfcApiProxyAP214 {
         const loadState = await IfcApiProxyAP214.parseAndExtractAsync(modelID, data, new ConwayGeometry(wasmModule), settings);
         return new IfcApiProxyAP214(modelID, data, wasmModule, settings, loadState);
     }
+    /**
+     * Streamed columnar construction (conway extension, used by
+     * OpenModelStreamed): 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 — the AP214 twin
+     * of IfcApiProxyIfc.createStreamed (STEP demand parity phase 1).
+     * Geometry extraction stays the classic whole-model thunk-tree walk;
+     * the deferred pump and preview channel follow in later phases.
+     * Throws when the streamed parse is anything but COMPLETE — the
+     * factory falls back to the classic open.
+     *
+     * @param modelID The model ID being opened.
+     * @param data The STEP data buffer.
+     * @param wasmModule The wasm module.
+     * @param settings Loader settings (ON_PROGRESS / ON_MODEL_INFO honored).
+     * @return {Promise<IfcApiProxyAP214>} The constructed proxy.
+     */
+    static async createStreamed(modelID, data, wasmModule, settings) {
+        const loadState = await IfcApiProxyAP214.parseColumnarAndExtractAsync(modelID, data, new ConwayGeometry(wasmModule), settings);
+        return new IfcApiProxyAP214(modelID, data, wasmModule, settings, loadState);
+    }
+    /**
+     * Deferred streamed construction (STEP demand parity phase 2): the
+     * streamed columnar parse runs, the assembly tree is prepared, but NO
+     * geometry units execute — the batch pump (extractGeometryBatch)
+     * extracts them progressively afterwards. The AP214 twin of
+     * IfcApiProxyIfc.createDeferred.
+     *
+     * @param modelID The model ID being opened.
+     * @param data The STEP data buffer.
+     * @param wasmModule The wasm module.
+     * @param settings Loader settings (ON_PROGRESS / ON_MODEL_INFO honored).
+     * @return {Promise<IfcApiProxyAP214>} The constructed proxy.
+     */
+    static async createDeferred(modelID, data, wasmModule, settings) {
+        const loadState = await IfcApiProxyAP214.parseColumnarAndExtractAsync(modelID, data, new ConwayGeometry(wasmModule), settings, true);
+        return new IfcApiProxyAP214(modelID, data, wasmModule, settings, loadState);
+    }
+    /**
+     * Streamed twin of parseAndExtractAsync: cooperative columnar index
+     * build (periodic event-loop yields, absolute byte-cursor progress),
+     * then the model adopts the columns directly — no per-record object
+     * phase. Mirrors IfcApiProxyIfc.parseColumnarAndExtractAsync minus
+     * the deferred branch.
+     *
+     * @param modelID The model ID being opened.
+     * @param data The STEP data buffer.
+     * @param conwaywasm The conway geometry wasm wrapper.
+     * @param settings Loader settings (ON_PROGRESS / ON_MODEL_INFO honored).
+     * @return {Promise<Ap214ProxyLoadState>} Everything the constructor tail needs.
+     */
+    static async parseColumnarAndExtractAsync(modelID, data, conwaywasm, settings, deferGeometry = false) {
+        const tracker = IfcApiProxyAP214.makeTracker(settings);
+        const allTimeStart = Date.now();
+        const parser = AP214StepParser.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 (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);
+        IfcApiProxyAP214.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();
+        const sink = new ColumnarIndexSink();
+        // Parse-time preview channel (slice A2, STEP demand parity phase
+        // 3): ticks between the cooperative parse's yields, emitting
+        // preview payloads from throwaway prefix extractions.
+        const previewChannel = deferGeometry && settings?.ON_PREVIEW_MESH !== void 0 ?
+            new StreamedPreviewChannel(data, conwaywasm, sink, ap214PreviewAdapter(), 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 AP214StepModel(data, columns);
+        statistics?.setParseTime(parseEndTime - parseStartTime);
+        const conwayGeometry = new AP214GeometryExtraction(conwaywasm, model);
+        // Deferred mode (createDeferred): build the assembly tree and the
+        // ordered unit list but execute nothing — the batch pump populates
+        // the scene progressively. `scene` is the same object the deferred
+        // capture walks, so meshes appear to consumers as units extract.
+        if (deferGeometry) {
+            conwayGeometry.prepareDemandExtraction();
+            return {
+                conwaywasm,
+                deferred: true,
+                previewCoordinationMatrix: previewChannel?.coordinationMatrix,
+                allTimeStart,
+                stepHeader,
+                model,
+                scene: conwayGeometry.scene,
+                conwayGeometry,
+                geometryTimeInMs: 0,
+                tracker,
+            };
+        }
+        // Heartbeat only: the AP214 thunk-tree extraction has no flat
+        // product loop to tick from yet.
+        tracker?.beginPhase("geometry", "products");
+        const startTime = Date.now();
+        const [extractionResult, scene] = conwayGeometry.extractAP214GeometryData();
+        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?.setGeometryTypeCounts(conwayGeometry.geometryTypeCounts);
+        return {
+            conwaywasm,
+            allTimeStart,
+            stepHeader,
+            model,
+            scene,
+            conwayGeometry,
+            geometryTimeInMs: endTime - startTime,
+        };
+    }
     /**
      * Log + record the header parse result on the model statistics.
      *
@@ -662,6 +858,16 @@ export class IfcApiProxyAP214 {
         const coordinationMatrix = this.model[5];
         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
@@ -688,8 +894,15 @@ export class IfcApiProxyAP214 {
      * @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
@@ -704,7 +917,254 @@ export class IfcApiProxyAP214 {
      * @param modelID
      * @param meshCallback
      */
+    /**
+     * Free this model's native geometry (conway extension) — the AP214
+     * twin of the IFC proxy's releaseGeometry; see its note.
+     *
+     * @return {boolean} True when geometry was released.
+     */
+    releaseGeometry() {
+        if (this.deferredMode_ && !this.demandFinished_ &&
+            this.conwayGeometry_.demandUnitCursor < this.conwayGeometry_.demandUnitCount) {
+            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.
+            }
+        }
+        this.model[3].clear();
+        this.released_ = true;
+        return true;
+    }
+    /**
+     * Deferred-mode unit pump (STEP demand parity phase 2; conway
+     * extension consumed through ExtractGeometryBatch): execute the next
+     * `batchSize` assembly-tree units and emit THIS BATCH's meshes as
+     * per-entity DELTA FlatMeshes — the AP214 twin of the IFC proxy's
+     * pump, same delta contract. On a fully-extracted model this is a
+     * no-op returning remaining 0.
+     *
+     * @param batchSize Max units to execute this call (min 1).
+     * @param meshCallback Receives each newly-captured delta mesh.
+     * @return {object} `{extracted, remaining}` — units executed this
+     * call and units still pending.
+     */
+    extractGeometryBatch(batchSize, meshCallback) {
+        if (!this.deferredMode_) {
+            return { extracted: 0, remaining: 0 };
+        }
+        const extraction = this.conwayGeometry_;
+        // Consumers tune batchSize for IFC's fine-grained products (Share
+        // pumps 64); AP214 units are whole parts/subassemblies — orders of
+        // magnitude chunkier (Arty: ~57 units for ~12s of geometry). Scale
+        // the requested batch down so STEP loads stay progressive without
+        // any consumer knowing the schema.
+        const units = Math.max(1, Math.floor(batchSize / AP214_UNITS_PER_PRODUCT_BATCH));
+        if (this.progressTracker_ !== void 0 && !this.geometryPhaseStarted_) {
+            this.progressTracker_.beginPhase("geometry", "products", extraction.demandUnitCount);
+            this.geometryPhaseStarted_ = true;
+        }
+        const extracted = extraction.extractDemandUnitBatch(units);
+        const remaining = extraction.demandUnitCount - extraction.demandUnitCursor;
+        if (this.progressTracker_ !== void 0) {
+            if (remaining === 0) {
+                this.progressTracker_.endPhase(extraction.demandUnitCount);
+            }
+            else {
+                this.progressTracker_.update(extraction.demandUnitCursor);
+            }
+        }
+        if (remaining === 0 && !this.demandFinished_) {
+            this.demandFinished_ = true;
+            extraction.finishDemandExtraction();
+        }
+        if (meshCallback !== void 0) {
+            this.streamNewMeshes_(meshCallback);
+        }
+        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 (bare
+     * coordination x nativeTransform composition, occurrence paths),
+     * processed in walk order exactly once per instance. The shared
+     * meshMap accumulates each entity's FULL vector so getFlatMesh stays
+     * whole-model correct; the derived coordination matrix is remembered
+     * across calls (demandCoordination_) without leaking through
+     * getCoordinationMatrix (classic identity contract).
+     *
+     * @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();
+        const deltaExpressIDs = new Map();
+        // eslint-disable-next-line no-unused-vars
+        for (const [_, nativeTransform, geometry, material, entity, occurrencePath] of scene.walkWithOccurrence()) {
+            if (entity?.localID === void 0 || entity.expressID === void 0) {
+                continue;
+            }
+            const walkIndex = seenThisPass.get(entity.localID) ?? 0;
+            seenThisPass.set(entity.localID, walkIndex + 1);
+            if (walkIndex < (this.demandCapturedCounts_.get(entity.localID) ?? 0)) {
+                continue;
+            }
+            this.demandCapturedCounts_.set(entity.localID, walkIndex + 1);
+            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);
+            }
+            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();
+            if (!this._isCoordinated && this.settings?.COORDINATE_TO_ORIGIN) {
+                const derived = deriveCoordinationF64(geometryTransform, nativePt, this.NormalizeMat, this.linearScalingFactor);
+                coordinationMatrix = derived;
+                this.demandCoordination_ = derived;
+                this._isCoordinated = true;
+            }
+            else if (validatePreviewFrame) {
+                // One-shot adopted-frame validation — see the IFC proxy twin
+                // (Share#1634). Bare composition here: AP214 has no per-leaf
+                // recenter (issue #308).
+                this.demandCoordinationFromPreview_ = false;
+                const probe = composeTransformF64(coordinationMatrix, geometryTransform);
+                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`);
+                }
+            }
+            // Bare composition — no per-leaf recenter (issue #308: AP214
+            // instances share one geometry buffer), matching streamAllMeshes.
+            const newTransformArr = composeTransformF64(coordinationMatrix, geometryTransform);
+            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,
+                occurrencePath,
+            };
+            let mesh = meshMap.get(entity.localID);
+            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.localID, mesh);
+            }
+            mesh[0].push(placed);
+            mesh[1].geometries = mesh[0];
+            let delta = deltas.get(entity.localID);
+            if (delta === void 0) {
+                delta = [];
+                deltas.set(entity.localID, delta);
+                deltaExpressIDs.set(entity.localID, entity.expressID);
+            }
+            delta.push(placed);
+        }
+        const vectorFlatMesh = this.model[4];
+        for (const [localID, placedList] of deltas) {
+            const placedVector = {
+                get: (index) => placedList[index] ?? placedList[0],
+                size: () => placedList.length,
+                push: (parameter) => {
+                    placedList.push(parameter);
+                },
+            };
+            const deltaMesh = {
+                geometries: placedVector,
+                expressID: deltaExpressIDs.get(localID),
+            };
+            vectorFlatMesh.push(deltaMesh);
+            meshCallback(deltaMesh);
+        }
+    }
+    /**
+     *
+     * @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: pump any remainder to completion and serve the
+        // accumulated full per-entity meshes — re-running the classic walk
+        // would push every instance a second time (mirrors the IFC proxy).
+        if (this.deferredMode_) {
+            const noCallback = void 0;
+            while (this.extractGeometryBatch(DEFERRED_DRAIN_BATCH_AP214, 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
@@ -731,57 +1191,24 @@ export class IfcApiProxyAP214 {
                 }
                 // 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);
                     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);
                 // Compose the world transform from the engine's scene transform
-                // (newMatrix = nativeTransform). Geometry vertices stay in their
-                // source-unit local space; nativeTransform maps them to metre world
-                // space — the same bare composition the native consumer
-                // geometry_aggregator uses. The per-leaf geometry.normalize() recenter
-                // was removed: AP214 instances/mapped-items share one geometry buffer,
-                // so normalize() mutated it once and later instances lost their offset
-                // and collapsed toward the origin (issue #308 "port cluster"). The
-                // global coordinationMatrix still carries Y-up + COORDINATE_TO_ORIGIN.
-                if (newMatrix !== void 0) {
-                    glmatrix.mat4.multiply(newTransform, coordinationMatrix, newMatrix);
-                }
-                else {
-                    glmatrix.mat4.copy(newTransform, coordinationMatrix);
-                }
-                const newTransformArr = Array.from(newTransform);
+                // (nativeTransform). Geometry vertices stay in their source-unit local
+                // space; nativeTransform maps them to metre world space — the same
+                // bare composition the native consumer geometry_aggregator uses. The
+                // per-leaf geometry.normalize() recenter was removed: AP214
+                // instances/mapped-items share one geometry buffer, so normalize()
+                // mutated it once and later instances lost their offset and collapsed
+                // toward the origin (issue #308 "port cluster"). The global
+                // coordinationMatrix still carries Y-up + COORDINATE_TO_ORIGIN.
+                const newTransformArr = composeTransformF64(coordinationMatrix, geometryTransform);
                 geometryMaterialTransformMap.set(expressID, [geometry.geometry, material_, newTransformArr]);
                 if (entity?.localID !== void 0) {
                     if (entity?.expressID !== void 0) {
@@ -894,56 +1321,25 @@ export class IfcApiProxyAP214 {
                 }
                 // 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);
                     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);
                 // Compose the world transform from the engine's scene transform
-                // (newMatrix = nativeTransform). Geometry vertices stay in their
-                // source-unit local space; nativeTransform maps them to metre world
-                // space — the same bare composition the native consumer
-                // geometry_aggregator uses. The per-leaf geometry.normalize() recenter
-                // was removed: AP214 instances/mapped-items share one geometry buffer,
-                // so normalize() mutated it once and later instances lost their offset
-                // and collapsed toward the origin (issue #308 "port cluster"). The
-                // global coordinationMatrix still carries Y-up + COORDINATE_TO_ORIGIN.
-                if (newMatrix !== void 0) {
-                    glmatrix.mat4.multiply(newTransform, coordinationMatrix, newMatrix);
-                }
-                else {
-                    glmatrix.mat4.copy(newTransform, coordinationMatrix);
-                }
-                const newTransformArr = Array.from(newTransform);
+                // (nativeTransform). Geometry vertices stay in their source-unit local
+                // space; nativeTransform maps them to metre world space — the same
+                // bare composition the native consumer geometry_aggregator uses. The
+                // per-leaf geometry.normalize() recenter was removed: AP214
+                // instances/mapped-items share one geometry buffer, so normalize()
+                // mutated it once and later instances lost their offset and collapsed
+                // toward the origin (issue #308 "port cluster"). The global
+                // coordinationMatrix still carries Y-up + COORDINATE_TO_ORIGIN.
+                const newTransformArr = composeTransformF64(coordinationMatrix, geometryTransform);
                 geometryMaterialTransformMap.set(expressID, [geometry.geometry, material_, newTransformArr]);
                 if (entity?.localID !== void 0) {
                     if (entity?.expressID !== void 0) {