@bldrs-ai/conway 1.426.1283 → 1.427.1287

package/compiled/src/AP214E3_2010/ap214_geometry_extraction.js

@@ -88,6 +88,7 @@ export class AP214GeometryExtraction {
          * Statistics by the loader/proxies after extraction.
          */
         this.geometryTypeCounts = new Map();
+        this.demandCursor_ = 0;
         this.csgMemoization = !this.lowMemoryMode;
         this.materials = model.materials;
         this.scene = new AP214SceneBuilder(model, conwayModel, this.materials);
@@ -2902,16 +2903,27 @@ export class AP214GeometryExtraction {
      * @return {[ExtractResult, AP214SceneBuilder]} - Enum indicating extraction result
      * + Geometry array
      */
-    extractAP214GeometryData(logTime = false) {
-        let result = ExtractResult.INCOMPLETE;
-        const startTime = Date.now();
-        //  this.extractLinearScalingFactor()
-        const previousMemoizationState = this.model.elementMemoization;
-        // populate relMaterialsMap
-        // const relAssociatesMaterials = this.model.types(AP214RelAssociatesMaterial)
+    /**
+     * Prepare per-unit demand extraction (STEP demand parity phase 2)
+     * without executing any geometry work: builds the assembly tree and
+     * thunks exactly like the whole-model walk, but the root executions
+     * are captured as an ordered list of UNITS — a childless root is one
+     * unit; a root with children is flattened one level (one unit per
+     * immediate child, in order, then one for the root's own items), so
+     * single-root assemblies still pump progressively per part. Executing
+     * every unit in order then calling {@link finishDemandExtraction}
+     * reproduces the whole-model walk exactly — the classic
+     * {@link extractAP214GeometryData} runs through this same path.
+     * Idempotent.
+     */
+    // eslint-disable-next-line max-lines-per-function
+    prepareDemandExtraction() {
+        if (this.demandUnits_ !== void 0) {
+            return;
+        }
         const model = this.model;
         const treeMap = new Map();
-        const makeThunk = (representation, owningElementLocalID, mappedTreeNode) => {
+        const makeThunk = (representation, owningElementLocalID, mappedTreeNode, slice) => {
             return (owningLocalID, parentTransform) => {
                 owningLocalID ??= owningElementLocalID;
                 const mappedItem = mappedTreeNode !== void 0 || parentTransform !== void 0;
@@ -2920,8 +2932,12 @@ export class AP214GeometryExtraction {
                 if (parentTransform !== void 0) {
                     this.scene.addTransform(representation.localID, parentTransform.getValues(), parentTransform, true);
                 }
-                if (mappedTreeNode?.children !== void 0) {
-                    for (const [childLocalID, childOwningLocalID, childTransform] of mappedTreeNode.children) {
+                if (mappedTreeNode?.children !== void 0 &&
+                    (slice === void 0 || slice.childStart !== slice.childEnd)) {
+                    const sliceChildren = slice !== void 0 ?
+                        mappedTreeNode.children.slice(slice.childStart, slice.childEnd) :
+                        mappedTreeNode.children;
+                    for (const [childLocalID, childOwningLocalID, childTransform] of sliceChildren) {
                         const mappedChild = treeMap.get(childLocalID);
                         const enterChildStackDepth = this.scene.stackLength;
                         const enterChildParent = this.scene.currentParent;
@@ -2971,7 +2987,8 @@ export class AP214GeometryExtraction {
                         }
                     }
                 }
-                for (const item of representation.items) {
+                const includeItems = slice?.includeItems ?? true;
+                for (const item of includeItems ? representation.items : []) {
                     try {
                         if (item instanceof placement) {
                             this.extractPlacement(item, mappedItem);
@@ -3010,11 +3027,19 @@ export class AP214GeometryExtraction {
                 }
             };
         };
-        try {
+        // Roots the whole-model walk would execute, in execution order —
+        // expanded into units at the end of preparation (children arrays
+        // are final only once every edge loop has run).
+        const pendingRoots = [];
+        {
             this.scene.clearParentStack();
             // 256 meg limit for memoization - smaller models get a big
             // win from memoization, but much larger models it uses far too much heap.
             const MEMOIZATION_THRESHOLD = 256 * 1024 * 1024;
+            // Remembered for finishDemandExtraction / the classic wrapper's
+            // finally — the pump spans many calls, so restoration cannot live
+            // in a single method's finally anymore.
+            this.demandMemoizationRestore_ = this.model.elementMemoization;
             if (this.lowMemoryMode || model.bufferBytesize > MEMOIZATION_THRESHOLD) {
                 this.model.elementMemoization = false;
             }
@@ -3089,6 +3114,8 @@ export class AP214GeometryExtraction {
                     sourceNode = { parents: 1 };
                     treeMap.set(sourceID, sourceNode);
                     sourceNode.thunk = makeThunk(sourceShape, owningLocalID, sourceNode);
+                    sourceNode.rep = sourceShape;
+                    sourceNode.owningLocalID = owningLocalID;
                 }
                 else {
                     sourceNode.parents ??= 0;
@@ -3135,6 +3162,8 @@ export class AP214GeometryExtraction {
                     ++sourceNode.parents;
                 }
                 sourceNode.thunk = makeThunk(sourceShape, owningLocalID, sourceNode);
+                sourceNode.rep = sourceShape;
+                sourceNode.owningLocalID = owningLocalID;
                 let targetNode = treeMap.get(targetID);
                 if (targetNode === void 0) {
                     targetNode = { parents: 0, children: [[sourceID, owningLocalID, transform]] };
@@ -3166,6 +3195,8 @@ export class AP214GeometryExtraction {
                 const mappedTreeNode = treeNode;
                 const thunk = makeThunk(shapeRepresentation, owningElementLocalID, mappedTreeNode);
                 mappedTreeNode.thunk = thunk;
+                mappedTreeNode.rep = shapeRepresentation;
+                mappedTreeNode.owningLocalID = owningElementLocalID;
                 if (!hasMappedNode) {
                     mappedTreeNode.processed = true;
                     const sourceShapeContext = shapeRepresentation.context_of_items.findVariant(global_unit_assigned_context)?.units?.
@@ -3176,8 +3207,14 @@ export class AP214GeometryExtraction {
                         scaleTransform =
                             this.uniformScaleAffine(this.identity3DNativeMatrix, 1 / sourceUnitInM);
                     }
-                    // not an assembly mapped item, just extract the representation
-                    thunk(void 0, scaleTransform);
+                    // not an assembly mapped item — capture as a pending root
+                    // instead of executing inline (these nodes are childless by
+                    // construction: they were absent from the tree before this
+                    // loop, and all edges were added by the earlier loops).
+                    pendingRoots.push({
+                        node: mappedTreeNode,
+                        scaleTransform,
+                    });
                     continue;
                 }
             }
@@ -3195,12 +3232,14 @@ export class AP214GeometryExtraction {
                 const mappedTreeNode = treeNode;
                 const owningElementLocalID = shapeRepresentation.localID;
                 mappedTreeNode.thunk = makeThunk(shapeRepresentation, owningElementLocalID, mappedTreeNode);
+                mappedTreeNode.rep = shapeRepresentation;
+                mappedTreeNode.owningLocalID = owningElementLocalID;
             }
-            // All thunks are set, now we can execute the full
-            // assembly tree.
+            // All thunks are set — capture remaining assembly-tree roots as
+            // pending roots in the exact order the whole-model walk executed
+            // them.
             for (const [sourceID, mappedNode] of treeMap.entries()) {
                 if ((mappedNode.parents ?? 0) === 0 && mappedNode.thunk !== void 0 && mappedNode.processed !== true) {
-                    //this.scene.clearParentStack()
                     const shapeRepresentation = this.model.getTypedElementByLocalID(sourceID, shape_representation);
                     const sourceShapeContext = shapeRepresentation.context_of_items.findVariant(global_unit_assigned_context)?.units?.
                         find(unit => unit.findVariant(length_unit))?.findVariant(length_unit);
@@ -3210,30 +3249,133 @@ export class AP214GeometryExtraction {
                         scaleTransform =
                             this.uniformScaleAffine(this.identity3DNativeMatrix, 1 / sourceUnitInM);
                     }
-                    // not an assembly mapped item, just extract the representation
-                    mappedNode.thunk(void 0, scaleTransform);
+                    pendingRoots.push({ node: mappedNode, scaleTransform });
                 }
             }
-            // Run any deferred face tessellation across the native thread pool
-            // before geometry can be read or temporaries freed.
-            this.finalizeStagedFaces();
-            if (RegressionCaptureState.memoization !== MemoizationCapture.FULL) {
-                this.model.geometry.deleteTemporaries();
+            // Expand pending roots into ordered execution units: childless
+            // roots run their original thunk whole; roots with children are
+            // flattened one level — one unit per immediate child (in order),
+            // then one for the root's own representation items, matching the
+            // thunk body's children-then-items order exactly.
+            const units = [];
+            for (const root of pendingRoots) {
+                const node = root.node;
+                const scaleTransform = root.scaleTransform;
+                const childCount = node.children?.length ?? 0;
+                if (childCount === 0 || node.rep === void 0) {
+                    units.push(() => node.thunk(void 0, scaleTransform));
+                    continue;
+                }
+                for (let child = 0; child < childCount; ++child) {
+                    const sliced = makeThunk(node.rep, node.owningLocalID, node, { childStart: child, childEnd: child + 1, includeItems: false });
+                    units.push(() => sliced(void 0, scaleTransform));
+                }
+                const itemsOnly = makeThunk(node.rep, node.owningLocalID, node, { childStart: 0, childEnd: 0, includeItems: true });
+                units.push(() => itemsOnly(void 0, scaleTransform));
+            }
+            this.demandUnits_ = units;
+        }
+    }
+    /**
+     * Total demand units (see prepareDemandExtraction).
+     *
+     * @return {number} The unit count (0 before preparation).
+     */
+    get demandUnitCount() {
+        return this.demandUnits_?.length ?? 0;
+    }
+    /**
+     * Units already executed by extractDemandUnitBatch.
+     *
+     * @return {number} The cursor.
+     */
+    get demandUnitCursor() {
+        return this.demandCursor_;
+    }
+    /**
+     * Execute the next `count` demand units (STEP demand parity phase 2)
+     * — the per-unit pump behind the shim's ExtractGeometryBatch for
+     * AP214 models. Staged face tessellation is finalized after every
+     * batch so captured geometry is complete and readable.
+     *
+     * @param count Max units to execute this call (min 1).
+     * @return {number} Units actually executed.
+     */
+    extractDemandUnitBatch(count) {
+        const units = this.demandUnits_;
+        if (units === void 0) {
+            return 0;
+        }
+        const end = Math.min(this.demandCursor_ + Math.max(count, 1), units.length);
+        let executed = 0;
+        for (; this.demandCursor_ < end; ++this.demandCursor_) {
+            try {
+                units[this.demandCursor_]();
+                ++executed;
             }
-            result = ExtractResult.COMPLETE;
-            // free buffer at the end if you don't need it anymore
-            if (this.pointBuffer?.pointer) {
-                this.wasmModule._free(this.pointBuffer.pointer);
-                this.pointBuffer = null;
+            catch (ex) {
+                if (ex instanceof Error) {
+                    Logger.error(`Error processing demand unit: \n\t${ex.name}\n\t${ex.message}`);
+                }
+                else {
+                    Logger.error(`Unknown exception processing demand unit (${ex})`);
+                }
             }
-            return [result, this.scene, this.productShapeMap];
+        }
+        // Deferred face tessellation must land before geometry is read.
+        this.finalizeStagedFaces();
+        return executed;
+    }
+    /**
+     * Complete a demand extraction after every unit has run: final staged
+     * tessellation, temporaries cleanup, point-buffer release and
+     * memoization restore — the tail the whole-model walk runs.
+     *
+     * @return {[ExtractResult, AP214SceneBuilder, AP214ProductShapeMap]}
+     * The completed extraction result.
+     */
+    finishDemandExtraction() {
+        this.finalizeStagedFaces();
+        if (RegressionCaptureState.memoization !== MemoizationCapture.FULL) {
+            this.model.geometry.deleteTemporaries();
+        }
+        if (this.pointBuffer?.pointer) {
+            this.wasmModule._free(this.pointBuffer.pointer);
+            this.pointBuffer = null;
+        }
+        if (this.demandMemoizationRestore_ !== void 0) {
+            this.model.elementMemoization = this.demandMemoizationRestore_;
+            this.demandMemoizationRestore_ = void 0;
+        }
+        return [ExtractResult.COMPLETE, this.scene, this.productShapeMap];
+    }
+    /**
+     * Whole-model extraction: prepare + run every demand unit + finish —
+     * a single code path with the per-unit pump, so pumped and classic
+     * extractions are identical by construction.
+     *
+     * @param logTime Unused (kept for call compatibility).
+     * @return {[ExtractResult, AP214SceneBuilder, AP214ProductShapeMap]}
+     * The completed extraction result.
+     */
+    // eslint-disable-next-line no-unused-vars
+    extractAP214GeometryData(logTime = false) {
+        try {
+            this.prepareDemandExtraction();
+            while (this.demandCursor_ < this.demandUnitCount) {
+                this.extractDemandUnitBatch(this.demandUnitCount);
+            }
+            return this.finishDemandExtraction();
         }
         finally {
             // Ensure no staged face jobs outlive extraction (their target
             // geometry may be freed once the model is invalidated), even if
             // extraction exits through an exception.
             this.finalizeStagedFaces();
-            this.model.elementMemoization = previousMemoizationState;
+            if (this.demandMemoizationRestore_ !== void 0) {
+                this.model.elementMemoization = this.demandMemoizationRestore_;
+                this.demandMemoizationRestore_ = void 0;
+            }
         }
     }
     /**

package/compiled/src/AP214E3_2010/ap214_model_geometry.d.ts

@@ -13,6 +13,12 @@ export declare class AP214ModelGeometry implements ModelGeometry {
     /**
      * Add a mesh to this geometry collection.
      *
+     * Freezes the native float vertex mirror at add time, exactly like
+     * IfcModelGeometry.add (see its note): consumers read float vertices
+     * whose frame must match the scene transforms, which are authored
+     * against the geometry AS CREATED — later count-preserving native
+     * mutations (normalize's centering) must not shift the served frame.
+     *
      * @param mesh
      * @param parentLocalID
      */

package/compiled/src/AP214E3_2010/ap214_model_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ap214_model_geometry.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_model_geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAqB,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAG7C;;GAEG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IAEtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAE1D;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;OAKG;IACI,GAAG,CAAE,IAAI,EAAE,aAAa,EAAE,aAAa,CAAC,EAAG,MAAM,GAAI,IAAI;IAkBhE;;;;OAIG;IACI,MAAM,CAAE,OAAO,EAAE,MAAM;IAe9B;;OAEG;IACI,iBAAiB,IAAI,IAAI;IAgBhC;;;;;OAKG;IACI,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAIlE;;;;OAIG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI/D;;;OAGG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAI3D;;;OAGG;IACI,qBAAqB,IAAI,MAAM;CAoBvC"}
+{"version":3,"file":"ap214_model_geometry.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_model_geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAqB,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAG7C;;GAEG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IAEtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAE1D;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;;;;;OAWG;IACI,GAAG,CAAE,IAAI,EAAE,aAAa,EAAE,aAAa,CAAC,EAAG,MAAM,GAAI,IAAI;IAsBhE;;;;OAIG;IACI,MAAM,CAAE,OAAO,EAAE,MAAM;IAe9B;;OAEG;IACI,iBAAiB,IAAI,IAAI;IAgBhC;;;;;OAKG;IACI,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAIlE;;;;OAIG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI/D;;;OAGG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAI3D;;;OAGG;IACI,qBAAqB,IAAI,MAAM;CAoBvC"}

package/compiled/src/AP214E3_2010/ap214_model_geometry.js

@@ -16,10 +16,19 @@ export class AP214ModelGeometry {
     /**
      * Add a mesh to this geometry collection.
      *
+     * Freezes the native float vertex mirror at add time, exactly like
+     * IfcModelGeometry.add (see its note): consumers read float vertices
+     * whose frame must match the scene transforms, which are authored
+     * against the geometry AS CREATED — later count-preserving native
+     * mutations (normalize's centering) must not shift the served frame.
+     *
      * @param mesh
      * @param parentLocalID
      */
     add(mesh, parentLocalID) {
+        if (mesh.type === CanonicalMeshType.BUFFER_GEOMETRY) {
+            mesh.geometry.GetVertexData();
+        }
         this.meshes_.set(mesh.localID, mesh);
         if (parentLocalID !== void 0) {
             let children = this.children_.get(parentLocalID);

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

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

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

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

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

@@ -0,0 +1,150 @@
+/* eslint-disable no-magic-numbers */
+// STEP demand parity phase 1: the streamed columnar open for AP214 must
+// reproduce the classic open exactly — same entities, same placed
+// instances and transforms, and byte-identical GetGeometry vertex
+// content (the served float frame must match the scene transforms; see
+// AP214ModelGeometry.add's mirror-freeze note).
+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 };
+// Fixtures with real served geometry (as1-assembly is structure-only —
+// zero meshes even classically; ap214-multibody-part's geometry ids
+// serve no vertex data through GetGeometry on the classic path either).
+const FIXTURES = [
+    "data/nema-23-76mm.step",
+    "data/a-gear-with-3-inch-diameter-and-20-curved-teeth.step",
+];
+let api;
+/**
+ * Capture per-entity placed instances from a model.
+ *
+ * @param modelID The open model.
+ * @return {Map} expressID -> {geometryExpressID, flatTransformation}[].
+ */
+function capture(modelID) {
+    const instances = new Map();
+    api.StreamAllMeshes(modelID, (mesh) => {
+        const list = instances.get(mesh.expressID) ?? [];
+        for (let where = 0; where < mesh.geometries.size(); ++where) {
+            const placed = mesh.geometries.get(where);
+            list.push({
+                geometryExpressID: placed.geometryExpressID,
+                flatTransformation: [...placed.flatTransformation],
+            });
+        }
+        instances.set(mesh.expressID, list);
+    });
+    return instances;
+}
+beforeAll(async () => {
+    api = new IfcAPI();
+    await api.Init();
+}, 120000);
+describe("OpenModelStreamed on AP214 STEP input", () => {
+    test.each(FIXTURES)("streamed open matches classic exactly: %s", async (fixture) => {
+        const data = new Uint8Array(fs.readFileSync(fixture));
+        const classicID = api.OpenModel(data, SETTINGS);
+        const classic = capture(classicID);
+        expect(classic.size).toBeGreaterThan(0);
+        const streamedID = await api.OpenModelStreamed(data, SETTINGS);
+        expect(streamedID).toBeGreaterThanOrEqual(0);
+        const streamed = capture(streamedID);
+        expect(streamed.size).toBe(classic.size);
+        for (const [expressID, classicList] of classic) {
+            const streamedList = streamed.get(expressID);
+            expect(streamedList).toBeDefined();
+            expect(streamedList.length).toBe(classicList.length);
+            for (let where = 0; where < classicList.length; ++where) {
+                expect(streamedList[where].geometryExpressID)
+                    .toBe(classicList[where].geometryExpressID);
+                expect(streamedList[where].flatTransformation)
+                    .toEqual(classicList[where].flatTransformation);
+            }
+        }
+        // Vertex content: the streamed open's GetGeometry must serve
+        // byte-identical floats to classic for every placed geometry.
+        const geometryIDs = new Set();
+        for (const list of classic.values()) {
+            for (const placed of list) {
+                geometryIDs.add(placed.geometryExpressID);
+            }
+        }
+        let compared = 0;
+        for (const geometryID of geometryIDs) {
+            const classicGeometry = api.GetGeometry(classicID, geometryID);
+            const streamedGeometry = api.GetGeometry(streamedID, geometryID);
+            const classicSize = classicGeometry.GetVertexDataSize();
+            if (classicSize === 0) {
+                continue;
+            }
+            expect(streamedGeometry.GetVertexDataSize()).toBe(classicSize);
+            expect(api.GetVertexArray(streamedGeometry.GetVertexData(), classicSize))
+                .toEqual(api.GetVertexArray(classicGeometry.GetVertexData(), classicSize));
+            ++compared;
+        }
+        expect(compared).toBeGreaterThan(0);
+        // No CloseModel here: closing destroys the shared wasm processor
+        // and poisons later opens (pre-existing multi-open quirk).
+    }, 240000);
+    test.each(FIXTURES)("deferred unit pump to completion matches classic exactly: %s", async (fixture) => {
+        const data = new Uint8Array(fs.readFileSync(fixture));
+        const classicID = api.OpenModel(data, SETTINGS);
+        const classic = capture(classicID);
+        expect(classic.size).toBeGreaterThan(0);
+        const deferredID = await api.OpenModelStreamed(data, { ...SETTINGS, DEFER_GEOMETRY: true });
+        expect(deferredID).toBeGreaterThanOrEqual(0);
+        // Pump in deliberately small unit batches, accumulating delta
+        // emissions additively per entity.
+        const pumped = new Map();
+        let rounds = 0;
+        for (;;) {
+            const { extracted, remaining } = api.ExtractGeometryBatch(deferredID, 2, (mesh) => {
+                const list = pumped.get(mesh.expressID) ?? [];
+                for (let where = 0; where < mesh.geometries.size(); ++where) {
+                    const placed = mesh.geometries.get(where);
+                    list.push({
+                        geometryExpressID: placed.geometryExpressID,
+                        flatTransformation: [...placed.flatTransformation],
+                    });
+                }
+                pumped.set(mesh.expressID, list);
+            });
+            ++rounds;
+            if (remaining === 0 && extracted === 0) {
+                break;
+            }
+        }
+        expect(rounds).toBeGreaterThan(1);
+        expect(pumped.size).toBe(classic.size);
+        for (const [expressID, classicList] of classic) {
+            const pumpedList = pumped.get(expressID);
+            expect(pumpedList).toBeDefined();
+            expect(pumpedList.length).toBe(classicList.length);
+            // Instance sets match (order may differ across unit batches):
+            // every classic instance has an exactly-matching pumped one.
+            const unmatched = pumpedList.map((entry) => entry);
+            for (const reference of classicList) {
+                const matchIndex = unmatched.findIndex((candidate) => candidate.geometryExpressID === reference.geometryExpressID &&
+                    candidate.flatTransformation.every((value, where) => Math.abs(value - reference.flatTransformation[where]) < 1e-9));
+                expect(matchIndex).toBeGreaterThanOrEqual(0);
+                unmatched.splice(matchIndex, 1);
+            }
+        }
+        // No CloseModel: closing destroys the shared wasm processor and
+        // degrades later opens (pre-existing multi-open quirk).
+    }, 240000);
+    test("StreamAllMeshes on a deferred STEP model drains the pump and matches classic", async () => {
+        const data = new Uint8Array(fs.readFileSync(FIXTURES[0]));
+        const classicID = api.OpenModel(data, SETTINGS);
+        const classic = capture(classicID);
+        const deferredID = await api.OpenModelStreamed(data, { ...SETTINGS, DEFER_GEOMETRY: true });
+        // No pump calls at all — the whole-model consumer must still get
+        // the complete mesh set (the proxy drains internally).
+        const drained = capture(deferredID);
+        expect(drained.size).toBe(classic.size);
+        for (const [expressID, classicList] of classic) {
+            expect(drained.get(expressID)?.length).toBe(classicList.length);
+        }
+    }, 240000);
+});

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;;;;;;;;;;;;;;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;IAyB5E;;;;;;;;;;;;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;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;;;;;;;;;;;;;;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;;;;;;;;;;;;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"}

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

@@ -95,6 +95,25 @@ export class IfcApiModelPassthroughFactory {
                     `falling back to classic open: ${message}`);
             }
         }
+        // STEP demand parity: AP214 (and the AP203/AP242 fall-throughs)
+        // get the streamed columnar open — index columnar from birth, no
+        // per-record object phase — and, with DEFER_GEOMETRY, the deferred
+        // assembly-tree unit pump (phase 2), so STEP models stream
+        // progressively through ExtractGeometryBatch just like IFC.
+        if (modelFormat === ModelFormatType.AP214 ||
+            modelFormat === ModelFormatType.AP203 ||
+            modelFormat === ModelFormatType.AP242) {
+            try {
+                return settings?.DEFER_GEOMETRY === true ?
+                    await IfcApiProxyAP214.createDeferred(modelID, data, wasmModule, settings) :
+                    await IfcApiProxyAP214.createStreamed(modelID, data, wasmModule, settings);
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                Logger.warning(`Streamed STEP open failed for model ${modelID}, ` +
+                    `falling back to classic open: ${message}`);
+            }
+        }
         return IfcApiModelPassthroughFactory.fromAsync(modelID, data, wasmModule, settings);
     }
     /**

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

@@ -17,6 +17,8 @@ import { StepHeader } from "../../step/parsing/step_parser.js";
  */
 interface Ap214ProxyLoadState {
     conwaywasm: ConwayGeometry;
+    /** True when opened without extraction (createDeferred). */
+    deferred?: boolean;
     allTimeStart: number;
     stepHeader: StepHeader;
     model: AP214StepModel;
@@ -47,6 +49,24 @@ export declare class IfcApiProxyAP214 implements IfcApiModelPassthrough {
         glmatrix.mat4
     ];
     conwaywasm: ConwayGeometry;
+    /** The extraction behind this model (drives the deferred unit pump). */
+    private conwayGeometry_;
+    /** Was this model opened without extraction (DEFER_GEOMETRY)? */
+    private deferredMode_;
+    /** Has finishDemandExtraction run (deferred models, once)? */
+    private demandFinished_;
+    /**
+     * 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.
+     */
+    private readonly demandCapturedCounts_;
+    /**
+     * Coordination matrix the deferred capture derived. Internal
+     * multi-call memory only — getCoordinationMatrix keeps the classic
+     * identity contract (see the IFC proxy's demandCoordination_ note).
+     */
+    private demandCoordination_?;
     _isCoordinated: boolean;
     linearScalingFactor: number;
     identity: number[];
@@ -119,6 +139,52 @@ export declare class IfcApiProxyAP214 implements IfcApiModelPassthrough {
      * @return {Promise<IfcApiProxyAP214>} The constructed proxy.
      */
     static createAsync(modelID: number, data: Uint8Array, wasmModule: any, settings?: Loadersettings): Promise<IfcApiProxyAP214>;
+    /**
+     * 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 createStreamed(modelID: number, data: Uint8Array, wasmModule: any, settings?: Loadersettings): Promise<IfcApiProxyAP214>;
+    /**
+     * 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 createDeferred(modelID: number, data: Uint8Array, wasmModule: any, settings?: Loadersettings): Promise<IfcApiProxyAP214>;
+    /**
+     * 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.
+     */
+    private static parseColumnarAndExtractAsync;
     /**
      * Log + record the header parse result on the model statistics.
      *
@@ -280,6 +346,42 @@ export declare class IfcApiProxyAP214 implements IfcApiModelPassthrough {
      * @param modelID
      * @param meshCallback
      */
+    /**
+     * 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: number, meshCallback?: (mesh: FlatMesh) => void): {
+        extracted: number;
+        remaining: number;
+    };
+    /**
+     * 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.
+     */
+    private streamNewMeshes_;
+    /**
+     *
+     * @param meshCallback
+     */
     streamAllMeshes(meshCallback: (mesh: FlatMesh) => void): void;
     /**
      *