@bldrs-ai/conway 1.389.1221 → 1.394.1504

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

@@ -1,6 +1,7 @@
-import { ConwayGeometry, } from "../../index.js";
+import { ConwayGeometry, setModulePrefix, } from "../../index.js";
 import { versionString } from "../../version/version.js";
 import Logger, { LogLevel as ConwayLogLevel } from "../../logging/logger.js";
+import { wasmHeapView, } from "../../core/wasm_heap.js";
 import Environment from "../../utilities/environment.js";
 import * as glmatrix from "gl-matrix";
 import { IfcApiModelPassthroughFactory } from "./ifc_api_model_passthrough_factory.js";
@@ -36,6 +37,34 @@ const CONWAY_LOG_LEVEL_BY_WEBIFC = {
     [LogLevel.LOG_LEVEL_ERROR]: ConwayLogLevel.ERROR,
     [LogLevel.LOG_LEVEL_OFF]: ConwayLogLevel.OFF,
 };
+// The directory conway-geom's web init locates wasm from when no
+// embedder path is configured — also the conventional serve location
+// (Share copies Dist/* there at build time).
+const DEFAULT_WEB_WASM_DIRECTORY = "/static/js/";
+/**
+ * Normalize an embedder wasm directory (the SetWasmPath value) to the
+ * absolute site path the web engine modules are served from — the
+ * runtime module prefix isolated (multithreaded) contexts import the
+ * engine from. Web wasm paths are site-root-relative by convention
+ * ('./static/js/'); missing input falls back to the same '/static/js/'
+ * directory conway-geom's web init already uses to locate wasm.
+ *
+ * @param wasmPath The embedder-configured wasm directory, if any.
+ * @return {string} Absolute directory with a trailing slash.
+ */
+export function webWasmDirectory(wasmPath) {
+    let directory = wasmPath ?? "";
+    if (directory === "") {
+        return DEFAULT_WEB_WASM_DIRECTORY;
+    }
+    if (directory.startsWith("./")) {
+        directory = directory.substring(1);
+    }
+    else if (!directory.startsWith("/")) {
+        directory = `/${directory}`;
+    }
+    return directory.endsWith("/") ? directory : `${directory}/`;
+}
 /**
  * @return {number} current time in ms
  */
@@ -83,6 +112,19 @@ export class IfcAPI {
         Environment.checkEnvironment();
         Logger.initializeWasmCallbacks();
         Logger.info(versionString);
+        // Cross-origin-isolated web contexts select the multithreaded wasm,
+        // whose pthread workers resolve their worker script from the engine
+        // module's own import.meta.url. A bundler-inlined copy of the glue
+        // gives workers a wrong URL (the worker script 404s and MT init dies
+        // with a bare error Event — Share #1610). Setting a runtime module
+        // prefix makes conway-geom import the engine module from the
+        // directory it is actually served from, so import.meta.url — and
+        // therefore the worker script URL — is correct. Web wasm paths are
+        // site-root-relative by convention; no-op outside isolated windows.
+        if (typeof window !== "undefined" &&
+            window.crossOriginIsolated === true) {
+            setModulePrefix(webWasmDirectory(this.wasmPath));
+        }
         const locateFileHandler = (path, prefix) => {
             // when the wasm module requests the wasm file, we redirect to include the user specified path
             if (path.endsWith(".wasm")) {
@@ -144,6 +186,60 @@ export class IfcAPI {
         this.models.set(modelIdResult, result);
         return modelIdResult;
     }
+    /**
+     * Streamed-open variant of OpenModelAsync (conway extension;
+     * feature-detect with typeof api.OpenModelStreamed === 'function').
+     * IFC input parses through the streaming columnar indexer, so the
+     * model's record index is columnar from birth and the classic
+     * per-record object phase — the dominant JS-heap cost of parsing
+     * large models — never exists. Everything downstream is identical to
+     * OpenModelAsync: same cooperative geometry extraction, same
+     * meshes/properties surface, and SpillModelSource works afterwards
+     * as usual.
+     *
+     * Never does worse than OpenModelAsync: non-IFC formats and any
+     * streamed-parse failure fall back to the classic path internally,
+     * so -1 here means the classic open would have failed too.
+     *
+     * @param data containing IFC data (bytes)
+     * @param settings settings for loading the model
+     * @return {Promise<number>} model ID
+     */
+    async OpenModelStreamed(data, settings) {
+        // Reserve the ID before the first await — see OpenModelAsync.
+        const modelIdResult = this.globalModelIDCounter++;
+        const result = await IfcApiModelPassthroughFactory.fromStreamed(modelIdResult, data, this.wasmModule, settings);
+        if (result === void 0) {
+            return -1;
+        }
+        this.models.set(modelIdResult, result);
+        return modelIdResult;
+    }
+    /**
+     * M1b store-backed open (conway extension; feature-detect with
+     * `typeof api.OpenModelStream === 'function'`). Parses through a
+     * moving window over `store` and keeps the model windowed from
+     * birth — the source is never one JS `ArrayBuffer`. Geometry
+     * extract on the deferred path must use
+     * {@link ExtractGeometryBatchAsync} so product closures can be
+     * paged in.
+     *
+     * IFC only; other formats return -1 (caller should fall back to
+     * buffering + OpenModelStreamed).
+     *
+     * @param store External store holding the source bytes (OPFS File).
+     * @param settings settings for loading the model
+     * @return {Promise<number>} model ID, or -1 on failure
+     */
+    async OpenModelStream(store, settings) {
+        const modelIdResult = this.globalModelIDCounter++;
+        const result = await IfcApiModelPassthroughFactory.fromStore(modelIdResult, store, this.wasmModule, settings);
+        if (result === void 0) {
+            return -1;
+        }
+        this.models.set(modelIdResult, result);
+        return modelIdResult;
+    }
     /**
      * Set conway's console-echo log threshold, web-ifc compatible surface
      * (numeric LogLevel enum). Embedders (e.g. Share) use this to quiet a
@@ -434,6 +530,25 @@ export class IfcAPI {
         const coordinationMatrix = glmatrix.mat4.create();
         return Array.from(coordinationMatrix);
     }
+    /**
+     * Conway extension: the coordination frame the open ACTUALLY applied
+     * to emitted placements (the COORDINATE_TO_ORIGIN recenter), identity
+     * when none ran. GetCoordinationMatrix keeps its classic identity
+     * contract (consumers stamp it onto assembled models); this is the
+     * explicit report of the real offset so embedders can map rendered
+     * points back to source-world coordinates (Share#1634 acceptance).
+     * Feature-detect: typeof api.GetAppliedCoordinationMatrix.
+     *
+     * @param modelID
+     * @return {Array<number>} column-major mat4
+     */
+    GetAppliedCoordinationMatrix(modelID) {
+        const result = this.models.get(modelID);
+        if (result !== void 0 && result.getAppliedCoordination !== void 0) {
+            return result.getAppliedCoordination();
+        }
+        return Array.from(glmatrix.mat4.create());
+    }
     /**
      *
      * @param ptr
@@ -460,8 +575,15 @@ export class IfcAPI {
      * @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
@@ -477,6 +599,92 @@ export class IfcAPI {
         this.models.delete(modelID);
         this.conwaywasm.destroy();
     }
+    /**
+     * Conway extension (Share demand/tiled rendering slice A): on a model
+     * opened with `OpenModelStreamed(data, {DEFER_GEOMETRY: true})`,
+     * extract the next `batchSize` products and emit this batch's meshes —
+     * the incremental twin of StreamAllMeshes. Feature-detect with
+     * `typeof api.ExtractGeometryBatch === 'function'`; call repeatedly
+     * until `remaining` is 0.
+     *
+     * DELTA CONTRACT: an entity may be emitted again in a LATER call with
+     * a FlatMesh containing only its NEW placed instances (shared/mapped
+     * geometry attributes instances to an entity from other products'
+     * extractions). Consumers must render/accumulate deltas additively —
+     * never key emissions by expressID with overwrite semantics. Each
+     * placed instance is emitted exactly once across all calls.
+     *
+     * @param modelID handle retrieved by OpenModelStreamed
+     * @param batchSize max products to extract this call
+     * @param meshCallback receives each newly-extracted product's mesh
+     * @return {object} `{extracted, remaining}`; `{extracted: 0,
+     * remaining: 0}` for unknown models or models without the deferred
+     * pump (non-IFC / fully-extracted opens).
+     */
+    ExtractGeometryBatch(modelID, batchSize, meshCallback) {
+        const result = this.models.get(modelID);
+        if (result?.extractGeometryBatch === void 0) {
+            return { extracted: 0, remaining: 0 };
+        }
+        return result.extractGeometryBatch(batchSize, meshCallback);
+    }
+    /**
+     * Async twin of {@link ExtractGeometryBatch}: pages each product's
+     * source-byte closure before extracting it. Required for models
+     * opened with {@link OpenModelStream}; a no-op-prefetch on a
+     * resident-source deferred open. Feature-detect with
+     * `typeof api.ExtractGeometryBatchAsync === 'function'`.
+     *
+     * @param modelID handle retrieved by OpenModelStream / OpenModelStreamed
+     * @param batchSize max products to extract this call
+     * @param meshCallback receives each newly-extracted product's mesh
+     * @return {Promise<object>} `{extracted, remaining}`
+     */
+    async ExtractGeometryBatchAsync(modelID, batchSize, meshCallback) {
+        const result = this.models.get(modelID);
+        if (result?.extractGeometryBatchAsync !== void 0) {
+            return result.extractGeometryBatchAsync(batchSize, meshCallback);
+        }
+        if (result?.extractGeometryBatch === void 0) {
+            return { extracted: 0, remaining: 0 };
+        }
+        return result.extractGeometryBatch(batchSize, meshCallback);
+    }
+    /**
+     * Conway extension: free a model's native geometry once the consumer
+     * has built its own scene from the meshes — every canonical mesh the
+     * extraction produced plus the GetGeometry map. Subsequent
+     * GetGeometry calls return an empty dummy; placed transforms, the
+     * spatial structure and properties are untouched. Feature-detect with
+     * `typeof api.ReleaseModelGeometry === 'function'`.
+     *
+     * The wasm heap never shrinks, but freed pages are reused — repeated
+     * loads in one tab plateau instead of stacking whole model scenes.
+     * On a deferred model whose pump has not drained this is a safe
+     * no-op returning false.
+     *
+     * @param modelID handle retrieved by OpenModel/OpenModelStreamed
+     * @return {boolean} True when geometry was released.
+     */
+    /**
+     * Conway extension: the model's linear scaling factor to metres
+     * (1 = metres, 0.001 = millimetres, 0.0254 = inches), derived from
+     * the model's unit assignment during extraction. Feature-detect with
+     * `typeof`. Returns 1 for unknown models.
+     *
+     * @param modelID handle retrieved by OpenModel/OpenModelStreamed
+     * @return {number} metres per model unit.
+     */
+    GetLinearScalingFactor(modelID) {
+        return this.models.get(modelID)?.linearScalingFactor ?? 1;
+    }
+    ReleaseModelGeometry(modelID) {
+        const result = this.models.get(modelID);
+        if (result?.releaseGeometry === void 0) {
+            return false;
+        }
+        return result.releaseGeometry();
+    }
     /**
      *
      * @param modelID

package/compiled/src/compat/web-ifc/ifc_api_deferred_open.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ifc_api_deferred_open.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ifc_api_deferred_open.test.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_deferred_open.test.ts"],"names":[],"mappings":""}

package/compiled/src/compat/web-ifc/ifc_api_deferred_open.test.js

@@ -0,0 +1,288 @@
+/* eslint-disable no-magic-numbers */
+// Deferred-geometry streamed open (demand/tiled rendering slice A):
+// pumping ExtractGeometryBatch to completion must reproduce EXACTLY the
+// meshes a classic OpenModel + StreamAllMeshes produces — same
+// entities, same placed-geometry ids, colors, and transforms — across
+// multiple small batches (which exercises the persisted coordination
+// matrix; a single-shot capture can't catch a stale one).
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { IfcAPI } from "./ifc_api.js";
+const SETTINGS = { COORDINATE_TO_ORIGIN: true, USE_FAST_BOOLS: true };
+let api;
+let buffer;
+/**
+ * Flatten a FlatMesh into comparable plain data.
+ *
+ * @param mesh The mesh.
+ * @return {object} Plain comparable form.
+ */
+function flatten(mesh, previous) {
+    const geometries = previous?.geometries ?? [];
+    for (let where = 0; where < mesh.geometries.size(); ++where) {
+        const placed = mesh.geometries.get(where);
+        geometries.push({
+            color: placed.color,
+            geometryExpressID: placed.geometryExpressID,
+            flatTransformation: [...placed.flatTransformation],
+        });
+    }
+    return { expressID: mesh.expressID, geometries };
+}
+beforeAll(async () => {
+    api = new IfcAPI();
+    await api.Init();
+    buffer = new Uint8Array(fs.readFileSync("data/index.ifc"));
+}, 120000);
+describe("OpenModelStreamed + DEFER_GEOMETRY", () => {
+    test("batch pump to completion matches classic StreamAllMeshes exactly", async () => {
+        const classicID = api.OpenModel(buffer, SETTINGS);
+        const classic = new Map();
+        api.StreamAllMeshes(classicID, (mesh) => {
+            classic.set(mesh.expressID, flatten(mesh));
+        });
+        expect(classic.size).toBeGreaterThan(0);
+        const deferredID = await api.OpenModelStreamed(buffer, { ...SETTINGS, DEFER_GEOMETRY: true });
+        expect(deferredID).toBeGreaterThanOrEqual(0);
+        // Pump in deliberately small batches; collect incremental meshes.
+        // (Deltas: an entity may re-emit with only its NEW instances —
+        // `flatten` accumulation in the map below must be additive.)
+        const streamed = new Map();
+        let firstBatchCount = 0;
+        let rounds = 0;
+        for (;;) {
+            const { extracted, remaining } = api.ExtractGeometryBatch(deferredID, 7, (mesh) => {
+                streamed.set(mesh.expressID, flatten(mesh, streamed.get(mesh.expressID)));
+            });
+            if (rounds === 0) {
+                firstBatchCount = streamed.size;
+            }
+            ++rounds;
+            if (remaining === 0 && extracted === 0) {
+                break;
+            }
+        }
+        // Incrementality: meshes arrived before the pump completed.
+        expect(rounds).toBeGreaterThan(2);
+        expect(firstBatchCount).toBeGreaterThanOrEqual(0);
+        expect(streamed.size).toBe(classic.size);
+        // Exact parity per entity: ids, colors, transforms.
+        for (const [expressID, mesh] of classic) {
+            expect(streamed.get(expressID)).toEqual(mesh);
+        }
+        api.CloseModel(classicID);
+        api.CloseModel(deferredID);
+    }, 240000);
+    test("deferred pump emits a Geometry progress phase", async () => {
+        const events = [];
+        const deferredID = await api.OpenModelStreamed(buffer, {
+            ...SETTINGS,
+            DEFER_GEOMETRY: true,
+            ON_PROGRESS: (event) => {
+                events.push({
+                    phase: event.phase,
+                    completed: event.completed,
+                    total: event.total,
+                });
+            },
+        });
+        expect(deferredID).toBeGreaterThanOrEqual(0);
+        for (;;) {
+            const { extracted, remaining } = api.ExtractGeometryBatch(deferredID, 7);
+            if (remaining === 0 && extracted === 0) {
+                break;
+            }
+        }
+        const parseEvents = events.filter((event) => event.phase === "dataParse");
+        const geometryEvents = events.filter((event) => event.phase === "geometry");
+        expect(parseEvents.length).toBeGreaterThan(0);
+        expect(geometryEvents.length).toBeGreaterThan(0);
+        expect(geometryEvents[0].completed).toBe(0);
+        expect(geometryEvents[geometryEvents.length - 1].completed).
+            toBe(geometryEvents[geometryEvents.length - 1].total);
+        api.CloseModel(deferredID);
+    }, 240000);
+    test("StreamAllMeshes on a deferred model drains the pump and matches classic", async () => {
+        const classicID = api.OpenModel(buffer, SETTINGS);
+        const classic = new Map();
+        api.StreamAllMeshes(classicID, (mesh) => {
+            classic.set(mesh.expressID, flatten(mesh));
+        });
+        const deferredID = await api.OpenModelStreamed(buffer, { ...SETTINGS, DEFER_GEOMETRY: true });
+        // No pump calls at all — the whole-model consumer must still get
+        // the complete mesh set (the shim drains internally).
+        const drained = new Map();
+        api.StreamAllMeshes(deferredID, (mesh) => {
+            drained.set(mesh.expressID, flatten(mesh));
+        });
+        expect(drained.size).toBe(classic.size);
+        for (const [expressID, mesh] of classic) {
+            expect(drained.get(expressID)).toEqual(mesh);
+        }
+        api.CloseModel(classicID);
+        api.CloseModel(deferredID);
+    }, 240000);
+    test("deferred GetGeometry serves byte-identical vertex content to classic", async () => {
+        // The build multiplies GetGeometry FLOAT vertices by captured
+        // transforms, and the float mirror's frame must match the scene
+        // transforms (frozen at mesh add — see IfcModelGeometry.add). A
+        // per-geometry frame shift here renders as scattered pieces even
+        // with perfect transform parity, which transform-only assertions
+        // cannot catch.
+        //
+        // Fresh IfcAPI: CloseModel destroys the shared wasm processor, and
+        // models opened after ANY close serve empty geometry payloads (a
+        // long-standing multi-open shim quirk — browsers open one model per
+        // page). The shared `api` has closed models by the time this runs.
+        const api2 = new IfcAPI();
+        await api2.Init();
+        const classicID = api2.OpenModel(buffer, SETTINGS);
+        const geometryIDs = new Set();
+        api2.StreamAllMeshes(classicID, (mesh) => {
+            for (let where = 0; where < mesh.geometries.size(); ++where) {
+                geometryIDs.add(mesh.geometries.get(where).geometryExpressID);
+            }
+        });
+        const deferredID = await api2.OpenModelStreamed(buffer, { ...SETTINGS, DEFER_GEOMETRY: true });
+        api2.StreamAllMeshes(deferredID, () => { });
+        let compared = 0;
+        for (const geometryID of geometryIDs) {
+            const classicGeometry = api2.GetGeometry(classicID, geometryID);
+            const deferredGeometry = api2.GetGeometry(deferredID, geometryID);
+            const classicSize = classicGeometry.GetVertexDataSize();
+            if (classicSize === 0) {
+                continue;
+            }
+            expect(deferredGeometry.GetVertexDataSize()).toBe(classicSize);
+            const classicVertices = api2.GetVertexArray(classicGeometry.GetVertexData(), classicSize);
+            const deferredVertices = api2.GetVertexArray(deferredGeometry.GetVertexData(), classicSize);
+            expect(deferredVertices).toEqual(classicVertices);
+            ++compared;
+        }
+        expect(compared).toBeGreaterThan(0);
+        api2.CloseModel(classicID);
+        api2.CloseModel(deferredID);
+    }, 240000);
+    test("ReleaseModelGeometry frees served geometry, keeps meshes, refuses undrained pumps", async () => {
+        // Fresh IfcAPI (CloseModel poisons later opens — see the content
+        // parity test's note).
+        const api3 = new IfcAPI();
+        await api3.Init();
+        // Undrained deferred pump: refuse (releasing would break the
+        // remaining extraction).
+        const deferredID = await api3.OpenModelStreamed(buffer, { ...SETTINGS, DEFER_GEOMETRY: true });
+        api3.ExtractGeometryBatch(deferredID, 1);
+        expect(api3.ReleaseModelGeometry(deferredID)).toBe(false);
+        // Classic model: release frees GetGeometry serving, keeps captured
+        // mesh data, double-release stays safe.
+        const classicID = api3.OpenModel(buffer, SETTINGS);
+        const geometryIDs = [];
+        let meshes = 0;
+        api3.StreamAllMeshes(classicID, (mesh) => {
+            ++meshes;
+            for (let where = 0; where < mesh.geometries.size(); ++where) {
+                geometryIDs.push(mesh.geometries.get(where).geometryExpressID);
+            }
+        });
+        expect(meshes).toBeGreaterThan(0);
+        expect(api3.GetGeometry(classicID, geometryIDs[0]).GetVertexDataSize())
+            .toBeGreaterThan(0);
+        expect(api3.ReleaseModelGeometry(classicID)).toBe(true);
+        // Served geometry degrades to the empty dummy; mesh data survives.
+        expect(api3.GetGeometry(classicID, geometryIDs[0]).GetVertexDataSize())
+            .toBe(0);
+        let meshesAfter = 0;
+        api3.StreamAllMeshes(classicID, () => {
+            ++meshesAfter;
+        });
+        expect(meshesAfter).toBeGreaterThan(0);
+        expect(api3.ReleaseModelGeometry(classicID)).toBe(true);
+        expect(api3.ReleaseModelGeometry(9999)).toBe(false);
+    }, 240000);
+    test("pump applies the rel-aggregates master-voids pass (cut parity)", async () => {
+        // Classic's whole-model walk follows its product loop with a second
+        // pass re-extracting every IfcRelAggregates related product with
+        // the RELATING object's rel-voids, REPLACING the canonical mesh
+        // under the same localID — aggregate parts whose parent carries
+        // openings end up cut. A pump that only ran the per-product pass
+        // served the UNCUT content classic never exposes (field reports:
+        // wrong shapes + flicker on faceset-heavy vyzn models). The
+        // synthetic fixture is an assembly voided by an opening,
+        // aggregating a box part the opening must cut.
+        //
+        // Fresh IfcAPI (CloseModel poisons later opens — see the content
+        // parity test's note).
+        const api4 = new IfcAPI();
+        await api4.Init();
+        const fixture = new Uint8Array(fs.readFileSync("data/aggregate_master_voids.ifc"));
+        const classicID = api4.OpenModel(fixture, SETTINGS);
+        const classicInstances = [];
+        api4.StreamAllMeshes(classicID, (mesh) => {
+            for (let where = 0; where < mesh.geometries.size(); ++where) {
+                classicInstances.push(mesh.geometries.get(where).geometryExpressID);
+            }
+        });
+        // Aggregate targets are extracted ONLY by the second pass now
+        // (aggregateTargetLocalIDs): exactly ONE placed instance of the cut
+        // part. (Historically 2 — the first-pass uncut node plus the
+        // pass-two re-extraction node coinciding, a duplicate that
+        // z-fought and, on the pump, delivered stale uncut content.)
+        expect(classicInstances.length).toBe(1);
+        const deferredID = await api4.OpenModelStreamed(fixture, { ...SETTINGS, DEFER_GEOMETRY: true });
+        const pumpedInstances = [];
+        const pumpedTrisAtDelivery = [];
+        for (;;) {
+            const { extracted, remaining } = api4.ExtractGeometryBatch(deferredID, 1, (mesh) => {
+                for (let where = 0; where < mesh.geometries.size(); ++where) {
+                    const geometryID = mesh.geometries.get(where).geometryExpressID;
+                    pumpedInstances.push(geometryID);
+                    // Content-at-delivery: what an incremental consumer
+                    // copies the moment the instance is emitted.
+                    const geometry = api4.GetGeometry(deferredID, geometryID);
+                    pumpedTrisAtDelivery.push(
+                    // eslint-disable-next-line no-magic-numbers
+                    (geometry.GetIndexDataSize() / 3) | 0);
+                }
+            });
+            if (remaining === 0 && extracted === 0) {
+                break;
+            }
+        }
+        // Instance parity: same single cut instance as classic.
+        expect(pumpedInstances.sort()).toEqual(classicInstances.sort());
+        // The #1640 invariant (Share bldrs-ai/Share#1640): the content an
+        // incremental consumer copies AT DELIVERY equals the final content
+        // — the pump must never mutate a geometry after emitting instances
+        // that reference it.
+        for (let where = 0; where < pumpedInstances.length; ++where) {
+            const finalGeometry = api4.GetGeometry(deferredID, pumpedInstances[where]);
+            expect(pumpedTrisAtDelivery[where])
+                // eslint-disable-next-line no-magic-numbers
+                .toBe((finalGeometry.GetIndexDataSize() / 3) | 0);
+        }
+        // Content parity: GetGeometry must serve the CUT part, byte-identical
+        // to classic (the uncut box has strictly fewer vertices).
+        for (const geometryID of new Set(classicInstances)) {
+            const classicGeometry = api4.GetGeometry(classicID, geometryID);
+            const deferredGeometry = api4.GetGeometry(deferredID, geometryID);
+            const classicSize = classicGeometry.GetVertexDataSize();
+            expect(classicSize).toBeGreaterThan(0);
+            expect(deferredGeometry.GetVertexDataSize()).toBe(classicSize);
+            expect(deferredGeometry.GetIndexDataSize())
+                .toBe(classicGeometry.GetIndexDataSize());
+            const classicVertices = api4.GetVertexArray(classicGeometry.GetVertexData(), classicSize);
+            const deferredVertices = api4.GetVertexArray(deferredGeometry.GetVertexData(), classicSize);
+            expect(deferredVertices).toEqual(classicVertices);
+        }
+        api4.CloseModel(classicID);
+        api4.CloseModel(deferredID);
+    }, 240000);
+    test("ExtractGeometryBatch is a safe no-op on non-deferred models", async () => {
+        const modelID = await api.OpenModelStreamed(buffer, SETTINGS);
+        expect(api.ExtractGeometryBatch(modelID, 8))
+            .toEqual({ extracted: 0, remaining: 0 });
+        expect(api.ExtractGeometryBatch(9999, 8))
+            .toEqual({ extracted: 0, remaining: 0 });
+        api.CloseModel(modelID);
+    }, 120000);
+});

package/compiled/src/compat/web-ifc/ifc_api_model_passthrough.d.ts

@@ -7,7 +7,37 @@ export interface IfcApiModelPassthrough {
     loadAllGeometry(): Vector<FlatMesh>;
     streamAllMeshesWithTypes(types: number[], meshCallback: (mesh: FlatMesh) => void): void;
     streamAllMeshes(meshCallback: (mesh: FlatMesh) => void): void;
+    /**
+     * Deferred-mode batch pump (IFC proxies opened with DEFER_GEOMETRY) —
+     * see IfcApiProxyIfc.extractGeometryBatch.
+     */
+    /** Free the model's native geometry after the consumer's scene build
+     * (conway extension) — see the proxies' releaseGeometry. */
+    releaseGeometry?(): boolean;
+    /** Metres per model unit (see IfcAPI.GetLinearScalingFactor). */
+    linearScalingFactor?: number;
+    extractGeometryBatch?(batchSize: number, meshCallback?: (mesh: FlatMesh) => void): {
+        extracted: number;
+        remaining: number;
+    };
+    /**
+     * Async twin of extractGeometryBatch — pages windowed source ranges
+     * before each product extract (M1b). Feature-detect with typeof.
+     */
+    extractGeometryBatchAsync?(batchSize: number, meshCallback?: (mesh: FlatMesh) => void): Promise<{
+        extracted: number;
+        remaining: number;
+    }>;
     getCoordinationMatrix(): number[];
+    /**
+     * Optional: the coordination frame the open ACTUALLY applied to
+     * emitted placements (COORDINATE_TO_ORIGIN recenter). Unlike
+     * getCoordinationMatrix — whose classic identity contract consumers
+     * stamp onto assembled models — this reports the real offset, so
+     * embedders can map rendered points back to source-world coordinates
+     * (Share#1634 acceptance).
+     */
+    getAppliedCoordination?(): number[];
     getAllLines(): Vector<number>;
     getLineIDsWithType(type: number): Vector<number>;
     getRawLineData(expressID: number): RawLineData;
@@ -24,6 +54,15 @@ export interface IfcApiModelPassthrough {
      * external store and served through on-demand windows.
      */
     readonly sourceIsExternal?: boolean;
+    /** Optional: store-backed pump split (prefetch / extract / release). */
+    readonly extractProfile?: {
+        prefetchMs: number;
+        extractMs: number;
+        releaseMs: number;
+        batches: number;
+        lastPins: number;
+        pinMax: number;
+    };
     /**
      * Optional: release the resident source buffer, serving subsequent
      * record reads through windows paged from the given external store.

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

@@ -1 +1 @@
-{"version":3,"file":"ifc_api_model_passthrough.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_model_passthrough.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAA;AAGhE,MAAM,WAAW,sBAAsB;IAErC,UAAU,EAAE,qBAAqB,CAAA;IAEjC,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAA;IACxC,eAAe,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAA;IACnC,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI,CAAA;IACvF,eAAe,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI,CAAA;IAC7D,qBAAqB,IAAI,MAAM,EAAE,CAAA;IACjC,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAAA;IAC7B,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;IAChD,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,CAAA;IAC9C,WAAW,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAAA;IAC5B,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAAA;IAC5D,WAAW,CAAC,iBAAiB,EAAE,MAAM,GAAG,WAAW,CAAA;IAEnD;;;OAGG;IACH,kBAAkB,CAAC,IAAI,IAAI,CAAA;IAE3B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAEnC;;;OAGG;IACH,0BAA0B,CAAC,CACzB,KAAK,EAAE,qBAAqB,EAC5B,UAAU,CAAC,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,GAAI,IAAI,CAAA;IAEpC;;;OAGG;IACH,kBAAkB,CAAC,CAAE,SAAS,EAAE,MAAM,GAAI,OAAO,CAAE,IAAI,CAAE,CAAA;IAEzD;;;;;OAKG;IACH,cAAc,CAAC,IAAI,gBAAgB,CAAE,MAAM,CAAE,CAAA;CAC9C"}
+{"version":3,"file":"ifc_api_model_passthrough.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_model_passthrough.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAA;AAGhE,MAAM,WAAW,sBAAsB;IAErC,UAAU,EAAE,qBAAqB,CAAA;IAEjC,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAA;IACxC,eAAe,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAA;IACnC,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI,CAAA;IACvF,eAAe,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI,CAAA;IAC7D;;;OAGG;IACH;gEAC4D;IAC5D,eAAe,CAAC,IAAI,OAAO,CAAA;IAE3B,iEAAiE;IACjE,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAE5B,oBAAoB,CAAC,CACnB,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAG;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAAA;IAElF;;;OAGG;IACH,yBAAyB,CAAC,CACxB,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GACvC,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;IACjD,qBAAqB,IAAI,MAAM,EAAE,CAAA;IAEjC;;;;;;;OAOG;IACH,sBAAsB,CAAC,IAAI,MAAM,EAAE,CAAA;IACnC,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAAA;IAC7B,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;IAChD,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,CAAA;IAC9C,WAAW,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAAA;IAC5B,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAAA;IAC5D,WAAW,CAAC,iBAAiB,EAAE,MAAM,GAAG,WAAW,CAAA;IAEnD;;;OAGG;IACH,kBAAkB,CAAC,IAAI,IAAI,CAAA;IAE3B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAEnC,wEAAwE;IACxE,QAAQ,CAAC,cAAc,CAAC,EAAE;QACxB,UAAU,EAAE,MAAM,CAAA;QAClB,SAAS,EAAE,MAAM,CAAA;QACjB,SAAS,EAAE,MAAM,CAAA;QACjB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;IAED;;;OAGG;IACH,0BAA0B,CAAC,CACzB,KAAK,EAAE,qBAAqB,EAC5B,UAAU,CAAC,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,GAAI,IAAI,CAAA;IAEpC;;;OAGG;IACH,kBAAkB,CAAC,CAAE,SAAS,EAAE,MAAM,GAAI,OAAO,CAAE,IAAI,CAAE,CAAA;IAEzD;;;;;OAKG;IACH,cAAc,CAAC,IAAI,gBAAgB,CAAE,MAAM,CAAE,CAAA;CAC9C"}

package/compiled/src/compat/web-ifc/ifc_api_model_passthrough_factory.d.ts

@@ -1,5 +1,6 @@
 import { Loadersettings } from "./ifc_api.js";
 import { IfcApiModelPassthrough } from "./ifc_api_model_passthrough.js";
+import { StepExternalByteStore } from "../../step/step_buffer_provider.js";
 /**
  * The factory to construct models.
  */
@@ -13,6 +14,35 @@ export declare class IfcApiModelPassthroughFactory {
      * @return {IfcApiModelPassthrough | undefined}
      */
     static from(modelID: number, data: Uint8Array, wasmModule: any, settings?: Loadersettings): IfcApiModelPassthrough | undefined;
+    /**
+     * Streamed-open twin of fromAsync (used by OpenModelStreamed): IFC
+     * models parse through the streaming columnar indexer (no per-record
+     * object phase — see IfcApiProxyIfc.createStreamed); everything else
+     * behaves like fromAsync. Non-IFC formats and any streamed-open
+     * failure fall back to the classic cooperative path, so this never
+     * does worse than fromAsync — the safety net behind embedder
+     * feature flags.
+     *
+     * @param modelID
+     * @param data
+     * @param wasmModule
+     * @param settings
+     * @return {Promise<IfcApiModelPassthrough | undefined>}
+     */
+    static fromStreamed(modelID: number, data: Uint8Array, wasmModule: any, settings?: Loadersettings): Promise<IfcApiModelPassthrough | undefined>;
+    /**
+     * Store-backed open (M1b): IFC models parse through a moving window
+     * over `store` and stay windowed from birth. Non-IFC formats are not
+     * implemented on this path — the caller should fall back to buffering
+     * and fromStreamed.
+     *
+     * @param modelID
+     * @param store External store holding the source bytes.
+     * @param wasmModule
+     * @param settings
+     * @return {Promise<IfcApiModelPassthrough | undefined>}
+     */
+    static fromStore(modelID: number, store: StepExternalByteStore, wasmModule: any, settings?: Loadersettings): Promise<IfcApiModelPassthrough | undefined>;
     /**
      * Cooperative twin of from() (used by OpenModelAsync): the data parse
      * runs with periodic event-loop yields so progress UI can repaint

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

@@ -1 +1 @@
-{"version":3,"file":"ifc_api_model_passthrough_factory.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_model_passthrough_factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AAKpE;;GAEG;AACH,qBAAa,6BAA6B;IAExC;;;;;;;OAOG;WACW,IAAI,CACd,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,sBAAsB,GAAG,SAAS;IA2EnE;;;;;;;;;;;;OAYG;WACiB,SAAS,CACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;CA+C7E"}
+{"version":3,"file":"ifc_api_model_passthrough_factory.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_model_passthrough_factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AAIpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAMvE;;GAEG;AACH,qBAAa,6BAA6B;IAExC;;;;;;;OAOG;WACW,IAAI,CACd,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,sBAAsB,GAAG,SAAS;IA2EnE;;;;;;;;;;;;;;OAcG;WACiB,YAAY,CAC5B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;IAkD5E;;;;;;;;;;;OAWG;WACiB,SAAS,CACzB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,qBAAqB,EAC5B,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;IA2B5E;;;;;;;;;;;;OAYG;WACiB,SAAS,CACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;CA+C7E"}