@bldrs-ai/conway 1.529.1492 → 1.534.1505

package/compiled/examples/browser-bundled.cjs

@@ -30,7 +30,7 @@ var import_node_process = require("node:process");
 var readline = __toESM(require("node:readline"), 1);
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.529.1492";
+var versionString = "Conway v1.534.1505";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -2626,10 +2626,12 @@ var StepParser = class extends StepHeaderParser {
    * buffer; the callback may rebase the buffer's window in place. Must be
    * synchronous on this driver — a returned Promise is a caller bug.
    * @param onRecordIndexed Called as each top-level record is indexed, with
-   * its localID, expressID and typeID (0 for external-mapping records) — the
-   * seam for incremental semantic consumers (type index, roots registry,
-   * names skeleton). Must be synchronous and cheap; expensive work belongs on
-   * a demand queue, not the parse path.
+   * its localID, expressID, typeID (0 for external-mapping records) and the
+   * record's bytes as an un-materialised `(buffer, byteOffset, byteLength)`
+   * window view — the seam for incremental semantic consumers (type index,
+   * roots registry, names skeleton). See {@link RecordEventHandler} for the
+   * window-lifetime rule. Must be synchronous and cheap; expensive work
+   * belongs on a demand queue, not the parse path.
    * @param onProgress Optional byte-cursor progress callback.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
@@ -2913,11 +2915,6 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
-        {
-          const recordLen = input2.address - startElement2;
-          onRecordIndexed?.(topLevelCount, expressID, 0, input2.buffer.subarray(input2.cursor - recordLen, input2.cursor));
-        }
-        ++topLevelCount;
         pushEntry({
           address: startElement2,
           length: input2.address - startElement2,
@@ -2927,6 +2924,11 @@ var StepParser = class extends StepHeaderParser {
           inlineEntities: inlineElements,
           multiMapping: multiElements
         });
+        {
+          const recordLen = input2.address - startElement2;
+          onRecordIndexed?.(topLevelCount, expressID, 0, input2.buffer, input2.cursor - recordLen, recordLen);
+        }
+        ++topLevelCount;
         multiElements = void 0;
         continue;
       }
@@ -3006,11 +3008,6 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
-      {
-        const recordLen = input2.address - startElement;
-        onRecordIndexed?.(topLevelCount, expressID, foundItem, input2.buffer.subarray(input2.cursor - recordLen, input2.cursor));
-      }
-      ++topLevelCount;
       pushEntry({
         address: startElement,
         length: input2.address - startElement,
@@ -3018,6 +3015,11 @@ var StepParser = class extends StepHeaderParser {
         expressID,
         inlineEntities: inlineElements
       });
+      {
+        const recordLen = input2.address - startElement;
+        onRecordIndexed?.(topLevelCount, expressID, foundItem, input2.buffer, input2.cursor - recordLen, recordLen);
+      }
+      ++topLevelCount;
     }
     return parseResult2(ParseResult.INCOMPLETE);
   }
@@ -72163,13 +72165,11 @@ async function buildIndexStreamingAsync(source, parser211, pool3, onRecordIndexe
     };
   }
 }
-function buildColumnarIndexStreaming(source, parser211, pool3, onRecordIndexed) {
-  const sink = new ColumnarIndexSink();
+function buildColumnarIndexStreaming(source, parser211, pool3, onRecordIndexed, sink = new ColumnarIndexSink()) {
   const { header, result, stats } = buildIndexStreaming(source, parser211, pool3, onRecordIndexed, sink);
   return { header, columns: sink.finalize(), result, stats };
 }
-async function buildColumnarIndexStreamingAsync(source, parser211, pool3, onRecordIndexed, onProgress, yieldIntervalMs) {
-  const sink = new ColumnarIndexSink();
+async function buildColumnarIndexStreamingAsync(source, parser211, pool3, onRecordIndexed, onProgress, yieldIntervalMs, sink = new ColumnarIndexSink()) {
   const { header, result, stats } = await buildIndexStreamingAsync(source, parser211, pool3, onRecordIndexed, sink, onProgress, yieldIntervalMs);
   return { header, columns: sink.finalize(), result, stats };
 }

package/compiled/examples/cli-bundled.cjs

@@ -14965,7 +14965,7 @@ ${t5.join("\n")}` : "";
 var import_process = require("process");
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.529.1492";
+var versionString = "Conway v1.534.1505";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -18462,10 +18462,12 @@ var StepParser = class extends StepHeaderParser {
    * buffer; the callback may rebase the buffer's window in place. Must be
    * synchronous on this driver — a returned Promise is a caller bug.
    * @param onRecordIndexed Called as each top-level record is indexed, with
-   * its localID, expressID and typeID (0 for external-mapping records) — the
-   * seam for incremental semantic consumers (type index, roots registry,
-   * names skeleton). Must be synchronous and cheap; expensive work belongs on
-   * a demand queue, not the parse path.
+   * its localID, expressID, typeID (0 for external-mapping records) and the
+   * record's bytes as an un-materialised `(buffer, byteOffset, byteLength)`
+   * window view — the seam for incremental semantic consumers (type index,
+   * roots registry, names skeleton). See {@link RecordEventHandler} for the
+   * window-lifetime rule. Must be synchronous and cheap; expensive work
+   * belongs on a demand queue, not the parse path.
    * @param onProgress Optional byte-cursor progress callback.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
@@ -18749,11 +18751,6 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
-        {
-          const recordLen = input.address - startElement2;
-          onRecordIndexed?.(topLevelCount, expressID, 0, input.buffer.subarray(input.cursor - recordLen, input.cursor));
-        }
-        ++topLevelCount;
         pushEntry({
           address: startElement2,
           length: input.address - startElement2,
@@ -18763,6 +18760,11 @@ var StepParser = class extends StepHeaderParser {
           inlineEntities: inlineElements,
           multiMapping: multiElements
         });
+        {
+          const recordLen = input.address - startElement2;
+          onRecordIndexed?.(topLevelCount, expressID, 0, input.buffer, input.cursor - recordLen, recordLen);
+        }
+        ++topLevelCount;
         multiElements = void 0;
         continue;
       }
@@ -18842,11 +18844,6 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
-      {
-        const recordLen = input.address - startElement;
-        onRecordIndexed?.(topLevelCount, expressID, foundItem, input.buffer.subarray(input.cursor - recordLen, input.cursor));
-      }
-      ++topLevelCount;
       pushEntry({
         address: startElement,
         length: input.address - startElement,
@@ -18854,6 +18851,11 @@ var StepParser = class extends StepHeaderParser {
         expressID,
         inlineEntities: inlineElements
       });
+      {
+        const recordLen = input.address - startElement;
+        onRecordIndexed?.(topLevelCount, expressID, foundItem, input.buffer, input.cursor - recordLen, recordLen);
+      }
+      ++topLevelCount;
     }
     return parseResult(ParseResult.INCOMPLETE);
   }
@@ -88131,13 +88133,11 @@ async function buildIndexStreamingAsync(source, parser210, pool3, onRecordIndexe
     };
   }
 }
-function buildColumnarIndexStreaming(source, parser210, pool3, onRecordIndexed) {
-  const sink = new ColumnarIndexSink();
+function buildColumnarIndexStreaming(source, parser210, pool3, onRecordIndexed, sink = new ColumnarIndexSink()) {
   const { header, result, stats } = buildIndexStreaming(source, parser210, pool3, onRecordIndexed, sink);
   return { header, columns: sink.finalize(), result, stats };
 }
-async function buildColumnarIndexStreamingAsync(source, parser210, pool3, onRecordIndexed, onProgress, yieldIntervalMs) {
-  const sink = new ColumnarIndexSink();
+async function buildColumnarIndexStreamingAsync(source, parser210, pool3, onRecordIndexed, onProgress, yieldIntervalMs, sink = new ColumnarIndexSink()) {
   const { header, result, stats } = await buildIndexStreamingAsync(source, parser210, pool3, onRecordIndexed, sink, onProgress, yieldIntervalMs);
   return { header, columns: sink.finalize(), result, stats };
 }
@@ -88456,6 +88456,7 @@ var IfcSceneBuilder = class {
     this.sceneLocalIdMap_ = /* @__PURE__ */ new Map();
     this.geometrySet_ = /* @__PURE__ */ new Set();
     this.sceneStack_ = [];
+    this.geometryNodeVisits_ = 0;
   }
   /**
    *
@@ -88646,37 +88647,118 @@ var IfcSceneBuilder = class {
   isAllSpaces() {
     return this.scene_.every((node) => !(node instanceof IfcSceneGeometry) || node.isSpace);
   }
+  *walk(includeSpaces = false) {
+    for (let index = 0; index < this.scene_.length; ++index) {
+      const resolved = this.resolveGeometryNode_(index, includeSpaces);
+      if (resolved === void 0 || resolved[2] === void 0) {
+        continue;
+      }
+      yield [resolved[0], resolved[1], resolved[2], resolved[3], resolved[4]];
+    }
+  }
   /**
-   * Walk the current scene.
+   * The number of nodes in the scene array. Append-only, so a caller that
+   * remembers this value has a stable cursor into the scene: everything
+   * added after it sits at a higher index.
    *
-   * @yields Raw absolute matrix transform, the native absolute transform, the canonical mesh,
-   * @param includeSpaces
-   * the canonical material and the associated step element as it walks the hierarchy.
-   * @param walkTemporary Include temporary items.
+   * @return {number} The node count.
    */
-  *walk(includeSpaces = false) {
-    for (const node of this.scene_) {
-      if (node instanceof IfcSceneGeometry && (includeSpaces || !node.isSpace)) {
-        const parentIndex = node.parentIndex;
-        const geometry = node.model.geometry?.getByLocalID(node.localID);
-        if (geometry === void 0) {
-          continue;
-        }
-        let parentNode;
-        if (parentIndex !== void 0) {
-          parentNode = this.scene_[parentIndex];
-        }
-        const material = this.materials.getMaterialByGeometryID(node.materialOverideLocalID ?? geometry.localID);
-        yield [
-          parentNode?.absoluteTransform,
-          parentNode?.absoluteNativeTransform,
-          geometry,
-          material !== void 0 ? material[0] : void 0,
-          node.relatedElementLocalId !== void 0 ? this.model.getElementByLocalID(node.relatedElementLocalId) : void 0
-        ];
+  get nodeCount() {
+    return this.scene_.length;
+  }
+  /**
+   * How many times a node has been considered by any walk form since this
+   * scene was built.
+   *
+   * Exists so the *complexity* of an incremental consumer can be asserted
+   * rather than timed: a capture that walks only what the scene gained
+   * visits each node about once for the whole load, where one that
+   * re-walks from zero visits every node once per call. Output parity
+   * cannot distinguish those — both deliver the same meshes — so without
+   * this a regression from O(new nodes) back to O(batches x scene) passes
+   * every correctness test while restoring the cost. See the batch-size
+   * invariance test in ifc_api_deferred_open.test.ts.
+   *
+   * @return {number} The visit count.
+   */
+  get geometryNodeVisits() {
+    return this.geometryNodeVisits_;
+  }
+  /**
+   * Walk only the nodes added at or after `startIndex` — the incremental
+   * form of {@link walk}, for a consumer draining the scene in batches.
+   *
+   * Unlike `walk`, this yields nodes whose geometry does NOT resolve, with
+   * `undefined` in the geometry slot and the node's index last. That is
+   * deliberate: a cursor-based caller passes each index exactly once, so a
+   * node skipped for missing geometry would be lost forever, where the
+   * whole-scene walk would have picked it up on its next pass. Geometry can
+   * appear late — a product that maps geometry a release freed re-extracts
+   * it — so the caller must park those indices and retry them with
+   * {@link walkNode}. Yielding them is what makes that possible.
+   *
+   * @param startIndex First node index to consider.
+   * @param includeSpaces Include space geometry.
+   * @yields The walk tuple plus the node's index.
+   */
+  *walkFrom(startIndex, includeSpaces = false) {
+    for (let index = startIndex; index < this.scene_.length; ++index) {
+      const resolved = this.resolveGeometryNode_(index, includeSpaces);
+      if (resolved === void 0) {
+        continue;
       }
+      yield resolved;
     }
   }
+  /**
+   * Resolve one node by index, for retrying a node {@link walkFrom} yielded
+   * without geometry.
+   *
+   * @param index The node's index in the scene array.
+   * @param includeSpaces Include space geometry.
+   * @return {[...]|undefined} The walk tuple plus the index, or undefined
+   * when the node isn't geometry this walk covers.
+   */
+  walkNode(index, includeSpaces = false) {
+    return this.resolveGeometryNode_(index, includeSpaces);
+  }
+  /**
+   * The shared body of walk/walkFrom/walkNode: one node in, one walk tuple
+   * out. Single-sourced so the incremental walk cannot drift from the whole
+   * -scene one — a drift here would show up as geometry placed differently
+   * depending on batch size.
+   *
+   * @param index The node's index in the scene array.
+   * @param includeSpaces Include space geometry.
+   * @return {[...]|undefined} Undefined when the node isn't a geometry node
+   * this walk covers; otherwise the tuple, whose geometry slot is undefined
+   * if the geometry doesn't currently resolve.
+   */
+  resolveGeometryNode_(index, includeSpaces) {
+    ++this.geometryNodeVisits_;
+    const node = this.scene_[index];
+    if (!(node instanceof IfcSceneGeometry) || !includeSpaces && node.isSpace) {
+      return void 0;
+    }
+    const geometry = node.model.geometry?.getByLocalID(node.localID);
+    if (geometry === void 0) {
+      return [void 0, void 0, void 0, void 0, void 0, index];
+    }
+    const parentIndex = node.parentIndex;
+    let parentNode;
+    if (parentIndex !== void 0) {
+      parentNode = this.scene_[parentIndex];
+    }
+    const material = this.materials.getMaterialByGeometryID(node.materialOverideLocalID ?? geometry.localID);
+    return [
+      parentNode?.absoluteTransform,
+      parentNode?.absoluteNativeTransform,
+      geometry,
+      material !== void 0 ? material[0] : void 0,
+      node.relatedElementLocalId !== void 0 ? this.model.getElementByLocalID(node.relatedElementLocalId) : void 0,
+      index
+    ];
+  }
   /**
    *
    */

package/compiled/examples/cli-step-bundled.cjs

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.529.1492";
+var versionString = "Conway v1.534.1505";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -18365,10 +18365,12 @@ var StepParser = class extends StepHeaderParser {
    * buffer; the callback may rebase the buffer's window in place. Must be
    * synchronous on this driver — a returned Promise is a caller bug.
    * @param onRecordIndexed Called as each top-level record is indexed, with
-   * its localID, expressID and typeID (0 for external-mapping records) — the
-   * seam for incremental semantic consumers (type index, roots registry,
-   * names skeleton). Must be synchronous and cheap; expensive work belongs on
-   * a demand queue, not the parse path.
+   * its localID, expressID, typeID (0 for external-mapping records) and the
+   * record's bytes as an un-materialised `(buffer, byteOffset, byteLength)`
+   * window view — the seam for incremental semantic consumers (type index,
+   * roots registry, names skeleton). See {@link RecordEventHandler} for the
+   * window-lifetime rule. Must be synchronous and cheap; expensive work
+   * belongs on a demand queue, not the parse path.
    * @param onProgress Optional byte-cursor progress callback.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
@@ -18652,11 +18654,6 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
-        {
-          const recordLen = input.address - startElement2;
-          onRecordIndexed?.(topLevelCount, expressID, 0, input.buffer.subarray(input.cursor - recordLen, input.cursor));
-        }
-        ++topLevelCount;
         pushEntry({
           address: startElement2,
           length: input.address - startElement2,
@@ -18666,6 +18663,11 @@ var StepParser = class extends StepHeaderParser {
           inlineEntities: inlineElements,
           multiMapping: multiElements
         });
+        {
+          const recordLen = input.address - startElement2;
+          onRecordIndexed?.(topLevelCount, expressID, 0, input.buffer, input.cursor - recordLen, recordLen);
+        }
+        ++topLevelCount;
         multiElements = void 0;
         continue;
       }
@@ -18745,11 +18747,6 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
-      {
-        const recordLen = input.address - startElement;
-        onRecordIndexed?.(topLevelCount, expressID, foundItem, input.buffer.subarray(input.cursor - recordLen, input.cursor));
-      }
-      ++topLevelCount;
       pushEntry({
         address: startElement,
         length: input.address - startElement,
@@ -18757,6 +18754,11 @@ var StepParser = class extends StepHeaderParser {
         expressID,
         inlineEntities: inlineElements
       });
+      {
+        const recordLen = input.address - startElement;
+        onRecordIndexed?.(topLevelCount, expressID, foundItem, input.buffer, input.cursor - recordLen, recordLen);
+      }
+      ++topLevelCount;
     }
     return parseResult(ParseResult.INCOMPLETE);
   }

package/compiled/examples/validator-bundled.cjs

@@ -944,7 +944,7 @@ var EntityTypesIfcCount = 909;
 var entity_types_ifc_gen_default = EntityTypesIfc;
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.529.1492";
+var versionString = "Conway v1.534.1505";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -3540,10 +3540,12 @@ var StepParser = class extends StepHeaderParser {
    * buffer; the callback may rebase the buffer's window in place. Must be
    * synchronous on this driver — a returned Promise is a caller bug.
    * @param onRecordIndexed Called as each top-level record is indexed, with
-   * its localID, expressID and typeID (0 for external-mapping records) — the
-   * seam for incremental semantic consumers (type index, roots registry,
-   * names skeleton). Must be synchronous and cheap; expensive work belongs on
-   * a demand queue, not the parse path.
+   * its localID, expressID, typeID (0 for external-mapping records) and the
+   * record's bytes as an un-materialised `(buffer, byteOffset, byteLength)`
+   * window view — the seam for incremental semantic consumers (type index,
+   * roots registry, names skeleton). See {@link RecordEventHandler} for the
+   * window-lifetime rule. Must be synchronous and cheap; expensive work
+   * belongs on a demand queue, not the parse path.
    * @param onProgress Optional byte-cursor progress callback.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
@@ -3827,11 +3829,6 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
-        {
-          const recordLen = input.address - startElement2;
-          onRecordIndexed?.(topLevelCount, expressID, 0, input.buffer.subarray(input.cursor - recordLen, input.cursor));
-        }
-        ++topLevelCount;
         pushEntry({
           address: startElement2,
           length: input.address - startElement2,
@@ -3841,6 +3838,11 @@ var StepParser = class extends StepHeaderParser {
           inlineEntities: inlineElements,
           multiMapping: multiElements
         });
+        {
+          const recordLen = input.address - startElement2;
+          onRecordIndexed?.(topLevelCount, expressID, 0, input.buffer, input.cursor - recordLen, recordLen);
+        }
+        ++topLevelCount;
         multiElements = void 0;
         continue;
       }
@@ -3920,11 +3922,6 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
-      {
-        const recordLen = input.address - startElement;
-        onRecordIndexed?.(topLevelCount, expressID, foundItem, input.buffer.subarray(input.cursor - recordLen, input.cursor));
-      }
-      ++topLevelCount;
       pushEntry({
         address: startElement,
         length: input.address - startElement,
@@ -3932,6 +3929,11 @@ var StepParser = class extends StepHeaderParser {
         expressID,
         inlineEntities: inlineElements
       });
+      {
+        const recordLen = input.address - startElement;
+        onRecordIndexed?.(topLevelCount, expressID, foundItem, input.buffer, input.cursor - recordLen, recordLen);
+      }
+      ++topLevelCount;
     }
     return parseResult2(ParseResult.INCOMPLETE);
   }
@@ -72161,13 +72163,11 @@ async function buildIndexStreamingAsync(source, parser211, pool3, onRecordIndexe
     };
   }
 }
-function buildColumnarIndexStreaming(source, parser211, pool3, onRecordIndexed) {
-  const sink = new ColumnarIndexSink();
+function buildColumnarIndexStreaming(source, parser211, pool3, onRecordIndexed, sink = new ColumnarIndexSink()) {
   const { header, result, stats } = buildIndexStreaming(source, parser211, pool3, onRecordIndexed, sink);
   return { header, columns: sink.finalize(), result, stats };
 }
-async function buildColumnarIndexStreamingAsync(source, parser211, pool3, onRecordIndexed, onProgress, yieldIntervalMs) {
-  const sink = new ColumnarIndexSink();
+async function buildColumnarIndexStreamingAsync(source, parser211, pool3, onRecordIndexed, onProgress, yieldIntervalMs, sink = new ColumnarIndexSink()) {
   const { header, result, stats } = await buildIndexStreamingAsync(source, parser211, pool3, onRecordIndexed, sink, onProgress, yieldIntervalMs);
   return { header, columns: sink.finalize(), result, stats };
 }

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

@@ -277,6 +277,126 @@ describe("OpenModelStreamed + DEFER_GEOMETRY", () => {
         api4.CloseModel(classicID);
         api4.CloseModel(deferredID);
     }, 240000);
+    test("shared representation survives a batch boundary, emitted once", async () => {
+        // data/mapped_shared_representation.ifc: one IfcRepresentationMap
+        // mapped by two products 15 products apart, so a batch size of 4
+        // guarantees they land in DIFFERENT batches. The smoke corpus cannot
+        // produce this shape — there every sharer of a definition falls
+        // inside one batch — so this is the only fixture that exercises the
+        // delta capture across a boundary where geometry is shared.
+        //
+        // It pins the cursor capture from both directions. Lose a parked or
+        // suffix node and the second mapped product goes missing; re-emit a
+        // node the cursor should have passed (the failure a reverted cursor
+        // or a broken watermark produces) and instances duplicate. Both show
+        // up as an instance-count mismatch against classic, which is why the
+        // comparison is against classic rather than a hard-coded number.
+        const api5 = new IfcAPI();
+        await api5.Init();
+        const fixture = new Uint8Array(fs.readFileSync("data/mapped_shared_representation.ifc"));
+        const classicID = api5.OpenModel(fixture, SETTINGS);
+        const classicPlacements = [];
+        api5.StreamAllMeshes(classicID, (mesh) => {
+            for (let where = 0; where < mesh.geometries.size(); ++where) {
+                const placed = mesh.geometries.get(where);
+                classicPlacements.push(`${placed.geometryExpressID}@${[...placed.flatTransformation]
+                    .map((value) => value.toFixed(3)).join(",")}`);
+            }
+        });
+        const deferredID = await api5.OpenModelStreamed(fixture, { ...SETTINGS, DEFER_GEOMETRY: true });
+        const pumpedPlacements = [];
+        let batches = 0;
+        for (;;) {
+            const { extracted, remaining } = api5.ExtractGeometryBatch(deferredID, 4, (mesh) => {
+                for (let where = 0; where < mesh.geometries.size(); ++where) {
+                    const placed = mesh.geometries.get(where);
+                    pumpedPlacements.push(`${placed.geometryExpressID}@${[...placed.flatTransformation]
+                        .map((value) => value.toFixed(3)).join(",")}`);
+                }
+            });
+            ++batches;
+            if (remaining === 0 && extracted === 0) {
+                break;
+            }
+        }
+        // The boundary the fixture exists to create: with 16 products at
+        // batch 4, the two sharers cannot be in the same batch.
+        expect(batches).toBeGreaterThan(2);
+        // Exact multiset equality — placement included, so an instance
+        // delivered at the wrong location fails as loudly as a missing one.
+        expect(pumpedPlacements.slice().sort())
+            .toEqual(classicPlacements.slice().sort());
+        // Emitted once each: a duplicate would survive the multiset check
+        // only if classic duplicated too, but state it directly since
+        // re-emission is the specific failure a broken cursor produces.
+        expect(new Set(pumpedPlacements).size).toBe(pumpedPlacements.length);
+        // Both users of the shared map are present, at their own placements
+        // — the shared SOURCE geometry appears under two distinct transforms.
+        const mappedTransforms = new Set(pumpedPlacements.map((entry) => entry.split("@")[1]));
+        expect(mappedTransforms.size).toBe(pumpedPlacements.length);
+        api5.CloseModel(classicID);
+        api5.CloseModel(deferredID);
+    }, 240000);
+    test("delta capture visits each scene node once, whatever the batch size", async () => {
+        // Output parity cannot see this. The whole-scene walk this replaced
+        // delivered exactly the same meshes; what changed is the COST of
+        // delivering them — it re-resolved every node on every call, so the
+        // capture was O(batches x scene). A revert would pass every
+        // correctness assertion in this file while restoring the 1.47-2.97x
+        // regression the PR description measures, so the complexity gets an
+        // assertion of its own.
+        //
+        // Counting node visits rather than timing: deterministic, and it
+        // fails the same way on a fast machine as a slow one.
+        const api6 = new IfcAPI();
+        await api6.Init();
+        const fixture = new Uint8Array(fs.readFileSync("data/mapped_shared_representation.ifc"));
+        /**
+         * Pump a fresh deferred model to completion and report how much
+         * scene walking it took.
+         *
+         * @param batchSize Products per ExtractGeometryBatch call.
+         * @return {Promise<{visits: number, nodes: number, batches: number}>}
+         * Node visits, final scene size, and calls taken.
+         */
+        async function pump(batchSize) {
+            const modelID = await api6.OpenModelStreamed(fixture, { ...SETTINGS, DEFER_GEOMETRY: true });
+            let batches = 0;
+            for (;;) {
+                const { extracted, remaining } = api6.ExtractGeometryBatch(modelID, batchSize, () => { });
+                ++batches;
+                if (remaining === 0 && extracted === 0) {
+                    break;
+                }
+            }
+            const scene = api6.getPassthrough(modelID)
+                .model[1];
+            // A revert that drops the counter along with the cursor would
+            // otherwise fail as `expected undefined to be less than 68`, which
+            // reads like a broken test rather than the regression it is.
+            expect(typeof scene?.geometryNodeVisits)
+                .toBe("number");
+            const measured = { visits: scene.geometryNodeVisits, nodes: scene.nodeCount, batches };
+            api6.CloseModel(modelID);
+            return measured;
+        }
+        const oneAtATime = await pump(1);
+        const allAtOnce = await pump(64);
+        // The fixture is 16 products, so batch 1 really does take many calls
+        // — otherwise this asserts nothing.
+        expect(oneAtATime.batches).toBeGreaterThan(8);
+        expect(allAtOnce.batches).toBeLessThan(oneAtATime.batches);
+        // The invariant: total walking is a property of the SCENE, not of how
+        // many calls drained it. Allowing 2x the node count leaves room for
+        // the whole-model drain's own pass and for parked-node retries
+        // (DEMAND_PARKED_NODE_RETRIES each, and nothing in this corpus parks
+        // a node at all), while a per-call re-walk would land near
+        // batches x nodes — an order of magnitude clear of the bound.
+        expect(oneAtATime.visits).toBeLessThan(oneAtATime.nodes * 2);
+        // And it must not grow when the batch shrinks, which is the specific
+        // shape of the regression: same scene, ~16x the calls, same work.
+        expect(oneAtATime.visits).toBeLessThan(allAtOnce.visits * 2);
+    }, 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))

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

@@ -75,7 +75,38 @@ export declare class IfcApiProxyIfc implements IfcApiModelPassthrough {
      * batches - the watermark makes each instance captured exactly once,
      * in the same order the classic single walk would process it.
      */
-    private readonly demandCapturedCounts_;
+    /**
+     * How much of the scene array the delta capture has consumed. The scene
+     * is append-only, so this is a stable cursor: everything a batch adds
+     * sits above it. Replaces the per-entity walk watermark this used to
+     * keep, which existed only because the capture restarted its walk from
+     * zero every batch — an O(batches x scene) cost that dominated on
+     * instance-dense models (D3D: 562k instances, 1182 batches at size 64).
+     */
+    private demandSceneCursor_;
+    /**
+     * Node indices walkFrom yielded without resolvable geometry, against the
+     * number of times a later capture has re-checked them. Parked because a
+     * cursor passes each index once, where the whole-scene walk this replaced
+     * re-checked every node on every call. See IfcSceneBuilder.walkFrom.
+     *
+     * Bounded by DEMAND_PARKED_NODE_RETRIES because not every unresolved node
+     * is waiting on something: extraction can append a scene node and then
+     * fail to cache geometry for it (extractSweptDiskSolid returns early on a
+     * failed directrix; extractRepresentationItem still calls addGeometry),
+     * and no amount of re-checking makes a deterministic failure resolve.
+     * Retrying those forever would be O(batches x unresolvable) — still under
+     * the O(batches x scene) this replaced, but unbounded in batch count for
+     * no benefit. Expiring after a fixed number of attempts makes the total
+     * retry work O(retries x unresolvable) regardless of batch size.
+     *
+     * Measured at zero on every model available here — the 12-model smoke
+     * corpus, PSB, and D3D (which logs exactly the malformed-geometry errors
+     * that produce this case) all park nothing — so this path is a
+     * correctness guard rather than a hot path, and its constant is chosen to
+     * be generous rather than tuned.
+     */
+    private readonly demandPendingNodes_;
     /** Cursor into demandProducts_ — products before it are extracted. */
     private demandCursor_;
     /** Wall-clock split of the store-backed batch pump (profile script). */