@bldrs-ai/conway 1.424.1275 → 1.426.1283

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

@@ -0,0 +1,185 @@
+/* eslint-disable no-magic-numbers */
+// Parse-time preview channel (demand/tiled rendering slice A2): prefix
+// snapshots of the live columnar sink must be exact prefixes of the final
+// columns, and a full drain of the channel (prefix == whole file) must
+// reproduce the classic StreamAllMeshes instance set — same entities,
+// same geometry ids, same placed transforms — since the durable pump the
+// preview hands over to is already pinned to classic parity.
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { ConwayGeometry } from "../../../dependencies/conway-geom/index.js";
+import IfcStepParser from "../../ifc/ifc_step_parser.js";
+import { BufferByteSource } from "../../step/parsing/byte_source.js";
+import { ColumnarIndexSink, } from "../../step/parsing/columnar_index.js";
+import { ParseResult } from "../../step/parsing/step_parser.js";
+import { buildIndexStreaming } from "../../step/parsing/streaming_index_builder.js";
+import { IfcAPI } from "./ifc_api.js";
+import { StreamedPreviewChannel, } from "./streamed_preview_channel.js";
+const SETTINGS = { COORDINATE_TO_ORIGIN: true, USE_FAST_BOOLS: true };
+const POOL = 1024 * 1024;
+let api;
+let conwayGeometry;
+let data;
+/**
+ * Parse index.ifc's data block into a fresh columnar sink.
+ *
+ * @param wrap Optional sink wrapper (snapshot triggers).
+ * @return {ColumnarIndexSink} The filled sink.
+ */
+function buildSink(wrap) {
+    const sink = new ColumnarIndexSink();
+    const { result } = buildIndexStreaming(new BufferByteSource(data), IfcStepParser.Instance, POOL, void 0, wrap !== void 0 ? wrap(sink) : sink);
+    expect(result).toBe(ParseResult.COMPLETE);
+    return sink;
+}
+/**
+ * Classic reference: expressID -> list of placed instances.
+ *
+ * @param modelID An open classic model.
+ * @return {Map} expressID -> {geometryExpressID, flatTransformation}[].
+ */
+function classicInstances(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();
+    conwayGeometry = new ConwayGeometry();
+    expect(await conwayGeometry.initialize()).toBe(true);
+    data = new Uint8Array(fs.readFileSync("data/index.ifc"));
+}, 120000);
+describe("ColumnarIndexSink.snapshot", () => {
+    test("a mid-parse snapshot is an exact prefix of the final columns", () => {
+        const snapshotAt = 50;
+        let snapshot;
+        const sink = buildSink((inner) => ({
+            pushTopLevel: (entry) => {
+                inner.pushTopLevel(entry);
+                if (inner.topLevelCount === snapshotAt) {
+                    snapshot = inner.snapshot();
+                }
+            },
+            reset: () => inner.reset(),
+        }));
+        const full = sink.finalize();
+        expect(snapshot).toBeDefined();
+        expect(snapshot.firstInlineElement).toBe(snapshotAt);
+        expect(full.firstInlineElement).toBeGreaterThan(snapshotAt);
+        for (let where = 0; where < snapshotAt; ++where) {
+            expect(snapshot.address[where]).toBe(full.address[where]);
+            expect(snapshot.length[where]).toBe(full.length[where]);
+            expect(snapshot.typeID[where]).toBe(full.typeID[where]);
+            expect(snapshot.expressID[where]).toBe(full.expressID[where]);
+        }
+    });
+    test("snapshotting does not disturb the sink (finalize sees everything)", () => {
+        const undisturbed = buildSink().finalize();
+        const snapshotted = buildSink((inner) => ({
+            pushTopLevel: (entry) => {
+                inner.pushTopLevel(entry);
+                // Snapshot aggressively — every 25 records.
+                if (inner.topLevelCount % 25 === 0) {
+                    inner.snapshot();
+                }
+            },
+            reset: () => inner.reset(),
+        })).finalize();
+        expect(snapshotted.count).toBe(undisturbed.count);
+        expect(snapshotted.firstInlineElement).toBe(undisturbed.firstInlineElement);
+        expect([...snapshotted.address]).toEqual([...undisturbed.address]);
+        expect([...snapshotted.expressID]).toEqual([...undisturbed.expressID]);
+    });
+});
+describe("StreamedPreviewChannel", () => {
+    test("a full drain reproduces the classic instance set exactly", async () => {
+        const classicID = api.OpenModel(data, SETTINGS);
+        const classic = classicInstances(classicID);
+        let classicTotal = 0;
+        for (const list of classic.values()) {
+            classicTotal += list.length;
+        }
+        expect(classicTotal).toBeGreaterThan(0);
+        // Channel over a finished sink: the "prefix" is the whole file, so a
+        // drain must be a complete, classic-parity extraction.
+        const sink = buildSink();
+        const payloads = [];
+        const channel = new StreamedPreviewChannel(data, conwayGeometry, sink, true, (mesh) => payloads.push(mesh), void 0, void 0, 1);
+        channel.drainForTest();
+        expect(payloads.length).toBe(classicTotal);
+        // Every payload matches a classic instance of the same entity and
+        // geometry, with the same placed transform.
+        const unmatched = new Map();
+        for (const [expressID, list] of classic) {
+            unmatched.set(expressID, list.map((entry) => ({ ...entry })));
+        }
+        for (const payload of payloads) {
+            const candidates = unmatched.get(payload.expressID);
+            expect(candidates).toBeDefined();
+            const matchIndex = candidates.findIndex((candidate) => candidate.geometryExpressID === payload.geometryExpressID &&
+                candidate.flatTransformation.every((value, where) => Math.abs(value - payload.flatTransformation[where]) < 0.000001));
+            expect(matchIndex).toBeGreaterThanOrEqual(0);
+            candidates.splice(matchIndex, 1);
+        }
+        // Geometry payloads: exactly one carrier per distinct geometry, each
+        // carrying a sane interleaved buffer.
+        const carriers = payloads.filter((payload) => payload.vertexData !== void 0);
+        const distinctGeometry = new Set(payloads.map((p) => p.geometryExpressID));
+        expect(carriers.length).toBe(distinctGeometry.size);
+        for (const carrier of carriers) {
+            expect(carrier.vertexData.length % 6).toBe(0);
+            expect(carrier.vertexData.length).toBeGreaterThan(0);
+            expect(carrier.indexData.length % 3).toBe(0);
+            expect(carrier.indexData.length).toBeGreaterThan(0);
+        }
+        // The channel derived and pinned a coordination frame (proved
+        // equivalent to classic's by the transform parity above), and the
+        // deferred open must keep the classic GetCoordinationMatrix
+        // contract: identity, because placed transforms are premultiplied
+        // and consumers stamp the result onto assembled models — a
+        // non-identity return would coordinate twice.
+        expect(channel.coordinationMatrix).toBeDefined();
+        const deferredID = await api.OpenModelStreamed(data, { ...SETTINGS, DEFER_GEOMETRY: true });
+        api.StreamAllMeshes(deferredID, () => { });
+        const classicCoordination = api.GetCoordinationMatrix(classicID);
+        const deferredCoordination = api.GetCoordinationMatrix(deferredID);
+        expect(deferredCoordination).toEqual(classicCoordination);
+        api.CloseModel(classicID);
+        api.CloseModel(deferredID);
+    }, 240000);
+    test("ON_PREVIEW_MESH on a deferred streamed open never breaks the durable path", async () => {
+        const classicID = api.OpenModel(data, SETTINGS);
+        const classic = classicInstances(classicID);
+        const payloads = [];
+        const deferredID = await api.OpenModelStreamed(data, {
+            ...SETTINGS,
+            DEFER_GEOMETRY: true,
+            ON_PREVIEW_MESH: (mesh) => payloads.push(mesh),
+        });
+        expect(deferredID).toBeGreaterThanOrEqual(0);
+        // index.ifc parses inside one cooperative slice, so the timer-driven
+        // channel usually never fires — the contract here is that its presence
+        // changes nothing about the durable pump's output.
+        const drained = new Map();
+        api.StreamAllMeshes(deferredID, (mesh) => {
+            drained.set(mesh.expressID, (drained.get(mesh.expressID) ?? 0) + mesh.geometries.size());
+        });
+        expect(drained.size).toBe(classic.size);
+        for (const [expressID, list] of classic) {
+            expect(drained.get(expressID)).toBe(list.length);
+        }
+        api.CloseModel(classicID);
+        api.CloseModel(deferredID);
+    }, 240000);
+});

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

@@ -20,6 +20,9 @@ interface IfcProxyLoadState {
     conwaywasm: ConwayGeometry;
     /** True when opened without extraction (createDeferred). */
     deferred?: boolean;
+    /** Coordination matrix the parse-time preview channel derived (slice
+     * A2) — adopted by the durable capture so both share one frame. */
+    previewCoordinationMatrix?: glmatrix.mat4;
     allTimeStart: number;
     stepHeader: StepHeader;
     model: IfcStepModel;
@@ -57,8 +60,28 @@ export declare class IfcApiProxyIfc implements IfcApiModelPassthrough {
     private deferredMode_;
     /** Deferred-mode product worklist (file order), lazily enumerated. */
     private demandProducts_?;
+    /**
+     * Deferred capture watermarks: entity localID -> how many of its
+     * placed instances (in scene-walk order) have been captured. Shared
+     * (mapped) geometry attributes instances to an entity from OTHER
+     * products' extractions, so an entity's instance set grows across
+     * batches - the watermark makes each instance captured exactly once,
+     * in the same order the classic single walk would process it.
+     */
+    private readonly demandCapturedCounts_;
     /** Cursor into demandProducts_ — products before it are extracted. */
     private demandCursor_;
+    /**
+     * Coordination matrix the deferred capture derived (or adopted from
+     * the parse-time preview channel). Kept OFF the model tuple's slot 5
+     * deliberately: classic streamAllMeshes derives its coordination into
+     * a local and getCoordinationMatrix therefore returns identity —
+     * consumers (Share) stamp that result onto the assembled model, so a
+     * deferred open must present the same identity or coordination would
+     * apply twice. This field is only the pump's internal multi-call
+     * memory.
+     */
+    private demandCoordination_?;
     _isCoordinated: boolean;
     linearScalingFactor: number;
     identity: number[];
@@ -393,17 +416,26 @@ export declare class IfcApiProxyIfc implements IfcApiModelPassthrough {
         remaining: number;
     };
     /**
-     * Walk the scene and emit FlatMeshes for the given entities only —
-     * the filtered core of streamAllMeshes with identical placed-geometry
-     * math. Also fixes a latent multi-call bug: the derived coordination
-     * matrix is stored back to the model tuple, so later batches place
+     * Walk the scene and emit every not-yet-captured placed instance as
+     * per-entity DELTA FlatMeshes — the incremental core of
+     * streamAllMeshes with identical placed-geometry math, processed in
+     * walk order exactly once per instance (per-entity watermarks). An
+     * entity re-emits with only its NEW instances when shared/mapped
+     * geometry attributes more to it in later batches; consumers render
+     * deltas additively (the shared meshMap still accumulates each
+     * entity's FULL vector, so getFlatMesh stays whole-model correct).
+     *
+     * Also fixes a latent multi-call bug: the derived coordination
+     * matrix is remembered (demandCoordination_), so later batches place
      * with the SAME coordination the first batch established
-     * (streamAllMeshes never needed this — it runs once).
+     * (streamAllMeshes never needed this — it runs once). It is NOT
+     * exposed through getCoordinationMatrix, which keeps the classic
+     * identity contract consumers stamp onto assembled models.
      *
-     * @param entityFilter Entity localIDs whose meshes to emit.
-     * @param meshCallback Receives one FlatMesh per matched entity.
+     * @param meshCallback Receives one delta FlatMesh per entity that
+     * gained instances this call.
      */
-    private streamMeshesForEntities_;
+    private streamNewMeshes_;
     /**
      *
      * @param modelID

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

@@ -1 +1 @@
-{"version":3,"file":"ifc_api_proxy_ifc.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_proxy_ifc.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ifc_api_proxy_ifc.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_proxy_ifc.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,cAAc,EACf,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,YAAY,MAAM,0BAA0B,CAAA;AACnD,OAAO,EACL,QAAQ,EACR,WAAW,EACX,WAAW,EACX,cAAc,EACd,cAAc,EACd,WAAW,EACX,MAAM,EACP,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,QAAQ,MAAM,WAAW,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAchD,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAA;AAmBzE;;;;;GAKG;AACH,UAAU,iBAAiB;IACzB,UAAU,EAAE,cAAc,CAAA;IAC1B,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;uEACmE;IACnE,yBAAyB,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAA;IACzC,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,UAAU,CAAA;IACtB,KAAK,EAAE,YAAY,CAAA;IACnB,KAAK,EAAE,eAAe,CAAA;IACtB,cAAc,EAAE,qBAAqB,CAAA;IACrC,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED;;GAEG;AACH,qBAAa,cAAe,YAAW,sBAAsB;aAuEvC,OAAO,EAAE,MAAM;IAE/B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAxE9B,EAAE,CAAC,EAAE,GAAG,CAAY;IAEpB,KAAK,EACH;QAAC,YAAY;QACX,eAAe;QACf,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC/C,GAAG,CAAC,MAAM,EAAE,CAAC,cAAc,EAAE,iBAAiB,EAAE,MAAM,EAAE,CAAC,CAAC;QAE1D,MAAM,CAAC,QAAQ,CAAC;QAAE,QAAQ,CAAC,IAAI;KAAC,CAAA;IACpC,UAAU,EAAE,cAAc,CAAA;IAE1B,yEAAyE;IACzE,OAAO,CAAC,eAAe,CAAuB;IAE9C,iEAAiE;IACjE,OAAO,CAAC,aAAa,CAAiB;IAEtC,sEAAsE;IACtE,OAAO,CAAC,eAAe,CAAC,CAAU;IAElC;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAA4B;IAElE,sEAAsE;IACtE,OAAO,CAAC,aAAa,CAAI;IAEzB;;;;;;;;;OASG;IACH,OAAO,CAAC,mBAAmB,CAAC,CAAe;IAE3C,cAAc,EAAE,OAAO,CAAQ;IAC/B,mBAAmB,EAAE,MAAM,CAAI;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAmD;IAGrE,YAAY,EAAE,QAAQ,CAAC,IAAI,CAK1B;IAED;;OAEG;IACH,UAAU,gBAA0B;IAEpC;;;;OAIG;gBAGiB,OAAO,EAAE,MAAM,EAC/B,IAAI,EAAE,UAAU,EACC,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,YAAA,EAC1C,WAAW,CAAC,EAAE,iBAAiB;IAmKnC;;;;;;;;;;OAUG;WACiB,WAAW,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,OAAO,CAAC,cAAc,CAAC;IAQxD;;;;;;;;;;;;;;;OAeG;WACiB,cAAc,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,OAAO,CAAC,cAAc,CAAC;IAQxD;;;;;;;;;;;;;;;OAeG;WACiB,cAAc,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,OAAO,CAAC,cAAc,CAAC;IAQxD;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAwCtC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAU1B;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAsF9B;;;;;;;;;OASG;mBACkB,oBAAoB;IAsFzC;;;;;;;;;;;;;;;;;;;;;;OAsBG;mBACkB,4BAA4B;IA+IjD;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IA4BxC;;;;;OAKG;IACH,WAAW,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,MAAM;IAM9C;;;;OAIG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAO5C;;;;;;OAMG;IACH,WAAW,CAAC,iBAAiB,EAAE,MAAM,GAAG,WAAW;IA8BnD;;;;;;OAMG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe;IA0BnD;;;;;;;;;;;;OAYG;IACH,qBAAqB,CAAC,SAAS,EAAE,MAAM,GACrC;QAAE,IAAI,CAAC,EAAE,eAAe,CAAC;QACvB,QAAQ,CAAC,EAAE,eAAe,CAAC;QAC3B,QAAQ,CAAC,EAAE,eAAe,CAAA;KAAE;IAoChC;;;;;;OAMG;IACH,kBAAkB,IAAI,IAAI;IAI1B;;;;;OAKG;IACH,IAAI,gBAAgB,IAAI,OAAO,CAE9B;IAED;;;;;;;;;;OAUG;IACH,0BAA0B,CACtB,KAAK,EAAE,qBAAqB,EAC5B,UAAU,CAAC,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,GAAI,IAAI;IAItC;;;;;;;;;;;OAWG;IACG,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1D;;;;;;;;;;;OAWG;IACH,cAAc,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAI1C;;;;OAIG;IACH,iBAAiB,IAAI,MAAM,CAAC,WAAW,CAAC;IAoBxC;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,GAAG;IAIzB;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI;IAkB5B;;;;;OAKG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW;IAgD9C;;;;OAIG;IACH,gBAAgB,CAAC,IAAI,EAAE,WAAW;IAIlC;;;;;OAKG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IA6ChD;;;;OAIG;IACH,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC;IA0C7B;;;;OAIG;IACH,yBAAyB,CAAC,oBAAoB,EAAE,KAAK,CAAC,MAAM,CAAC;IAU7D;;;;OAIG;IACH,qBAAqB,IAAI,KAAK,CAAC,MAAM,CAAC;IActC;;;;;OAKG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY;IAIvD;;;;;OAKG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW;IAIrD;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAC/E,YAAY,GAAG,WAAW;IAK5B;;;;OAIG;IACH,UAAU;IAIV;;;;;;;;;;;;;;;;;OAiBG;IACH,oBAAoB,CAChB,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAI;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC;IA6CrF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,gBAAgB;IA8KxB;;;;OAIG;IACH,eAAe,CAAE,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI;IAmPvD;;;;;OAKG;IACH,wBAAwB,CACpB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,EACpB,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI;IA+O1C;;;;OAIG;IACH,eAAe,IAAI,MAAM,CAAC,QAAQ,CAAC;IA0RnC;;;;;OAKG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ;IAqDxC;;;;;OAKG;IACH,4BAA4B,IAAI,IAAI;CAwBrC"}

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

@@ -9,7 +9,9 @@ import { extractModelInfo } from "../../loaders/loading_utilities.js";
 import IfcStepParser from "../../ifc/ifc_step_parser.js";
 import ParsingBuffer from "../../parsing/parsing_buffer.js";
 import { BufferByteSource } from "../../step/parsing/byte_source.js";
-import { buildColumnarIndexStreamingAsync, } from "../../step/parsing/streaming_index_builder.js";
+import { buildIndexStreamingAsync, } from "../../step/parsing/streaming_index_builder.js";
+import { ColumnarIndexSink } from "../../step/parsing/columnar_index.js";
+import { StreamedPreviewChannel } from "./streamed_preview_channel.js";
 import { ExtractResult } from "../../index.js";
 import { IfcGeometryExtraction } from "../../ifc/ifc_geometry_extraction.js";
 import { ParseResult } from "../../index.js";
@@ -19,6 +21,9 @@ import { shimIfcEntityMap, shimIfcEntityReverseMap } from "./shim_schema_mapping
 import { EntityTypesIfcCount } from "../../ifc/ifc4_gen/entity_types_ifc.gen.js";
 import { IfcProduct, IfcRoot } from "../../ifc/ifc4_gen/index.js";
 import { CanonicalMeshType } from "../../index.js";
+// Batch size used when a whole-model consumer (streamAllMeshes) drains
+// a deferred model's remaining products synchronously.
+const DEFERRED_DRAIN_BATCH = 256;
 /* Moving-window size for the streamed columnar parse (matches the
  * ifc_stream_open default; the window bounds parse-time scratch, not
  * the source buffer, which the model keeps resident here). */
@@ -41,6 +46,15 @@ export class IfcApiProxyIfc {
         this.fs = undefined;
         /** Was this model opened without extraction (DEFER_GEOMETRY)? */
         this.deferredMode_ = false;
+        /**
+         * Deferred capture watermarks: entity localID -> how many of its
+         * placed instances (in scene-walk order) have been captured. Shared
+         * (mapped) geometry attributes instances to an entity from OTHER
+         * products' extractions, so an entity's instance set grows across
+         * batches - the watermark makes each instance captured exactly once,
+         * in the same order the classic single walk would process it.
+         */
+        this.demandCapturedCounts_ = new Map();
         /** Cursor into demandProducts_ — products before it are extracted. */
         this.demandCursor_ = 0;
         this._isCoordinated = false;
@@ -138,6 +152,15 @@ export class IfcApiProxyIfc {
         ];
         // save settings
         this.settings = settings;
+        // Deferred opens whose preview channel already established the
+        // coordination frame: adopt it, so the durable capture skips its own
+        // derivation and places exactly where the preview did. (Internal
+        // only — getCoordinationMatrix stays identity, see
+        // demandCoordination_.)
+        if (this.deferredMode_ && loadState.previewCoordinationMatrix !== void 0) {
+            this.demandCoordination_ = loadState.previewCoordinationMatrix;
+            this._isCoordinated = true;
+        }
         let FILE_NAME = stepHeader.headers.get("FILE_NAME");
         if (FILE_NAME !== void 0) {
             // strip start / end parenthesis
@@ -439,7 +462,21 @@ export class IfcApiProxyIfc {
         const parseTick = tracker !== void 0 ?
             (cursorBytes) => tracker.update(cursorBytes) : void 0;
         const parseStartTime = Date.now();
-        const { columns, result } = await buildColumnarIndexStreamingAsync(new BufferByteSource(data), parser, STREAMED_PARSE_POOL_BYTES, void 0, parseTick);
+        // Inline twin of buildColumnarIndexStreamingAsync — the sink is created
+        // here so the parse-time preview channel (slice A2) can watch it grow
+        // and snapshot prefix models between the parse's cooperative yields.
+        const sink = new ColumnarIndexSink();
+        const previewChannel = deferGeometry && settings?.ON_PREVIEW_MESH !== void 0 ?
+            new StreamedPreviewChannel(data, conwaywasm, sink, settings.COORDINATE_TO_ORIGIN === true, settings.ON_PREVIEW_MESH) : void 0;
+        previewChannel?.start();
+        let result;
+        try {
+            ({ result } = await buildIndexStreamingAsync(new BufferByteSource(data), parser, STREAMED_PARSE_POOL_BYTES, void 0, sink, parseTick));
+        }
+        finally {
+            previewChannel?.stop();
+        }
+        const columns = sink.finalize();
         const parseEndTime = Date.now();
         tracker?.endPhase(data.length);
         if (result !== ParseResult.COMPLETE) {
@@ -460,6 +497,10 @@ export class IfcApiProxyIfc {
             return {
                 conwaywasm,
                 deferred: true,
+                // Pin the durable pump's coordination to the preview channel's
+                // (derived from the same first instance with the same math), so
+                // preview payloads and durable meshes share one frame.
+                previewCoordinationMatrix: previewChannel?.coordinationMatrix,
                 allTimeStart,
                 stepHeader,
                 model,
@@ -990,40 +1031,57 @@ export class IfcApiProxyIfc {
             this.demandCursor_ = 0;
         }
         const end = Math.min(this.demandCursor_ + Math.max(batchSize, 1), this.demandProducts_.length);
-        const batch = new Set();
+        let extracted = 0;
         for (; this.demandCursor_ < end; ++this.demandCursor_) {
             const localID = this.demandProducts_[this.demandCursor_];
             if (this.conwayGeometry_.extractProductGeometryByLocalID(localID)) {
-                batch.add(localID);
+                ++extracted;
             }
         }
-        if (meshCallback !== void 0 && batch.size > 0) {
-            this.streamMeshesForEntities_(batch, meshCallback);
+        if (meshCallback !== void 0) {
+            this.streamNewMeshes_(meshCallback);
         }
         return {
-            extracted: batch.size,
+            extracted,
             remaining: this.demandProducts_.length - this.demandCursor_,
         };
     }
     /**
-     * Walk the scene and emit FlatMeshes for the given entities only —
-     * the filtered core of streamAllMeshes with identical placed-geometry
-     * math. Also fixes a latent multi-call bug: the derived coordination
-     * matrix is stored back to the model tuple, so later batches place
+     * Walk the scene and emit every not-yet-captured placed instance as
+     * per-entity DELTA FlatMeshes — the incremental core of
+     * streamAllMeshes with identical placed-geometry math, processed in
+     * walk order exactly once per instance (per-entity watermarks). An
+     * entity re-emits with only its NEW instances when shared/mapped
+     * geometry attributes more to it in later batches; consumers render
+     * deltas additively (the shared meshMap still accumulates each
+     * entity's FULL vector, so getFlatMesh stays whole-model correct).
+     *
+     * Also fixes a latent multi-call bug: the derived coordination
+     * matrix is remembered (demandCoordination_), so later batches place
      * with the SAME coordination the first batch established
-     * (streamAllMeshes never needed this — it runs once).
+     * (streamAllMeshes never needed this — it runs once). It is NOT
+     * exposed through getCoordinationMatrix, which keeps the classic
+     * identity contract consumers stamp onto assembled models.
      *
-     * @param entityFilter Entity localIDs whose meshes to emit.
-     * @param meshCallback Receives one FlatMesh per matched entity.
+     * @param meshCallback Receives one delta FlatMesh per entity that
+     * gained instances this call.
      */
-    streamMeshesForEntities_(entityFilter, meshCallback) {
+    streamNewMeshes_(meshCallback) {
         const [model, scene, meshMap, geometryMaterialTransformMap] = this.model;
-        let coordinationMatrix = this.model[5];
-        const emitted = new Set();
+        let coordinationMatrix = this.demandCoordination_ ?? glmatrix.mat4.create();
+        const seenThisPass = new Map();
+        const deltas = new Map();
         // eslint-disable-next-line no-unused-vars
         for (const [_, nativeTransform, geometry, material, entity] of scene.walk()) {
-            if (entity?.localID === void 0 || !entityFilter.has(entity.localID) ||
-                entity.expressID === void 0) {
+            if (entity?.localID === void 0 || entity.expressID === void 0) {
+                continue;
+            }
+            // Per-entity walk position vs watermark: instances before the
+            // watermark were captured in an earlier call (append-only walk
+            // order makes the count a stable cursor).
+            const walkIndex = seenThisPass.get(entity.localID) ?? 0;
+            seenThisPass.set(entity.localID, walkIndex + 1);
+            if (walkIndex < (this.demandCapturedCounts_.get(entity.localID) ?? 0)) {
                 continue;
             }
             if (geometry.type !== CanonicalMeshType.BUFFER_GEOMETRY || geometry.temporary) {
@@ -1069,8 +1127,9 @@ export class IfcApiProxyIfc {
                 glmatrix.mat4.scale(scaleMatrix, scaleMatrix, scaleVec);
                 glmatrix.mat4.multiply(coordinationMatrix, this.NormalizeMat, coordinationMatrix);
                 glmatrix.mat4.multiply(coordinationMatrix, scaleMatrix, coordinationMatrix);
-                // Persist for every later batch (and getCoordinationMatrix).
-                this.model[5] = coordinationMatrix;
+                // Persist for every later batch (internal only — see
+                // demandCoordination_'s identity-contract note).
+                this.demandCoordination_ = coordinationMatrix;
                 this._isCoordinated = true;
             }
             const newTransform = glmatrix.mat4.create();
@@ -1111,15 +1170,26 @@ export class IfcApiProxyIfc {
             }
             mesh[0].push(placed);
             mesh[1].geometries = mesh[0];
-            emitted.add(entity.expressID);
+            this.demandCapturedCounts_.set(entity.localID, (this.demandCapturedCounts_.get(entity.localID) ?? 0) + 1);
+            let delta = deltas.get(entity.expressID);
+            if (delta === void 0) {
+                delta = [];
+                deltas.set(entity.expressID, delta);
+            }
+            delta.push(placed);
         }
         const vectorFlatMesh = this.model[4];
-        for (const expressID of emitted) {
-            const mesh = meshMap.get(expressID);
-            if (mesh !== void 0) {
-                vectorFlatMesh.push(mesh[1]);
-                meshCallback(mesh[1]);
-            }
+        for (const [expressID, placedList] of deltas) {
+            const placedVector = {
+                get: (index) => placedList[index] ?? placedList[0],
+                size: () => placedList.length,
+                push: (parameter) => {
+                    placedList.push(parameter);
+                },
+            };
+            const deltaMesh = { geometries: placedVector, expressID };
+            vectorFlatMesh.push(deltaMesh);
+            meshCallback(deltaMesh);
         }
     }
     /**
@@ -1128,6 +1198,23 @@ export class IfcApiProxyIfc {
      * @param meshCallback
      */
     streamAllMeshes(meshCallback) {
+        // Deferred models: the delta capture has already populated (or will
+        // populate) the shared meshMap — re-running the classic walk would
+        // push every instance a second time. Pump any remainder to
+        // completion and serve the accumulated full per-entity meshes.
+        if (this.deferredMode_) {
+            const noCallback = void 0;
+            while (this.extractGeometryBatch(DEFERRED_DRAIN_BATCH, noCallback).remaining > 0) {
+                // draining
+            }
+            this.streamNewMeshes_(() => { });
+            const [, , meshMap, , vectorFlatMesh] = this.model;
+            meshMap.forEach((mesh) => {
+                vectorFlatMesh.push(mesh[1]);
+                meshCallback(mesh[1]);
+            });
+            return;
+        }
         const [model, scene, meshMap, geometryMaterialTransformMap, vectorFlatMesh] = this.model;
         let coordinationMatrix = this.model[5];
         // eslint-disable-next-line no-unused-vars

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

@@ -0,0 +1,130 @@
+import { ConwayGeometry } from "../../index.js";
+import EntityTypesIfc from "../../ifc/ifc4_gen/entity_types_ifc.gen.js";
+import { ColumnarIndexSink } from "../../step/parsing/columnar_index.js";
+import * as glmatrix from "gl-matrix";
+/**
+ * One preview mesh instance, self-contained: geometry payload is COPIED out
+ * of the wasm heap at emission, so consumers can upload it directly and
+ * never touch the (still-loading) model. `vertexData` is interleaved
+ * position+normal, 6 floats per vertex, exactly the GetGeometry layout the
+ * classic FlatMesh path reads. For instances sharing geometry with an
+ * earlier emission (mapped items), `vertexData`/`indexData` are omitted and
+ * `geometryExpressID` identifies the earlier payload to reuse.
+ */
+export interface PreviewMeshPayload {
+    expressID: number;
+    geometryExpressID: number;
+    color: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    flatTransformation: number[];
+    vertexData?: Float32Array;
+    indexData?: Uint32Array;
+}
+/**
+ * Parse-time preview channel (demand/tiled rendering slice A2): while the
+ * deferred streamed open is still parsing, periodically snapshot the growing
+ * columnar index into a PREFIX model, extract a bounded number of products
+ * through a throwaway extraction, and emit self-contained mesh payloads —
+ * first pixels within the first seconds of a large parse instead of after
+ * it.
+ *
+ * Preview quality, by construction: IFC relationship records
+ * (IfcRelVoidsElement, IfcRelAssociatesMaterial, styled items) spread to the
+ * very end of real files (measured ~92–97% depth), so a prefix extraction
+ * can miss openings and materials. That is why these extractions are
+ * throwaway: the durable batch pump after the parse re-extracts every
+ * product with the full model and REPLACES the preview — final geometry
+ * parity is untouched by this channel.
+ *
+ * Scheduling: the cooperative parse yields to the event loop via macrotasks
+ * every ~50ms; each pump tick runs in one of those gaps under a hard time
+ * budget, so the parse keeps the bulk of the main thread.
+ *
+ * Product cursor: top-level localIDs are stable across snapshots (dense
+ * parse order) and `types(IfcProduct)` iterates in localID order, so a
+ * single ordinal cursor advances across generations without re-extracting.
+ * Products whose extraction throws mid-parse (unparsed forward references)
+ * are skipped — the durable pump extracts them correctly later.
+ */
+export declare class StreamedPreviewChannel {
+    private readonly data;
+    private readonly conwaywasm;
+    private readonly sink;
+    private readonly coordinateToOrigin;
+    private readonly onMesh;
+    private readonly maxProducts;
+    private readonly maxBytes;
+    private readonly firstGenerationMinRecords;
+    /** Coordination matrix pinned from the first captured instance, exactly
+     * the derivation the durable capture would perform — the proxy adopts it
+     * so preview and durable placements share one frame. */
+    coordinationMatrix?: glmatrix.mat4;
+    private stopped_;
+    private timer_?;
+    private emittedProducts_;
+    private emittedBytes_;
+    /** Ordinal cursor into the (append-stable) product list. */
+    private productOrdinal_;
+    /** Geometry expressIDs whose payload has been emitted (cross-generation
+     * dedup for mapped/shared geometry). */
+    private readonly emittedGeometry_;
+    private generation_?;
+    private lastSnapshotRecords_;
+    /**
+     * @param data The (fully resident) source buffer the parse is indexing.
+     * @param conwaywasm The shared geometry wasm wrapper (sequential use only
+     * — ticks run between parse yields, never concurrently with the durable
+     * extraction, which is created after the parse completes).
+     * @param sink The live columnar sink the streamed parse is filling.
+     * @param coordinateToOrigin The open's COORDINATE_TO_ORIGIN setting.
+     * @param onMesh Consumer callback for each preview payload.
+     * @param maxProducts Cap on products ever preview-extracted.
+     * @param maxBytes Cap on total payload bytes copied out.
+     * @param firstGenerationMinRecords Records required before the first
+     * snapshot (tests lower it for tiny fixtures).
+     */
+    constructor(data: Uint8Array, conwaywasm: ConwayGeometry, sink: ColumnarIndexSink<EntityTypesIfc>, coordinateToOrigin: boolean, onMesh: (mesh: PreviewMeshPayload) => void, maxProducts?: number, maxBytes?: number, firstGenerationMinRecords?: number);
+    /** Begin ticking (call just before awaiting the parse). */
+    start(): void;
+    /**
+     * Stop ticking (call once the parse settles, before finalize/fallback).
+     * Idempotent; no tick runs after this returns (ticks are synchronous and
+     * scheduled on the same event loop).
+     */
+    stop(): void;
+    /** True when a cap was hit and the channel retired itself early. */
+    get capped(): boolean;
+    private schedule_;
+    /**
+     * One pump tick: ensure a generation with pending products exists, then
+     * extract + capture under the time budget.
+     */
+    private tick_;
+    /**
+     * Ensure a generation with pending products: keep the current one while
+     * it has work; otherwise snapshot a fresh prefix model once the index has
+     * grown enough to be worth the copy.
+     *
+     * @return {boolean} True when a generation with pending products exists.
+     */
+    private ensureGeneration_;
+    /**
+     * Walk the current generation's scene and emit every not-yet-captured
+     * placed instance as a payload — the preview twin of the shim's durable
+     * delta capture, with the same placed-geometry math (normalize, scaling,
+     * coordination) so preview and durable placements coincide, but copying
+     * geometry OUT of the wasm heap instead of retaining native references.
+     */
+    private captureNewInstances_;
+    /**
+     * Test seam: run generation building + extraction + capture synchronously
+     * until either every product currently in the sink is attempted or a cap
+     * is hit — what the timer-driven ticks do, without the timers.
+     */
+    drainForTest(): void;
+}
+//# sourceMappingURL=streamed_preview_channel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streamed_preview_channel.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/streamed_preview_channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAM5C,OAAO,cAAc,MAAM,yCAAyC,CAAA;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAErE,OAAO,KAAK,QAAQ,MAAM,WAAW,CAAA;AAwCrC;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,iBAAiB,EAAE,MAAM,CAAA;IACzB,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACrD,kBAAkB,EAAE,MAAM,EAAE,CAAA;IAC5B,UAAU,CAAC,EAAE,YAAY,CAAA;IACzB,SAAS,CAAC,EAAE,WAAW,CAAA;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,sBAAsB;IA6C7B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,yBAAyB;IAlD9C;;4DAEwD;IACjD,kBAAkB,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAA;IAEzC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,MAAM,CAAC,CAA+B;IAE9C,OAAO,CAAC,gBAAgB,CAAI;IAC5B,OAAO,CAAC,aAAa,CAAI;IAEzB,4DAA4D;IAC5D,OAAO,CAAC,eAAe,CAAI;IAE3B;4CACwC;IACxC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoB;IAErD,OAAO,CAAC,WAAW,CAAC,CAOnB;IAED,OAAO,CAAC,oBAAoB,CAAI;IAEhC;;;;;;;;;;;;OAYG;gBAEkB,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,cAAc,EAC1B,IAAI,EAAE,iBAAiB,CAAC,cAAc,CAAC,EACvC,kBAAkB,EAAE,OAAO,EAC3B,MAAM,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,EAC1C,WAAW,GAAE,MAAqC,EAClD,QAAQ,GAAE,MAAkC,EAC5C,yBAAyB,GAAE,MAChB;IAGhC,2DAA2D;IACpD,KAAK,IAAI,IAAI;IAIpB;;;;OAIG;IACI,IAAI,IAAI,IAAI;IASnB,oEAAoE;IACpE,IAAW,MAAM,IAAI,OAAO,CAG3B;IAGD,OAAO,CAAC,SAAS;IAqBjB;;;OAGG;IACH,OAAO,CAAC,KAAK;IAoCb;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAiDzB;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAgJ5B;;;;OAIG;IACI,YAAY,IAAI,IAAI;CA+B5B"}