@bldrs-ai/conway 1.389.1221 → 1.394.1504

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.389.1221";
+var versionString = "Conway v1.394.1504";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -374,10 +374,12 @@ var Logger = class _Logger {
    *
    * @param level - log level
    * @param message - log message
+   * @param expressID - record this entry is about, kept out of the message
+   *   text so repeats dedupe into one entry (see the class doc)
    */
-  static log(level, message) {
+  static log(level, message, expressID) {
     const baseMessage = message.split(" expressID: ")[0];
-    const data = message.split(" expressID: ")[1];
+    const data = expressID !== void 0 ? String(expressID) : message.split(" expressID: ")[1];
     const index = _Logger.findLogIndex(baseMessage, level);
     let logEntry;
     let firstOccurrence = false;
@@ -399,7 +401,7 @@ var Logger = class _Logger {
       _Logger.logs.push(logEntry);
     }
     if (firstOccurrence && _Logger.isLevelEnabled(LOG_LEVEL_BY_NAME[level])) {
-      _Logger.sink(level, baseMessage);
+      _Logger.sink(level, data !== void 0 ? `${baseMessage} expressID: ${data}` : baseMessage);
     }
     _Logger.proxies.forEach((proxy) => proxy.log(logEntry));
   }
@@ -504,16 +506,18 @@ var Logger = class _Logger {
   /**
    *
    * @param message - log message
+   * @param expressID - record this entry is about
    */
-  static warning(message) {
-    _Logger.log("warning", message);
+  static warning(message, expressID) {
+    _Logger.log("warning", message, expressID);
   }
   /**
    *
    * @param message - log message
+   * @param expressID - record this entry is about
    */
-  static error(message) {
-    _Logger.log("error", message);
+  static error(message, expressID) {
+    _Logger.log("error", message, expressID);
   }
   /**
    *
@@ -584,6 +588,20 @@ var environment_default = Environment;
 
 // compiled/src/core/progress.js
 function yieldToEventLoop() {
+  const scheduler = globalThis.scheduler;
+  if (typeof scheduler?.yield === "function") {
+    return scheduler.yield();
+  }
+  if (typeof MessageChannel === "function") {
+    return new Promise((resolve) => {
+      const channel = new MessageChannel();
+      channel.port1.onmessage = () => {
+        channel.port1.close();
+        resolve();
+      };
+      channel.port2.postMessage(null);
+    });
+  }
   return new Promise((resolve) => {
     setTimeout(resolve, 0);
   });
@@ -1113,6 +1131,19 @@ function copyOutOfResizable(view) {
 function decodeUtf8(view) {
   return decoder.decode(decodeNeedsCopy(view.buffer) ? view.slice() : view);
 }
+var strictUtf8Decoder = new TextDecoder("utf-8", { fatal: true });
+function decodeStepString(view) {
+  const bytes = decodeNeedsCopy(view.buffer) ? view.slice() : view;
+  try {
+    return strictUtf8Decoder.decode(bytes);
+  } catch {
+    let result = "";
+    for (let where = 0; where < bytes.length; ++where) {
+      result += String.fromCharCode(bytes[where]);
+    }
+    return result;
+  }
+}
 var shimInstalled = false;
 function installResizableTextDecoderShim() {
   if (shimInstalled || typeof TextDecoder === "undefined") {
@@ -1286,6 +1317,37 @@ var ParsingBuffer = class {
     this.buffer = buffer;
     this.end = endOffset;
   }
+  /**
+   * Streaming support: repoint this buffer at a fresh window over the same
+   * logical stream while keeping `address` file-absolute.
+   *
+   * A moving-window parse holds only a slice of the source in memory at a
+   * time. Between top-level records (where the rewind stack is empty) the
+   * driver slides the window forward: it copies the unconsumed tail to the
+   * front of a reused buffer, appends freshly-read bytes, and calls this to
+   * repoint the parser. `addressBase` is the file offset that window index 0
+   * now corresponds to; we store it as a negative initial offset so
+   * `address` ( = cursor − initialOffset ) stays the file-absolute value the
+   * non-streaming parse would have produced.
+   *
+   * Must only be called with the rewind stack empty (i.e. at a record
+   * boundary) — the stack holds window-relative cursors that a slide would
+   * invalidate. Throws otherwise.
+   *
+   * @param buffer The new window buffer.
+   * @param cursorInWindow The cursor position within the new window.
+   * @param endInWindow The count of valid bytes in the new window.
+   * @param addressBase The file offset that window index 0 maps to.
+   */
+  rebaseWindow(buffer, cursorInWindow, endInWindow, addressBase) {
+    if (this.rewindStack_.length !== 0) {
+      throw Error("rebaseWindow called mid-transaction (rewind stack non-empty)");
+    }
+    this.buffer = buffer;
+    this.cursor_ = cursorInWindow;
+    this.initialOffset_ = -addressBase;
+    this.end = endInWindow;
+  }
   /**
    * Construct this with a buffer, initial offset into the buffer and an end offset.
    *
@@ -1769,14 +1831,14 @@ var StepStringParser = class extends ParsingDfa16Table {
               if (nextCursor < endCursor && input2[nextCursor] === QUOTE) {
                 result ??= "";
                 if (cursor > reificationIndex) {
-                  result += decodeUtf8(input2.subarray(reificationIndex, cursor - 1));
+                  result += decodeStepString(input2.subarray(reificationIndex, cursor - 1));
                 }
                 result += "'";
                 cursor = nextCursor + 1;
                 reificationIndex = cursor;
               } else {
                 result ??= "";
-                result += decodeUtf8(input2.subarray(reificationIndex, cursor));
+                result += decodeStepString(input2.subarray(reificationIndex, cursor));
                 return result;
               }
             }
@@ -1802,7 +1864,7 @@ var StepStringParser = class extends ParsingDfa16Table {
                 const nextChar2 = input2[nextCursor2];
                 if (nextChar2 !== BSLASH) {
                   result ??= "";
-                  result += decodeUtf8(input2.subarray(reificationIndex, cursor));
+                  result += decodeStepString(input2.subarray(reificationIndex, cursor));
                   cursor = nextCursor2 + 1;
                   break;
                 }
@@ -1815,7 +1877,7 @@ var StepStringParser = class extends ParsingDfa16Table {
                   return result;
                 }
                 result ??= "";
-                result += decodeUtf8(input2.subarray(reificationIndex, cursor));
+                result += decodeStepString(input2.subarray(reificationIndex, cursor));
                 codePage = nextChar3 - A2;
                 cursor = nextCursor3 + 1;
                 reificationIndex = cursor;
@@ -1829,7 +1891,7 @@ var StepStringParser = class extends ParsingDfa16Table {
                 const nextChar2 = input2[nextCursor2];
                 if (nextChar2 !== BSLASH) {
                   result ??= "";
-                  result += decodeUtf8(input2.subarray(reificationIndex, cursor));
+                  result += decodeStepString(input2.subarray(reificationIndex, cursor));
                   cursor = nextCursor2 + 1;
                   break;
                 }
@@ -1839,7 +1901,7 @@ var StepStringParser = class extends ParsingDfa16Table {
                 }
                 const nextChar3 = input2[nextCursor3];
                 result ??= "";
-                result += decodeUtf8(input2.subarray(reificationIndex, cursor));
+                result += decodeStepString(input2.subarray(reificationIndex, cursor));
                 if (nextChar3 < 127) {
                   result += String.fromCharCode(nextChar3);
                 } else if (nextChar >= 161 && nextChar <= 255) {
@@ -1858,7 +1920,7 @@ var StepStringParser = class extends ParsingDfa16Table {
                 }
                 const nextChar2 = input2[nextCursor2];
                 result ??= "";
-                result += decodeUtf8(input2.subarray(reificationIndex, cursor));
+                result += decodeStepString(input2.subarray(reificationIndex, cursor));
                 const hexParserTil0 = (count) => {
                   if (nextCursor2 + 1 >= endCursor || input2[nextCursor2 + 1] !== BSLASH) {
                     return false;
@@ -2205,6 +2267,18 @@ function* stepExtractArray(buffer, cursor, endCursor) {
     throw new Error("Unterminated array");
   }
 }
+function stepEnterTypedValue(buffer, cursor, endCursor, typeName) {
+  const identifierEnd = identifierParser.match(buffer, cursor, endCursor);
+  if (identifierEnd === void 0 || identifierEnd - cursor !== typeName.length) {
+    return cursor;
+  }
+  for (let where = 0; where < typeName.length; ++where) {
+    if (buffer[cursor + where] !== typeName.charCodeAt(where)) {
+      return cursor;
+    }
+  }
+  return stepExtractInlineElemement(buffer, cursor, endCursor) ?? cursor;
+}
 function stepExtractInlineElemement(buffer, cursor, endCursor) {
   const identifier = identifierParser.match(buffer, cursor, endCursor);
   if (identifier === void 0) {
@@ -2535,9 +2609,87 @@ var StepParser = class extends StepHeaderParser {
       if (next.done === true) {
         return next.value;
       }
+      if (typeof next.value === "number") {
+        onProgress?.(next.value);
+      }
+    }
+  }
+  /**
+   * Streaming driver over parseDataBlockIncremental: identical parse (same
+   * generator body) but invokes `onRecordBoundary` at every top-level record
+   * boundary so a caller feeding the parser from a moving window can slide
+   * that window forward while the rewind stack is empty. See
+   * streaming_index_builder.ts for the coordinator that owns the window.
+   *
+   * @param input The input parsing buffer, positioned at the data section.
+   * @param onRecordBoundary Called at each top-level record boundary with the
+   * 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, 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.
+   */
+  parseDataBlockStreamed(input2, onRecordBoundary, onRecordIndexed, onProgress, sink) {
+    const parser211 = this.parseDataBlockIncremental(input2, onRecordBoundary, onRecordIndexed, sink);
+    while (true) {
+      const next = parser211.next();
+      if (next.done === true) {
+        return next.value;
+      }
+      if (typeof next.value !== "number") {
+        throw new Error("parseDataBlockStreamed: async window slide requires parseDataBlockStreamedAsync");
+      }
       onProgress?.(next.value);
     }
   }
+  /**
+   * Cooperative variant of parseDataBlockStreamed: identical parse and
+   * window-slide behaviour (same generator body, same boundary callback),
+   * but periodically awaits a macrotask so the event loop can run —
+   * browsers repaint progress UI during a large streamed parse instead of
+   * flagging the tab as stalled. Issue #301 §2 for the streamed path.
+   *
+   * @param input The input parsing buffer, positioned at the data section.
+   * @param onRecordBoundary Called at each top-level record boundary with the
+   * buffer; the callback may rebase the buffer's window in place. May return
+   * a Promise when the slide itself is I/O (an async ByteSource); this
+   * driver awaits it before the next record is lexed.
+   * @param onRecordIndexed Called as each top-level record is indexed — see
+   * parseDataBlockStreamed.
+   * @param onProgress Optional byte-cursor progress callback.
+   * @param sink Optional index sink (columnar builds).
+   * @param yieldIntervalMs Minimum ms between event-loop yields.
+   * @return {Promise<BlockParseResult>} The parsing result, including the
+   * index and result enum.
+   */
+  async parseDataBlockStreamedAsync(input2, onRecordBoundary, onRecordIndexed, onProgress, sink, yieldIntervalMs = DEFAULT_PARSE_YIELD_INTERVAL_MS) {
+    const parser211 = this.parseDataBlockIncremental(input2, onRecordBoundary, onRecordIndexed, sink);
+    let lastYield = Date.now();
+    while (true) {
+      const next = parser211.next();
+      if (next.done === true) {
+        return next.value;
+      }
+      if (typeof next.value !== "number") {
+        await next.value;
+        continue;
+      }
+      const progressed = onProgress?.(next.value);
+      if (progressed !== void 0 && typeof progressed.then === "function") {
+        await progressed;
+      }
+      if (Date.now() - lastYield >= yieldIntervalMs) {
+        await yieldToEventLoop();
+        lastYield = Date.now();
+      }
+    }
+  }
   /**
    * Cooperative variant of parseDataBlock: identical parse (same generator
    * body), but periodically awaits a macrotask so the event loop can run —
@@ -2558,7 +2710,9 @@ var StepParser = class extends StepHeaderParser {
       if (next.done === true) {
         return next.value;
       }
-      onProgress?.(next.value);
+      if (typeof next.value === "number") {
+        onProgress?.(next.value);
+      }
       if (Date.now() - lastYield >= yieldIntervalMs) {
         await yieldToEventLoop();
         lastYield = Date.now();
@@ -2575,8 +2729,14 @@ var StepParser = class extends StepHeaderParser {
    * @yields {number} The current byte cursor within the input buffer.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
-  *parseDataBlockIncremental(input2) {
+  *parseDataBlockIncremental(input2, onRecordBoundary, onRecordIndexed, sink) {
     const indexResult = { elements: [] };
+    let topLevelCount = 0;
+    const pushEntry = sink !== void 0 ? (entry) => {
+      sink.pushTopLevel(entry);
+    } : (entry) => {
+      indexResult.elements.push(entry);
+    };
     const match = input2.match;
     const comment = () => match(commentParser2);
     const whitespace = () => {
@@ -2622,7 +2782,7 @@ var StepParser = class extends StepHeaderParser {
         return syntaxError();
       }
       whitespace();
-      const startElement = input2.cursor;
+      const startElement = input2.address;
       let stackDepth = 1;
       const savedInlineElements = inlineElements;
       inlineElements = void 0;
@@ -2716,6 +2876,10 @@ var StepParser = class extends StepHeaderParser {
       if ((++parsedElementCount & PARSE_PROGRESS_ELEMENT_MASK) === 0) {
         yield input2.cursor;
       }
+      const slide = onRecordBoundary?.(input2);
+      if (slide !== void 0 && typeof slide.then === "function") {
+        yield slide;
+      }
       if (!charws(HASH2)) {
         if (tokenws(END_SECTION)) {
           return parseResult2(ParseResult.COMPLETE);
@@ -2738,7 +2902,7 @@ var StepParser = class extends StepHeaderParser {
         }
         whitespace();
         inlineElements = void 0;
-        const startElement2 = input2.cursor;
+        const startElement2 = input2.address;
         while (!charws(CLOSE_PAREN2)) {
           input2.begin();
           const elementResult = parseInlineElement(expressID);
@@ -2751,7 +2915,7 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
-        indexResult.elements.push({
+        pushEntry({
           address: startElement2,
           length: input2.address - startElement2,
           typeID: 0,
@@ -2760,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;
       }
@@ -2769,7 +2938,7 @@ var StepParser = class extends StepHeaderParser {
         return syntaxError();
       }
       whitespace();
-      const startElement = input2.cursor;
+      const startElement = input2.address;
       let stackDepth = 1;
       inlineElements = void 0;
       while (stackDepth > 0) {
@@ -2796,9 +2965,6 @@ var StepParser = class extends StepHeaderParser {
             input2.begin();
             const elementResult = parseInlineElement();
             if (elementResult !== void 0) {
-              for (const element of elementResult[0].elements) {
-                element.expressID = expressID;
-              }
               input2.rollback();
               if (tokenws(INF)) {
                 break;
@@ -2842,13 +3008,18 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
-      indexResult.elements.push({
+      pushEntry({
         address: startElement,
         length: input2.address - startElement,
         typeID: foundItem,
         expressID,
         inlineEntities: inlineElements
       });
+      {
+        const recordLen = input2.address - startElement;
+        onRecordIndexed?.(topLevelCount, expressID, foundItem, input2.buffer, input2.cursor - recordLen, recordLen);
+      }
+      ++topLevelCount;
     }
     return parseResult2(ParseResult.INCOMPLETE);
   }
@@ -4257,6 +4428,70 @@ var EntityTypesIfc;
 var EntityTypesIfcCount = 909;
 var entity_types_ifc_gen_default = EntityTypesIfc;
 
+// compiled/src/step/parsing/express_ref_scan.js
+var HASH3 = 35;
+var QUOTE4 = 39;
+var DQUOTE = 34;
+var ZERO5 = 48;
+var NINE2 = 57;
+var SLASH3 = 47;
+var STAR2 = 42;
+function scanExpressRefs(bytes, from = 0, length = bytes.length - from) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const end = Math.min(from + length, bytes.length);
+  let cursor = from;
+  while (cursor < end) {
+    const byte = bytes[cursor];
+    if (byte === QUOTE4) {
+      cursor = skipQuoted_(bytes, cursor + 1, end, QUOTE4, true);
+      continue;
+    }
+    if (byte === DQUOTE) {
+      cursor = skipQuoted_(bytes, cursor + 1, end, DQUOTE, false);
+      continue;
+    }
+    if (byte === SLASH3 && cursor + 1 < end && bytes[cursor + 1] === STAR2) {
+      cursor += 2;
+      while (cursor + 1 < end && !(bytes[cursor] === STAR2 && bytes[cursor + 1] === SLASH3)) {
+        ++cursor;
+      }
+      cursor += 2;
+      continue;
+    }
+    if (byte === HASH3) {
+      let value = 0;
+      let digit = cursor + 1;
+      while (digit < end && bytes[digit] >= ZERO5 && bytes[digit] <= NINE2) {
+        value = value * 10 + (bytes[digit] - ZERO5);
+        ++digit;
+      }
+      if (digit > cursor + 1 && value !== 0 && !seen.has(value)) {
+        seen.add(value);
+        refs.push(value);
+      }
+      cursor = digit;
+      continue;
+    }
+    ++cursor;
+  }
+  return refs;
+}
+function skipQuoted_(bytes, from, end, quote, doubledEscape) {
+  let cursor = from;
+  while (cursor < end) {
+    if (bytes[cursor] === quote) {
+      if (doubledEscape && cursor + 1 < end && bytes[cursor + 1] === quote) {
+        cursor += 2;
+        continue;
+      }
+      return cursor + 1;
+    }
+    ++cursor;
+  }
+  return end;
+}
+
 // compiled/src/step/step_buffer_provider.js
 var DEFAULT_CHUNK_BYTES = 4 * 1024 * 1024;
 var DEFAULT_MAX_RESIDENT_CHUNKS = 16;
@@ -4437,7 +4672,7 @@ var WindowedStepBufferProvider = class {
     const firstChunk = Math.floor(address / chunkBytes);
     const lastChunk = Math.floor((address + Math.max(length, 1) - 1) / chunkBytes);
     for (let chunkIndex = firstChunk; chunkIndex <= lastChunk; ++chunkIndex) {
-      this.ensurePins_.set(chunkIndex, (this.ensurePins_.get(chunkIndex) ?? 0) + 1);
+      this.addPin_(chunkIndex, 1);
     }
     try {
       const loads = [];
@@ -4480,15 +4715,63 @@ var WindowedStepBufferProvider = class {
       }
     } finally {
       for (let chunkIndex = firstChunk; chunkIndex <= lastChunk; ++chunkIndex) {
-        const pins = this.ensurePins_.get(chunkIndex) ?? 0;
-        if (pins <= 1) {
-          this.ensurePins_.delete(chunkIndex);
-        } else {
-          this.ensurePins_.set(chunkIndex, pins - 1);
-        }
+        this.addPin_(chunkIndex, -1);
       }
     }
   }
+  /**
+   * Hold a range against LRU eviction until {@link unpinRange}.
+   *
+   * @param address Absolute start of the range.
+   * @param length Length of the range.
+   */
+  pinRange(address, length) {
+    for (const chunkIndex of this.chunkSpan_(address, length)) {
+      this.addPin_(chunkIndex, 1);
+    }
+  }
+  /**
+   * Drop one {@link pinRange} hold.
+   *
+   * @param address Absolute start of the range.
+   * @param length Length of the range.
+   */
+  unpinRange(address, length) {
+    for (const chunkIndex of this.chunkSpan_(address, length)) {
+      this.addPin_(chunkIndex, -1);
+    }
+  }
+  /**
+   * Chunk indices covering `[address, address + length)`.
+   *
+   * @param address Absolute start.
+   * @param length Length in bytes.
+   * @return {number[]} Inclusive chunk indices.
+   */
+  chunkSpan_(address, length) {
+    const chunkBytes = this.chunkBytes_;
+    const firstChunk = Math.floor(address / chunkBytes);
+    const lastChunk = Math.floor((address + Math.max(length, 1) - 1) / chunkBytes);
+    const span = [];
+    for (let chunkIndex = firstChunk; chunkIndex <= lastChunk; ++chunkIndex) {
+      span.push(chunkIndex);
+    }
+    return span;
+  }
+  /**
+   * Adjust a chunk's pin count, deleting the entry at zero.
+   *
+   * @param chunkIndex The chunk.
+   * @param delta +1 pin or -1 unpin.
+   */
+  addPin_(chunkIndex, delta) {
+    const pins = (this.ensurePins_.get(chunkIndex) ?? 0) + delta;
+    if (pins <= 0) {
+      this.ensurePins_.delete(chunkIndex);
+    } else {
+      this.ensurePins_.set(chunkIndex, pins);
+    }
+  }
 };
 
 // compiled/src/step/parsing/step_vtable_builder.js
@@ -4554,6 +4837,101 @@ var StepVtableBuilder = class {
   }
 };
 
+// compiled/src/step/parsing/uint32_sink.js
+var OPEN_PAREN3 = parsing_constants_default.OPEN_PAREN;
+var CLOSE_PAREN3 = parsing_constants_default.CLOSE_PAREN;
+var COMMA3 = parsing_constants_default.COMMA;
+var ZERO6 = parsing_constants_default.ZERO;
+var WHITESPACE4 = parsing_constants_default.WHITE_SPACE_SET;
+function extractIntegerArrayAt(buffer, cursor, endCursor, sink) {
+  const marked = sink.length;
+  const fast = extractUnsignedIntegerListAt(buffer, cursor, endCursor, sink);
+  if (fast !== void 0) {
+    return fast;
+  }
+  sink.truncate(marked);
+  if (stepExtractOptional(buffer, cursor, endCursor) === null) {
+    return 0;
+  }
+  let count = 0;
+  let signedCursor0 = stepExtractArrayBegin(buffer, cursor, endCursor);
+  let readCursor = Math.abs(signedCursor0);
+  while (signedCursor0 >= 0) {
+    const value = stepExtractNumber(buffer, readCursor, endCursor);
+    if (value === void 0) {
+      throw new Error("Value in STEP was incorrectly typed");
+    }
+    readCursor = skipValue(buffer, readCursor, endCursor);
+    sink.push(value);
+    ++count;
+    signedCursor0 = stepExtractArrayToken(buffer, readCursor, endCursor);
+    readCursor = Math.abs(signedCursor0);
+  }
+  return count;
+}
+function extractUnsignedIntegerListAt(buffer, cursor, endCursor, sink) {
+  const marked = sink.length;
+  while (cursor < endCursor && WHITESPACE4.has(buffer[cursor])) {
+    ++cursor;
+  }
+  if (cursor >= endCursor) {
+    return void 0;
+  }
+  if (buffer[cursor] === parsing_constants_default.DOLLAR) {
+    return 0;
+  }
+  if (buffer[cursor] !== OPEN_PAREN3) {
+    return void 0;
+  }
+  ++cursor;
+  let count = 0;
+  while (cursor < endCursor) {
+    while (cursor < endCursor && WHITESPACE4.has(buffer[cursor])) {
+      ++cursor;
+    }
+    if (cursor >= endCursor) {
+      sink.truncate(marked);
+      return void 0;
+    }
+    if (buffer[cursor] === CLOSE_PAREN3) {
+      return count;
+    }
+    if (count > 0) {
+      if (buffer[cursor] !== COMMA3) {
+        sink.truncate(marked);
+        return void 0;
+      }
+      ++cursor;
+      while (cursor < endCursor && WHITESPACE4.has(buffer[cursor])) {
+        ++cursor;
+      }
+      if (cursor >= endCursor) {
+        sink.truncate(marked);
+        return void 0;
+      }
+    }
+    const digit = buffer[cursor] - ZERO6;
+    if (digit < 0 || digit > 9) {
+      sink.truncate(marked);
+      return void 0;
+    }
+    let value = digit;
+    ++cursor;
+    while (cursor < endCursor) {
+      const next = buffer[cursor] - ZERO6;
+      if (next < 0 || next > 9) {
+        break;
+      }
+      value = value * 10 + next;
+      ++cursor;
+    }
+    sink.push(value);
+    ++count;
+  }
+  sink.truncate(marked);
+  return void 0;
+}
+
 // compiled/src/indexing/index_set_constants.js
 var IndexSetConstants = class {
 };
@@ -4915,23 +5293,54 @@ var InterpolationSearchTable32 = class {
 };
 
 // compiled/src/step/step_model_base.js
-var StepModelBase = class {
+var StepModelBase = class _StepModelBase {
   /**
    * Construct this step model with its matching schema, a buffer to read from and an element index.
    *
    * @param schema The Step schema this is based on.
-   * @param buffer_ The buffer to read this from.
+   * @param buffer_ The buffer to read this from. Pass `undefined` together
+   * with `provider` to build a model whose source is windowed from
+   * construction (e.g. a streaming open — see buildModelStreaming); the
+   * synchronous read paths (geometry extraction) then require the relevant
+   * ranges to be resident, exactly as after `spillSourceToExternalStore`.
    * @param elementIndex The element index for this, parsed or deserialized - note this takes
    * ownership of this array in the sense it will modify values/unfold inline elements etc.
+   * @param provider Optional pre-built buffer provider. When omitted, a
+   * resident provider over `buffer_` is used (the classic path).
    */
-  constructor(schema, buffer_, elementIndex) {
+  constructor(schema, buffer_, elementIndex, provider) {
     this.schema = schema;
     this.buffer_ = buffer_;
     this.vtableBuilder_ = new StepVtableBuilder();
     this.descriptorCache_ = [];
     this.elementMemoization = true;
     this.nullOnErrors = true;
-    this.bufferProvider_ = new ResidentStepBufferProvider(buffer_);
+    this.bufferProvider_ = provider ?? new ResidentStepBufferProvider(buffer_);
+    if (!Array.isArray(elementIndex)) {
+      const columns = elementIndex;
+      const firstInline = columns.firstInlineElement;
+      const inlineCount = columns.count - firstInline;
+      const inlineElementTable2 = new Uint32Array(inlineCount << 1);
+      for (let where2 = 0; where2 < inlineCount; ++where2) {
+        inlineElementTable2[where2 << 1] = firstInline + where2;
+        inlineElementTable2[(where2 << 1) + 1] = columns.address[firstInline + where2];
+      }
+      this.inlineAddressMap_ = new InterpolationSearchTable32(inlineElementTable2, true);
+      const expressIdTable2 = new Uint32Array(firstInline << 1);
+      for (let where2 = 0; where2 < firstInline; ++where2) {
+        expressIdTable2[where2 << 1] = where2;
+        expressIdTable2[(where2 << 1) + 1] = columns.expressID[where2];
+      }
+      this.expressIDMap_ = new InterpolationSearchTable32(expressIdTable2, columns.expressIdsSorted);
+      this.address_ = columns.address;
+      this.length_ = columns.length;
+      this.typeID_ = columns.typeID;
+      this.expressID_ = columns.expressID;
+      this.count_ = columns.count;
+      this.firstInlineElement_ = firstInline;
+      this.complexEntries_ = columns.complexEntries;
+      return;
+    }
     const localElementIndex = elementIndex;
     let where = 0;
     const firstInlineElement = localElementIndex.length;
@@ -5074,11 +5483,94 @@ var StepModelBase = class {
     }
   }
   /**
-   * Populate a raw vtable entry for a particular element, extra
+   * Resolve an express ID to a local ID, using `hintLocalID + 1` when
+   * the next record is the one we want. Tessellated Faces lists are
+   * sequential (PSB: every faceset), so this turns 9.1M interpolation
+   * searches into one per faceset.
    *
-   * @param element The raw elment to populate the vtable entry for.
-   * @return {boolean} Did the vtable entry populate correctly?
+   * @param expressID The referenced record.
+   * @param hintLocalID Local ID of the previous resolve, if any.
+   * @return {number | undefined} The local ID, or undefined if unknown.
+   */
+  resolveExpressID(expressID, hintLocalID) {
+    if (hintLocalID !== void 0) {
+      const next = hintLocalID + 1;
+      if (next < this.firstInlineElement_ && this.expressID_[next] === expressID) {
+        return next;
+      }
+    }
+    return this.expressIDMap_.get(expressID);
+  }
+  /**
+   * Append a local record's unsigned-integer list field into `sink`
+   * without an express-ID lookup. The reference-level twin of
+   * `StepEntityBase.extractIntegerArrayInto`, for hot loops that walk
+   * millions of small records (tessellated facesets) where constructing
+   * an entity per record dominates. It deliberately handles only the
+   * simple case and reports failure otherwise, so callers keep a
+   * correct fallback rather than this growing subtle special cases:
+   * the record must be single-class (no multi-mapping) and exactly
+   * `expectedTypeID`.
+   *
+   * Field 0 is the data-block start the parser stored in `address_`
+   * (after `TYPE(`). Reading it from the columns skips the descriptor
+   * and vtable `entry()` would retain — on a 9 M-face model those are
+   * the objects the faceset path is trying not to build. Non-zero
+   * offsets still go through a vtable, because only field 0 has that
+   * address identity.
+   *
+   * @param localID The record's local ID.
+   * @param offset The field's vtable offset.
+   * @param expectedTypeID The type the record must be.
+   * @param sink Receives the appended values.
+   * @return {number | undefined} Count appended, or undefined when the
+   * fast path does not apply.
+   */
+  extractIntegerArrayByLocalIDInto(localID, offset, expectedTypeID, sink) {
+    if (localID >= this.count_) {
+      return void 0;
+    }
+    if (this.complexEntries_?.has(localID) || this.typeID_[localID] !== expectedTypeID) {
+      return void 0;
+    }
+    if (offset === 0) {
+      const address = this.address_[localID];
+      const acquisition = this.bufferProvider_.acquire(address, this.length_[localID]);
+      const viewAddress = address - acquisition.offset;
+      return extractIntegerArrayAt(acquisition.buffer, viewAddress, acquisition.buffer.length, sink);
+    }
+    const element = this.entry(localID);
+    if (element.vtableIndex === void 0 && !this.populateVtableEntryRaw(element)) {
+      return void 0;
+    }
+    if (element.buffer === void 0) {
+      this.populateBufferEntry(localID);
+    }
+    const vtable = element.vtable;
+    const buffer = element.buffer;
+    if (vtable === void 0 || buffer === void 0 || offset >= (element.vtableCount ?? 0)) {
+      return void 0;
+    }
+    return extractIntegerArrayAt(buffer, vtable[element.vtableIndex + offset], buffer.length, sink);
+  }
+  /**
+   * Append a referenced record's unsigned-integer list field into `sink`
+   * without materialising the referenced entity.
+   *
+   * @param expressID The referenced record's express ID.
+   * @param offset The field's vtable offset within the record.
+   * @param expectedTypeID The type the record must be.
+   * @param sink Receives the appended values.
+   * @return {number | undefined} Count appended, or undefined when the
+   * fast path does not apply.
    */
+  extractIntegerArrayByExpressIDInto(expressID, offset, expectedTypeID, sink) {
+    const localID = this.expressIDMap_.get(expressID);
+    if (localID === void 0) {
+      return void 0;
+    }
+    return this.extractIntegerArrayByLocalIDInto(localID, offset, expectedTypeID, sink);
+  }
   populateVtableEntryRaw(element) {
     if (element.vtableIndex !== void 0 || element.typeID === 0) {
       return true;
@@ -5123,6 +5615,11 @@ var StepModelBase = class {
     }
     const element = this.entry(localID);
     element.buffer = this.bufferProvider_.acquire(element.address, element.length).buffer;
+    if (element.multiMapping !== void 0) {
+      for (const mapped of element.multiMapping) {
+        mapped.buffer = this.bufferProvider_.acquire(mapped.address, mapped.length).buffer;
+      }
+    }
   }
   /**
    * Get the size in bytes of the backing buffer for this.
@@ -5150,6 +5647,74 @@ var StepModelBase = class {
   get residentSourceBytes() {
     return this.bufferProvider_.residentBytes;
   }
+  /**
+   * Column type of a record, or `undefined` if the id is unknown / untyped.
+   *
+   * @param localID The record.
+   * @return {number | undefined} The schema type id.
+   */
+  typeIDOf(localID) {
+    if (localID >= this.count_) {
+      return;
+    }
+    const typeID = this.typeID_[localID];
+    return typeID < 0 ? void 0 : typeID;
+  }
+  /**
+   * Absolute source address of a record.
+   *
+   * @param localID The record.
+   * @return {number | undefined} The address.
+   */
+  recordAddress(localID) {
+    return localID < this.count_ ? this.address_[localID] : void 0;
+  }
+  /**
+   * Source length of a record.
+   *
+   * @param localID The record.
+   * @return {number | undefined} The length.
+   */
+  recordLength(localID) {
+    return localID < this.count_ ? this.length_[localID] : void 0;
+  }
+  /**
+   * Pin an arbitrary source span (e.g. a faceset's packed Faces[] run).
+   *
+   * @param address Absolute start.
+   * @param length Length in bytes.
+   */
+  pinAddressRange(address, length) {
+    if (!this.isSourceExternal) {
+      return;
+    }
+    this.bufferProvider_.pinRange?.(address, length);
+  }
+  /**
+   * Drop one {@link pinAddressRange} hold.
+   *
+   * @param address Absolute start.
+   * @param length Length in bytes.
+   */
+  unpinAddressRange(address, length) {
+    if (!this.isSourceExternal) {
+      return;
+    }
+    this.bufferProvider_.unpinRange?.(address, length);
+  }
+  /**
+   * Page an arbitrary source span.
+   *
+   * @param address Absolute start.
+   * @param length Length in bytes.
+   * @return {Promise<void>} Resolves when resident.
+   */
+  async ensureResidentRange(address, length) {
+    if (!this.isSourceExternal) {
+      return;
+    }
+    await this.bufferProvider_.ensureResident(address, length);
+  }
   /**
    * Release the resident source buffer and serve subsequent record
    * reads from fixed-size windows paged in from an external store.
@@ -5224,6 +5789,320 @@ var StepModelBase = class {
     }
     await this.ensureResidentByLocalID(localID);
   }
+  /**
+   * Page in the byte ranges a record *and every `#ref` reachable from
+   * its text* will need, so a following synchronous extract of that
+   * subgraph succeeds on a windowed source. Inverse relationships
+   * (not written in the record) are not discovered — callers that
+   * need them (rel-voids, styled items) pass their local IDs as
+   * `extraLocalIDs`.
+   *
+   * No-op while the source is fully resident.
+   *
+   * @param localID Seed record.
+   * @param extraLocalIDs Additional seeds (voids, styles, materials).
+   * @param seen Optional set to extend (also skips already-pinned IDs).
+   * @param descend If set, records for which this returns false are
+   * still visited (pinned, in `seen`) but their `#refs` are not
+   * followed — e.g. an `IfcPolygonalFaceSet` whose Faces[] payload
+   * is paged as one span afterwards.
+   * @param leafSpans Optional out-array of coalesced pin ranges for
+   * {@link spanLeaf} children — caller must {@link unpinAddressRange}
+   * each.
+   * @param spanLeaf If set, matching children are *not* visited
+   * (absent from `seen`); their bytes are one pin span. Packed
+   * extract reads `IfcIndexedPolygonalFace.CoordIndex` as integers —
+   * following those faces pinned ~78k records per PSB product. If
+   * omitted, `!descend` children use this span path (test helper).
+   * @param claimed Optional out-set of the IDs *this call* claimed and
+   * awaited residency for — a strict subset of `seen`. When `seen` is
+   * shared across concurrent walks (a batch of products sharing mapped
+   * geometry), an ID another walk claimed is skipped here and is NOT
+   * resident yet from this call's point of view: that walk's pin holds
+   * the chunk once it lands, but its read is still in flight. Anything
+   * that must synchronously read a record's bytes after this returns
+   * has to iterate `claimed`, never `seen` (conway#526).
+   * @return {Promise<Set<number>>} The local IDs that were visited.
+   */
+  async ensureResidentClosureByLocalID(localID, extraLocalIDs, seen = /* @__PURE__ */ new Set(), descend, leafSpans, spanLeaf, claimed) {
+    if (!this.isSourceExternal) {
+      return seen;
+    }
+    const frontier = [];
+    const enqueue = (id) => {
+      if (id < this.count_ && !seen.has(id)) {
+        frontier.push(id);
+      }
+    };
+    enqueue(localID);
+    if (extraLocalIDs !== void 0) {
+      for (const extra of extraLocalIDs) {
+        enqueue(extra);
+      }
+    }
+    while (frontier.length > 0) {
+      const wave = [];
+      for (const id of frontier) {
+        if (seen.has(id) || id >= this.count_) {
+          continue;
+        }
+        seen.add(id);
+        this.pinByLocalID(id);
+        wave.push(id);
+        claimed?.add(id);
+      }
+      frontier.length = 0;
+      if (wave.length === 0) {
+        break;
+      }
+      await Promise.all(wave.map((id) => this.ensureResidentByLocalID(id)));
+      const waveSpans = [];
+      for (const id of wave) {
+        if (descend !== void 0 && !descend(id)) {
+          continue;
+        }
+        const skipped = [];
+        for (const expressID of this.scanRecordRefs_(id)) {
+          const referenced = this.expressIDMap_.get(expressID);
+          if (referenced === void 0 || seen.has(referenced)) {
+            continue;
+          }
+          const leaf = spanLeaf !== void 0 ? spanLeaf(referenced) : descend !== void 0 && !descend(referenced);
+          if (leaf) {
+            skipped.push(referenced);
+            continue;
+          }
+          frontier.push(referenced);
+        }
+        if (skipped.length > 0) {
+          for (const span of this.spansOf_(skipped)) {
+            this.pinAddressRange(span.address, span.length);
+            waveSpans.push(span);
+            leafSpans?.push(span);
+          }
+        }
+      }
+      if (waveSpans.length > 0) {
+        await Promise.all(waveSpans.map((span) => this.ensureResidentRange(span.address, span.length)));
+      }
+    }
+    return seen;
+  }
+  /**
+   * Hold a record's source range against windowed LRU eviction until
+   * {@link unpinByLocalID}. No-op while the source is fully resident.
+   *
+   * @param localID The record to pin.
+   */
+  pinByLocalID(localID) {
+    if (!this.isSourceExternal || localID >= this.count_) {
+      return;
+    }
+    this.bufferProvider_.pinRange?.(this.address_[localID], this.length_[localID]);
+  }
+  /**
+   * Drop one {@link pinByLocalID} hold.
+   *
+   * @param localID The record to unpin.
+   */
+  unpinByLocalID(localID) {
+    if (!this.isSourceExternal || localID >= this.count_) {
+      return;
+    }
+    this.bufferProvider_.unpinRange?.(this.address_[localID], this.length_[localID]);
+  }
+  /**
+   * Drop captured source-window views on `localIDs` so the LRU can
+   * evict those chunks. Vtables stay — `acquire` of the same
+   * `(address, length)` is at a stable base. The next
+   * `ensureResident` + field read rematerialises the view.
+   *
+   * @param localIDs Records whose `buffer` views to drop.
+   */
+  releaseSourceViews(localIDs) {
+    if (!this.isSourceExternal) {
+      return;
+    }
+    for (const localID of localIDs) {
+      if (localID >= this.count_) {
+        continue;
+      }
+      const item = this.complexEntries_?.get(localID) ?? this.descriptorCache_[localID];
+      if (item === void 0) {
+        continue;
+      }
+      item.buffer = void 0;
+      if (item.multiMapping !== void 0) {
+        for (const mapped of item.multiMapping) {
+          mapped.buffer = void 0;
+        }
+      }
+    }
+    releaseScratchParsingBuffer();
+  }
+  /**
+   * Unpin every local ID in `localIDs` (best-effort; missing IDs are
+   * ignored). Use after {@link ensureResidentClosureByLocalID}, which
+   * pins as it walks.
+   *
+   * @param localIDs The records to unpin.
+   */
+  unpinLocalIDs(localIDs) {
+    for (const localID of localIDs) {
+      this.unpinByLocalID(localID);
+    }
+  }
+  /**
+   * Express-ID twin of {@link ensureResidentClosureByLocalID}. Unknown
+   * IDs resolve to an empty visit set.
+   *
+   * @param expressID Seed record.
+   * @param extraLocalIDs Additional seeds (local IDs).
+   * @return {Promise<Set<number>>} The local IDs that were visited.
+   */
+  async ensureResidentClosureByExpressID(expressID, extraLocalIDs, seen) {
+    if (!this.isSourceExternal) {
+      return seen ?? /* @__PURE__ */ new Set();
+    }
+    const localID = this.expressIDMap_.get(expressID);
+    if (localID === void 0) {
+      return seen ?? /* @__PURE__ */ new Set();
+    }
+    return this.ensureResidentClosureByLocalID(localID, extraLocalIDs, seen);
+  }
+  /**
+   * Source spans covering the records referenced by `expressIDs` from
+   * `fromIndex` onward. A packed Faces[] run is consecutive in parse
+   * order — two express-ID lookups then cover the whole range. Sparse
+   * sets are coalesced into tight runs so intervening file is not
+   * pinned.
+   *
+   * @param expressIDs Referenced express IDs (e.g. a faceset's #refs).
+   * @param fromIndex First index to include (skip Coordinates at [0]).
+   * @return {{address: number, length: number}[]} The spans.
+   */
+  spansOfExpressIDs(expressIDs, fromIndex = 0) {
+    let minExpressID = Infinity;
+    let maxExpressID = 0;
+    let count = 0;
+    for (let i = fromIndex; i < expressIDs.length; ++i) {
+      const expressID = expressIDs[i];
+      if (expressID < minExpressID) {
+        minExpressID = expressID;
+      }
+      if (expressID > maxExpressID) {
+        maxExpressID = expressID;
+      }
+      ++count;
+    }
+    if (count === 0 || !Number.isFinite(minExpressID)) {
+      return [];
+    }
+    const minLocal = this.expressIDMap_.get(minExpressID);
+    const maxLocal = this.expressIDMap_.get(maxExpressID);
+    if (minLocal === void 0 || maxLocal === void 0) {
+      return [];
+    }
+    const lo = Math.min(minLocal, maxLocal);
+    const hi = Math.max(minLocal, maxLocal);
+    if (hi - lo + 1 === count) {
+      const address = this.address_[lo];
+      const end = this.address_[hi] + this.length_[hi];
+      if (end <= address) {
+        return [];
+      }
+      return [{ address, length: end - address }];
+    }
+    const locals = [];
+    for (let i = fromIndex; i < expressIDs.length; ++i) {
+      const localID = this.expressIDMap_.get(expressIDs[i]);
+      if (localID !== void 0) {
+        locals.push(localID);
+      }
+    }
+    return this.spansOf_(locals);
+  }
+  /**
+   * Coalesce `localIDs` into tight source runs. Records more than
+   * {@link LEAF_SPAN_COALESCE_GAP_} apart stay separate so a sparse
+   * Faces[] list does not pin the file between them.
+   *
+   * @param localIDs The records.
+   * @return {{address: number, length: number}[]} The spans.
+   */
+  spansOf_(localIDs) {
+    const items = [];
+    for (const id of localIDs) {
+      if (id >= this.count_) {
+        continue;
+      }
+      items.push({
+        address: this.address_[id],
+        length: this.length_[id]
+      });
+    }
+    items.sort((a2, b) => a2.address - b.address);
+    const spans = [];
+    let run;
+    for (const item of items) {
+      if (run === void 0) {
+        run = { address: item.address, length: item.length };
+        continue;
+      }
+      const runEnd = run.address + run.length;
+      if (item.address <= runEnd + _StepModelBase.LEAF_SPAN_COALESCE_GAP_) {
+        const end = Math.max(runEnd, item.address + item.length);
+        run.length = end - run.address;
+        continue;
+      }
+      spans.push(run);
+      run = { address: item.address, length: item.length };
+    }
+    if (run !== void 0) {
+      spans.push(run);
+    }
+    return spans;
+  }
+  /**
+   * Express IDs referenced by a resident record (`#<id>` tokens in its
+   * text, including multi-mapped class records). The record itself
+   * must already be resident.
+   *
+   * @param localID The record to scan.
+   * @return {number[]} Distinct referenced express IDs.
+   */
+  referencedExpressIDs(localID) {
+    return this.scanRecordRefs_(localID);
+  }
+  /**
+   * Scan a resident record's bytes for `#<expressID>` references.
+   *
+   * @param localID The record to scan.
+   * @return {number[]} Distinct referenced express IDs.
+   */
+  scanRecordRefs_(localID) {
+    const address = this.address_[localID];
+    const length = this.length_[localID];
+    const acquisition = this.bufferProvider_.acquire(address, length);
+    const viewStart = address - acquisition.offset;
+    const refs = scanExpressRefs(acquisition.buffer, viewStart, length);
+    const complex = this.complexEntries_?.get(localID);
+    if (complex?.multiMapping === void 0) {
+      return refs;
+    }
+    const seen = new Set(refs);
+    for (const mapped of complex.multiMapping) {
+      const mappedAcquisition = this.bufferProvider_.acquire(mapped.address, mapped.length);
+      const mappedStart = mapped.address - mappedAcquisition.offset;
+      for (const expressID of scanExpressRefs(mappedAcquisition.buffer, mappedStart, mapped.length)) {
+        if (!seen.has(expressID)) {
+          seen.add(expressID);
+          refs.push(expressID);
+        }
+      }
+    }
+    return refs;
+  }
   /**
    * Get the number of elements/entities in this model.
    *
@@ -5608,6 +6487,8 @@ var StepModelBase = class {
     return this.geometry?.getByLocalID(node.localID);
   }
 };
+StepModelBase.LEAF_SPAN_COALESCE_GAP_ = 1024;
+var step_model_base_default = StepModelBase;
 
 // compiled/src/core/entity_field_description.js
 var FieldDescriptionKind;
@@ -10195,6 +11076,67 @@ function IfcWorkScheduleTypeEnumDeserializeStep(input2, cursor, endCursor) {
   return parser208.extract(IfcWorkScheduleTypeEnumSearch, input2, cursor, endCursor);
 }
 
+// compiled/src/core/wasm_heap.js
+function describeHeap(wasmModule, arrayPtr, numBytes) {
+  const heap = wasmModule.HEAPU8;
+  const buffer = currentHeapBuffer(wasmModule);
+  const shared = typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+  const kind = buffer === void 0 ? "none" : shared ? "SharedArrayBuffer" : "ArrayBuffer";
+  const extensible = shared ? buffer?.growable : buffer?.resizable;
+  return `ptr ${arrayPtr} + ${numBytes} bytes, heap view length ${heap?.length}, buffer ${kind} byteLength ${buffer?.byteLength}, extensible ${extensible}`;
+}
+function currentHeapBuffer(wasmModule) {
+  const memory = wasmModule.wasmMemory;
+  return memory !== void 0 ? memory.buffer : wasmModule.HEAPU8?.buffer;
+}
+function refreshHeapViews(wasmModule) {
+  if (typeof wasmModule.updateMemoryViews === "function") {
+    wasmModule.updateMemoryViews();
+    return;
+  }
+  if (wasmModule.wasmMemory !== void 0) {
+    return;
+  }
+  const StringVector = wasmModule.stringVector;
+  if (StringVector === void 0) {
+    return;
+  }
+  let scratch;
+  releaseQuietly(() => {
+    const created2 = new StringVector();
+    scratch = created2;
+    created2.push_back("");
+  });
+  const created = scratch;
+  if (created !== void 0) {
+    releaseQuietly(() => created.delete());
+  }
+}
+function reconcileHeapBuffer(wasmModule, address, numBytes) {
+  const buffer = currentHeapBuffer(wasmModule);
+  if (buffer !== void 0 && address + numBytes <= buffer.byteLength) {
+    return buffer;
+  }
+  refreshHeapViews(wasmModule);
+  const refreshed = currentHeapBuffer(wasmModule);
+  if (refreshed !== void 0 && address + numBytes <= refreshed.byteLength) {
+    return refreshed;
+  }
+  throw new Error("wasm heap allocation lies outside the heap, and refreshing the module views did not reconcile it. " + describeHeap(wasmModule, address, numBytes));
+}
+function wasmHeapView(wasmModule, arrayType, pointer, elementCount) {
+  const address = pointer >>> 0;
+  const numBytes = elementCount * arrayType.BYTES_PER_ELEMENT;
+  return new arrayType(reconcileHeapBuffer(wasmModule, address, numBytes), address, elementCount);
+}
+function releaseQuietly(release) {
+  try {
+    release();
+  } catch (error) {
+    logger_default.debug(`wasm resource release failed during teardown: ${error instanceof Error ? error.message : error}`);
+  }
+}
+
 // compiled/src/step/step_entity_base.js
 var IfcTokenType;
 (function(IfcTokenType2) {
@@ -10351,6 +11293,27 @@ var StepEntityBase = class {
     }
     return value;
   }
+  /**
+   * Extract a number at the particular vtable offset (i.e. the position
+   * in the matching step object).
+   *
+   * Used by other extraction methods with wrappers to perform
+   * semantically correct extraction.
+   *
+   * Unlike the other extractors this has a single signature rather than an
+   * optional/non-optional overload pair, because LOGICAL is three-valued:
+   * `.U.` is a legitimate value that reads as null, so a non-optional LOGICAL
+   * is null-valued too and `optional` only decides whether a *missing* value
+   * throws. The old `optional: false` overload promised a bare `boolean` and
+   * was a lie for exactly the `.U.` case this extractor exists to handle.
+   *
+   * @param offset The offset in the vtable to extract from
+   * @param baseOffset The base offset in the vtable to extract from
+   * @param depth The depth of the vtable to extract from
+   * @param optional Is this an optional field?
+   * @return {boolean | null} The extracted logical, or null for `.U.` and for
+   * an absent optional.
+   */
   extractLogical(offset, baseOffset, depth, optional) {
     const [cursor, endCursor, buffer] = this.getOffsetAndEndCursor(offset, baseOffset, depth);
     const value = stepExtractLogical(buffer, cursor, endCursor);
@@ -10380,6 +11343,38 @@ var StepEntityBase = class {
     }
     return value;
   }
+  /**
+   * Resolve a single reference field to its local ID without
+   * constructing the target entity. Prep maps that only store
+   * `Item.localID` (IfcStyledItem → faceset) must not hydrate the
+   * target: on a windowed source that would pin the faceset record
+   * (often megabytes) for every styled item at once.
+   *
+   * @param offset The offset in the vtable to extract from.
+   * @param baseOffset The base offset of the class in the vtable.
+   * @param depth The depth in the inheritance hierarchy.
+   * @param optional Is this an optional field?
+   * @return {number | null} The referenced local ID, or null if the
+   * field is unset/optional-null.
+   */
+  extractReferenceLocalID(offset, baseOffset, depth, optional) {
+    const [cursor, endCursor, buffer] = this.getOffsetAndEndCursor(offset, baseOffset, depth);
+    const expressID = stepExtractReference(buffer, cursor, endCursor);
+    if (expressID !== void 0) {
+      return this.model.resolveExpressID(expressID) ?? null;
+    }
+    const inline = this.model.getInlineElementByAddress(extractInlineElementAddress(buffer, cursor, endCursor));
+    if (inline !== void 0) {
+      return inline.localID;
+    }
+    if (!optional) {
+      throw new Error("Value in STEP was incorrectly typed");
+    }
+    if (!this.model.nullOnErrors && stepExtractOptional(buffer, cursor, endCursor) !== null) {
+      throw new Error("Value in STEP was incorrectly typed");
+    }
+    return null;
+  }
   /**
    *
    * @param buffer
@@ -10585,6 +11580,7 @@ var StepEntityBase = class {
    */
   extractParseBuffer(offset, baseOffset, depth, result, module2, optional) {
     offset -= this.multiReference_ !== void 0 ? baseOffset : 0;
+    this.guaranteeBuffer();
     const internalReference = this.guaranteeVTable(depth);
     if (offset >= internalReference.vtableCount) {
       throw new Error("Couldn't read field due to too few fields in record");
@@ -10597,10 +11593,72 @@ var StepEntityBase = class {
     if (optional && stepExtractOptional(buffer, cursor, endCursor) === null) {
       return false;
     }
-    const dataPtr = result.resize(endCursor - cursor);
-    module2.HEAPU8.set(buffer.subarray(cursor, endCursor), dataPtr);
+    const length = endCursor - cursor;
+    const dataPtr = result.resize(length);
+    wasmHeapView(module2, Uint8Array, dataPtr, length).set(buffer.subarray(cursor, endCursor));
     return true;
   }
+  /**
+   * Append an unsigned-integer list field straight from the STEP buffer
+   * into `sink`, without materialising an intermediate `Array< number >`.
+   *
+   * Semantically identical to the generated array getters (same
+   * optional handling, same element extraction, same "incorrectly
+   * typed" error), but it neither allocates nor caches a per-record
+   * array — the caller owns one reusable sink for the whole batch. On
+   * tessellated models this removes millions of short-lived arrays and
+   * the retained heap that goes with them; see Uint32Sink.
+   *
+   * @param offset The offset in the vtable to extract from.
+   * @param baseOffset The base offset of the class in the vtable.
+   * @param depth The depth in the inheritance hierarchy.
+   * @param sink Receives the appended values.
+   * @return {number} How many values were appended (0 when the field is
+   * unset/optional-null).
+   */
+  /**
+   * Walk a reference-list field, handing each element's express ID to
+   * `onReference` without resolving it to an entity.
+   *
+   * Lets hot loops decide per element how to read the referenced record
+   * (see StepModelBase.extractIntegerArrayByExpressIDInto) instead of
+   * paying for an entity per element the way the generated list getters
+   * do. Inline (non-reference) elements yield `undefined`, and
+   * `onReference` returning false aborts the walk — together those let
+   * a caller bail out to the generated getter for anything it is not
+   * prepared to handle.
+   *
+   * @param offset The offset in the vtable to extract from.
+   * @param baseOffset The base offset of the class in the vtable.
+   * @param depth The depth in the inheritance hierarchy.
+   * @param onReference Receives each element's express ID, or undefined
+   * for an inline element; return false to abort.
+   * @return {boolean} False if the walk was aborted, true otherwise.
+   */
+  forEachReferenceInField(offset, baseOffset, depth, onReference) {
+    let cursor = this.getOffsetCursor(offset, baseOffset, depth);
+    const buffer = this.buffer;
+    const endCursor = buffer.length;
+    if (stepExtractOptional(buffer, cursor, endCursor) === null) {
+      return true;
+    }
+    let signedCursor0 = stepExtractArrayBegin(buffer, cursor, endCursor);
+    cursor = Math.abs(signedCursor0);
+    while (signedCursor0 >= 0) {
+      if (!onReference(stepExtractReference(buffer, cursor, endCursor))) {
+        return false;
+      }
+      cursor = skipValue(buffer, cursor, endCursor);
+      signedCursor0 = stepExtractArrayToken(buffer, cursor, endCursor);
+      cursor = Math.abs(signedCursor0);
+    }
+    return true;
+  }
+  extractIntegerArrayInto(offset, baseOffset, depth, sink) {
+    const cursor = this.getOffsetCursor(offset, baseOffset, depth);
+    const buffer = this.buffer;
+    return extractIntegerArrayAt(buffer, cursor, buffer.length, sink);
+  }
   /**
    * Extract a number at the particular vtable offset (i.e. the position
    * in the matching step object).
@@ -10636,6 +11694,7 @@ var StepEntityBase = class {
    * @return {Uint8Array} The buffer for this.
    */
   get buffer() {
+    this.guaranteeBuffer();
     return this.internalReference_.buffer;
   }
   /**
@@ -10726,6 +11785,9 @@ var StepEntityBase = class {
           throw new Error("Entity does not have matching table entry to read from model");
         }
       }
+      if (classReference.buffer === void 0) {
+        this.model.populateBufferEntry(this.localID);
+      }
       this.internalReference_.buffer = classReference.buffer;
       return classReference;
     }
@@ -10736,6 +11798,9 @@ var StepEntityBase = class {
         throw new Error("Entity does not have matching table entry to read from model");
       }
     }
+    if (internalReference.buffer === void 0) {
+      this.guaranteeBuffer();
+    }
     return internalReference;
   }
   /**
@@ -12562,7 +13627,7 @@ var IfcPresentationStyleAssignment = class extends StepEntityBase {
       let signedCursor0 = stepExtractArrayBegin(buffer, cursor, endCursor);
       cursor = Math.abs(signedCursor0);
       while (signedCursor0 >= 0) {
-        const value1Untyped = this.extractBufferReference(buffer, cursor, endCursor) ?? IfcNullStyleDeserializeStep(buffer, cursor, endCursor);
+        const value1Untyped = this.extractBufferReference(buffer, cursor, endCursor) ?? IfcNullStyleDeserializeStep(buffer, stepEnterTypedValue(buffer, cursor, endCursor, "IFCNULLSTYLE"), endCursor);
         if (!(value1Untyped instanceof IfcCurveStyle) && !(value1Untyped instanceof IfcFillAreaStyle) && !(value1Untyped instanceof IfcSurfaceStyle) && !(value1Untyped instanceof IfcTextStyle) && value1Untyped !== IfcNullStyle.NULL) {
           throw new Error("Value in select must be populated");
         }
@@ -14390,7 +15455,7 @@ var IfcLogical = class extends StepEntityBase {
   }
   get Value() {
     if (this.Value_ === void 0) {
-      this.Value_ = this.extractBoolean(0, 0, 0, false);
+      this.Value_ = this.extractLogical(0, 0, 0, false);
     }
     return this.Value_;
   }
@@ -25512,7 +26577,7 @@ var IfcRelInterferesElements = class extends IfcRelConnects {
   }
   get ImpliedOrder() {
     if (this.ImpliedOrder_ === void 0) {
-      this.ImpliedOrder_ = this.extractBoolean(8, 4, 3, false);
+      this.ImpliedOrder_ = this.extractLogical(8, 4, 3, false);
     }
     return this.ImpliedOrder_;
   }
@@ -63780,7 +64845,7 @@ var descriptions = [
       },
       ImpliedOrder: {
         kind: f.BOOLEAN,
-        optional: false,
+        optional: true,
         derived: false,
         offset: 8
       }
@@ -68752,7 +69817,7 @@ var descriptions = [
     fields: {
       Value: {
         kind: f.BOOLEAN,
-        optional: false,
+        optional: true,
         derived: false,
         offset: 0
       }
@@ -70049,6 +71114,68 @@ var StepTypeIndexer = class {
   constructor(typeCount) {
     this.elementCounter_ = new Int32Array(typeCount << 1);
   }
+  /**
+   * Create a type index from either index form — the parsed object array or
+   * the columnar index (M7).
+   *
+   * @param index The element index, object or columnar.
+   * @return {MultiIndexSet} The created multi-set index.
+   */
+  createFor(index) {
+    return Array.isArray(index) ? this.create(index) : this.createFromColumns(index);
+  }
+  /**
+   * Create a type index straight from the columnar index — the same
+   * membership `create` produces from the unfolded object array: every row's
+   * concrete type (top-level + inline; −1 rows skipped) plus the
+   * multi-mapping subtypes of retained complex entries at their parent's
+   * dense index.
+   *
+   * @param columns The columnar index.
+   * @return {MultiIndexSet} The created multi-set index.
+   */
+  createFromColumns(columns) {
+    for (let where = 0, end = this.elementCounter_.length; where < end; where += 2) {
+      initCountCompactedElements32State(this.elementCounter_, where);
+    }
+    const elementCounter = this.elementCounter_;
+    const prefixSum = new Uint32Array((this.elementCounter_.length >>> 1) + 1);
+    const typeIDs = columns.typeID;
+    const count = columns.count;
+    const walkRows = (addOne) => {
+      const complexIterator = columns.complexEntries?.entries();
+      let nextComplex = complexIterator?.next();
+      for (let denseIndex = 0; denseIndex < count; ++denseIndex) {
+        const typeID = typeIDs[denseIndex];
+        if (typeID >= 0) {
+          addOne(denseIndex, typeID);
+        }
+        if (nextComplex !== void 0 && !nextComplex.done && nextComplex.value[0] === denseIndex) {
+          for (const subElement of nextComplex.value[1].multiMapping ?? []) {
+            const subTypeID = subElement.typeID;
+            if (subTypeID !== void 0) {
+              addOne(denseIndex, subTypeID);
+            }
+          }
+          nextComplex = complexIterator.next();
+        }
+      }
+    };
+    walkRows((denseIndex, typeID) => {
+      prefixSum[typeID + 1] = addCompactedElementCount32State(denseIndex, elementCounter, typeID << 1);
+    });
+    for (let prefixSumIndex = 2, prefixSumEnd = prefixSum.length; prefixSumIndex < prefixSumEnd; ++prefixSumIndex) {
+      prefixSum[prefixSumIndex] += prefixSum[prefixSumIndex - 1];
+    }
+    for (let where = 0, end = this.elementCounter_.length; where < end; where += 2) {
+      initCountCompactedElements32State(this.elementCounter_, where);
+    }
+    const indexOutput = new Uint32Array(prefixSum[prefixSum.length - 1] << 1);
+    walkRows((denseIndex, typeID) => {
+      addCompactedElement32State(denseIndex, elementCounter, indexOutput, typeID << 1, prefixSum[typeID] << 1);
+    });
+    return new MultiIndexSet(prefixSum, indexOutput);
+  }
   /**
    * Create a type index from a set of parsed STEP elements.
    *
@@ -70216,9 +71343,24 @@ var IfcModelGeometry = class {
   /**
    * Add a mesh to the geometry cache.
    *
+   * Freezes the native float vertex mirror at add time (one
+   * GetVertexData call): consumers (the compat GetGeometry surface)
+   * read float vertices whose frame must match the scene transforms,
+   * which are authored against the geometry AS CREATED. Later native
+   * mutations that keep the vertex count (normalize's centering)
+   * deliberately do NOT refresh the mirror, so every extraction path —
+   * whole-model walk, per-product demand pump, parse-time preview —
+   * serves the same creation-frame floats. Without this, paths that
+   * first read vertices only after a centering mutation serve
+   * per-geometry-shifted vertices against unshifted transforms
+   * (Share's demand-path "scatter").
+   *
    * @param mesh
    */
   add(mesh) {
+    if (mesh.type === CanonicalMeshType.BUFFER_GEOMETRY) {
+      mesh.geometry.GetVertexData();
+    }
     this.meshes_.set(mesh.localID, mesh);
   }
   /**
@@ -70689,16 +71831,18 @@ var IfcMaterialCache = class {
 
 // compiled/src/ifc/ifc_step_model.js
 var indexerInstance = new StepTypeIndexer(EntityTypesIfcCount);
-var IfcStepModel = class extends StepModelBase {
+var IfcStepModel = class extends step_model_base_default {
   /**
    * Construct this model given a buffer containing the data and the parsed data index on that,
    * adding the typeIndex on top of that.
    *
-   * @param buffer The buffer to values from.
+   * @param buffer The buffer to values from, or `undefined` with `provider`
+   * set for a windowed (streaming) source.
    * @param elementIndex The parsed index to elements in the STEP.
+   * @param provider Optional pre-built buffer provider (windowed source).
    */
-  constructor(buffer, elementIndex) {
-    super(schema_ifc_gen_default, buffer, elementIndex);
+  constructor(buffer, elementIndex, provider) {
+    super(schema_ifc_gen_default, buffer, elementIndex, provider);
     this.externalMappingType = ifc_step_external_mapping_default;
     this.geometry = new IfcModelGeometry(this);
     this.voidGeometry = new IfcModelGeometry(this, true);
@@ -70708,11 +71852,330 @@ var IfcStepModel = class extends StepModelBase {
     this.materials = new IfcMaterialCache(this);
     this.voidMaterials = new IfcMaterialCache(this, true);
     this.elementTypeIDs = entity_types_ifc_gen_default;
-    this.typeIndex = indexerInstance.create(elementIndex);
+    this.typeIndex = indexerInstance.createFor(elementIndex);
   }
 };
 
+// compiled/src/step/parsing/columnar_index.js
+var COLUMN_UNDEFINED_TYPE = -1;
+var SEGMENT_ROWS = 64 * 1024;
+var ColumnarIndexSink = class {
+  constructor() {
+    this.segments_ = [];
+    this.count_ = 0;
+    this.retained_ = /* @__PURE__ */ new Map();
+    this.expressIdsSorted_ = true;
+    this.previousExpressID_ = 0;
+  }
+  /**
+   * @return {number} Top-level records pushed so far.
+   */
+  get topLevelCount() {
+    return this.count_;
+  }
+  /**
+   * Encode one completed top-level record into the columns. The entry object
+   * is not kept unless it carries children (inline entities / multi-mapping).
+   *
+   * @param entry The completed top-level index entry.
+   */
+  pushTopLevel(entry) {
+    const localID = this.count_++;
+    const segmentIndex = Math.floor(localID / SEGMENT_ROWS);
+    const row = localID % SEGMENT_ROWS;
+    if (segmentIndex === this.segments_.length) {
+      this.segments_.push({
+        address: new Uint32Array(SEGMENT_ROWS),
+        length: new Uint32Array(SEGMENT_ROWS),
+        typeID: new Int32Array(SEGMENT_ROWS),
+        expressID: new Uint32Array(SEGMENT_ROWS)
+      });
+    }
+    const segment = this.segments_[segmentIndex];
+    segment.address[row] = entry.address;
+    segment.length[row] = entry.length;
+    segment.typeID[row] = entry.typeID === void 0 ? COLUMN_UNDEFINED_TYPE : entry.typeID;
+    segment.expressID[row] = entry.expressID;
+    if (entry.expressID < this.previousExpressID_) {
+      this.expressIdsSorted_ = false;
+    }
+    this.previousExpressID_ = entry.expressID;
+    if (entry.inlineEntities !== void 0 || entry.multiMapping !== void 0) {
+      this.retained_.set(localID, entry);
+    }
+  }
+  /**
+   * Rewind to empty (the streaming builder's grow-and-restart). The first
+   * segment is kept for reuse.
+   */
+  reset() {
+    this.segments_.length = Math.min(this.segments_.length, 1);
+    this.count_ = 0;
+    this.retained_.clear();
+    this.expressIdsSorted_ = true;
+    this.previousExpressID_ = 0;
+  }
+  /**
+   * Snapshot the columns pushed SO FAR into a self-contained prefix index,
+   * without disturbing the sink — the parse can keep pushing afterwards and
+   * a later snapshot/finalize sees the full data. Safe to call between the
+   * cooperative parse's yields (the parser only suspends at top-level
+   * record boundaries, where the sink is consistent). Top-level localIDs
+   * are stable across snapshots (dense parse order), so consumers can carry
+   * per-localID cursors from one snapshot to the next; inline-range
+   * localIDs are NOT stable (the inline tail re-packs after the growing
+   * top-level range) and must not be carried across snapshots.
+   *
+   * @return {StepIndexColumns} A prefix columnar index over the records
+   * pushed so far.
+   */
+  snapshot() {
+    return this.assemble_();
+  }
+  /**
+   * Assemble the final columns: concatenate the top-level segments (one
+   * column at a time, bounding transient overhead to a single column's
+   * segments) and unfold retained inline entities into the inline range in
+   * the model's exact unfold order.
+   *
+   * @return {StepIndexColumns} The finished columnar index.
+   */
+  finalize() {
+    return this.assemble_();
+  }
+  /**
+   * Shared assembly behind {@link snapshot} and {@link finalize} — pure
+   * over the sink's current state.
+   *
+   * @return {StepIndexColumns} The assembled columnar index.
+   */
+  assemble_() {
+    const topLevel = this.count_;
+    const unfolded = [];
+    for (const entry of this.retained_.values()) {
+      if (entry.inlineEntities !== void 0) {
+        unfolded.push(...entry.inlineEntities);
+      }
+    }
+    for (let where = 0; where < unfolded.length; ++where) {
+      const inlineEntities = unfolded[where].inlineEntities;
+      if (inlineEntities !== void 0) {
+        unfolded.push(...inlineEntities);
+      }
+    }
+    const count = topLevel + unfolded.length;
+    const address = concatColumn(this.segments_, "address", topLevel, count);
+    const length = concatColumn(this.segments_, "length", topLevel, count);
+    const typeID = new Int32Array(count);
+    for (let segment = 0; segment * SEGMENT_ROWS < topLevel; ++segment) {
+      const rows = Math.min(SEGMENT_ROWS, topLevel - segment * SEGMENT_ROWS);
+      typeID.set(this.segments_[segment].typeID.subarray(0, rows), segment * SEGMENT_ROWS);
+    }
+    const expressID = concatColumn(this.segments_, "expressID", topLevel, topLevel);
+    for (let where = 0; where < unfolded.length; ++where) {
+      const entry = unfolded[where];
+      const row = topLevel + where;
+      address[row] = entry.address;
+      length[row] = entry.length;
+      typeID[row] = entry.typeID === void 0 ? COLUMN_UNDEFINED_TYPE : entry.typeID;
+    }
+    let complexEntries;
+    for (const [localID, entry] of this.retained_) {
+      if (entry.multiMapping !== void 0) {
+        (complexEntries ??= /* @__PURE__ */ new Map()).set(localID, cloneIndexEntry(entry));
+      }
+    }
+    return {
+      address,
+      length,
+      typeID,
+      expressID,
+      count,
+      firstInlineElement: topLevel,
+      complexEntries,
+      expressIdsSorted: this.expressIdsSorted_
+    };
+  }
+};
+function cloneIndexEntry(entry) {
+  const clone = {
+    address: entry.address,
+    length: entry.length
+  };
+  if (entry.typeID !== void 0) {
+    clone.typeID = entry.typeID;
+  }
+  if (entry.expressID !== void 0) {
+    clone.expressID = entry.expressID;
+  }
+  if (entry.inlineEntities !== void 0) {
+    clone.inlineEntities = entry.inlineEntities;
+  }
+  if (entry.multiMapping !== void 0) {
+    clone.multiMapping = entry.multiMapping.map(cloneIndexEntry);
+  }
+  return clone;
+}
+function concatColumn(segments, column, rows, finalLength) {
+  const result = new Uint32Array(finalLength);
+  for (let segment = 0; segment * SEGMENT_ROWS < rows; ++segment) {
+    const valid = Math.min(SEGMENT_ROWS, rows - segment * SEGMENT_ROWS);
+    result.set(segments[segment][column].subarray(0, valid), segment * SEGMENT_ROWS);
+  }
+  return result;
+}
+
+// compiled/src/step/parsing/streaming_index_builder.js
+function buildIndexStreaming(source, parser211, pool3, onRecordIndexed, sink) {
+  const fileSize = source.byteLength;
+  let windowBytes = Math.max(pool3, MIN_WINDOW);
+  for (; ; ) {
+    const window2 = new Uint8Array(windowBytes);
+    let windowStartFile = 0;
+    let windowLen = source.read(0, windowBytes, window2, 0);
+    let bytesRead = windowLen;
+    const input2 = new ParsingBuffer(window2, 0, windowLen);
+    const [header, headerResult] = parser211.parseHeader(input2);
+    if (headerResult !== ParseResult.COMPLETE) {
+      return {
+        header,
+        elements: [],
+        result: headerResult,
+        stats: { pool: pool3, windowBytes, slides: 0, maxRecordLen: 0, bytesRead }
+      };
+    }
+    const slideThreshold = windowBytes >> 1;
+    let slides = 0;
+    let maxRecordLen = 0;
+    let prevBoundaryFile = windowStartFile + input2.cursor;
+    const onRecordBoundary = (buffer) => {
+      const cursor = buffer.cursor;
+      const recordFileStart = windowStartFile + cursor;
+      const recordLen = recordFileStart - prevBoundaryFile;
+      if (recordLen > maxRecordLen) {
+        maxRecordLen = recordLen;
+      }
+      prevBoundaryFile = recordFileStart;
+      if (windowStartFile + windowLen >= fileSize) {
+        return;
+      }
+      if (cursor < slideThreshold) {
+        return;
+      }
+      const tail = windowLen - cursor;
+      window2.copyWithin(0, cursor, windowLen);
+      const want = windowBytes - tail;
+      const got = source.read(windowStartFile + windowLen, want, window2, tail);
+      bytesRead += got;
+      windowLen = tail + got;
+      windowStartFile = recordFileStart;
+      buffer.rebaseWindow(window2, 0, windowLen, windowStartFile);
+      ++slides;
+    };
+    const [index, result] = parser211.parseDataBlockStreamed(input2, onRecordBoundary, onRecordIndexed, void 0, sink);
+    const stoppedShort = result !== ParseResult.COMPLETE;
+    const notAtEof = windowStartFile + windowLen < fileSize;
+    if (stoppedShort && notAtEof) {
+      windowBytes *= 2;
+      sink?.reset();
+      continue;
+    }
+    const lastRecordLen = windowStartFile + input2.cursor - prevBoundaryFile;
+    if (lastRecordLen > maxRecordLen) {
+      maxRecordLen = lastRecordLen;
+    }
+    return {
+      header,
+      elements: index.elements,
+      result,
+      stats: { pool: pool3, windowBytes, slides, maxRecordLen, bytesRead }
+    };
+  }
+}
+var MIN_WINDOW = 4 * 1024;
+async function readSource(source, offset, length, into, intoOffset) {
+  return await source.read(offset, length, into, intoOffset);
+}
+async function buildIndexStreamingAsync(source, parser211, pool3, onRecordIndexed, sink, onProgress, yieldIntervalMs) {
+  const fileSize = source.byteLength;
+  let windowBytes = Math.max(pool3, MIN_WINDOW);
+  for (; ; ) {
+    const window2 = new Uint8Array(windowBytes);
+    let windowStartFile = 0;
+    let windowLen = await readSource(source, 0, windowBytes, window2, 0);
+    let bytesRead = windowLen;
+    const input2 = new ParsingBuffer(window2, 0, windowLen);
+    const [header, headerResult] = parser211.parseHeader(input2);
+    if (headerResult !== ParseResult.COMPLETE) {
+      return {
+        header,
+        elements: [],
+        result: headerResult,
+        stats: { pool: pool3, windowBytes, slides: 0, maxRecordLen: 0, bytesRead }
+      };
+    }
+    const slideThreshold = windowBytes >> 1;
+    let slides = 0;
+    let maxRecordLen = 0;
+    let prevBoundaryFile = windowStartFile + input2.cursor;
+    const onRecordBoundary = (buffer) => {
+      const cursor = buffer.cursor;
+      const recordFileStart = windowStartFile + cursor;
+      const recordLen = recordFileStart - prevBoundaryFile;
+      if (recordLen > maxRecordLen) {
+        maxRecordLen = recordLen;
+      }
+      prevBoundaryFile = recordFileStart;
+      if (windowStartFile + windowLen >= fileSize) {
+        return;
+      }
+      if (cursor < slideThreshold) {
+        return;
+      }
+      const tail = windowLen - cursor;
+      window2.copyWithin(0, cursor, windowLen);
+      const want = windowBytes - tail;
+      const fillAt = windowStartFile + windowLen;
+      return readSource(source, fillAt, want, window2, tail).then((got) => {
+        bytesRead += got;
+        windowLen = tail + got;
+        windowStartFile = recordFileStart;
+        buffer.rebaseWindow(window2, 0, windowLen, windowStartFile);
+        ++slides;
+      });
+    };
+    const progressTick = onProgress !== void 0 ? (cursor) => onProgress(windowStartFile + cursor) : void 0;
+    const [index, result] = await parser211.parseDataBlockStreamedAsync(input2, onRecordBoundary, onRecordIndexed, progressTick, sink, yieldIntervalMs);
+    const stoppedShort = result !== ParseResult.COMPLETE;
+    const notAtEof = windowStartFile + windowLen < fileSize;
+    if (stoppedShort && notAtEof) {
+      windowBytes *= 2;
+      sink?.reset();
+      continue;
+    }
+    const lastRecordLen = windowStartFile + input2.cursor - prevBoundaryFile;
+    if (lastRecordLen > maxRecordLen) {
+      maxRecordLen = lastRecordLen;
+    }
+    return {
+      header,
+      elements: index.elements,
+      result,
+      stats: { pool: pool3, windowBytes, slides, maxRecordLen, bytesRead }
+    };
+  }
+}
+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, sink = new ColumnarIndexSink()) {
+  const { header, result, stats } = await buildIndexStreamingAsync(source, parser211, pool3, onRecordIndexed, sink, onProgress, yieldIntervalMs);
+  return { header, columns: sink.finalize(), result, stats };
+}
+
 // compiled/src/ifc/ifc_step_parser.js
+var DEFAULT_STREAM_POOL_BYTES = 1024 * 1024;
 var IfcStepParser = class extends StepParser {
   /**
    * Construct the IFC step parser.
@@ -70745,6 +72208,61 @@ var IfcStepParser = class extends StepParser {
     const [itemIndex, parseResult2] = await this.parseDataBlockAsync(input2, onProgress);
     return [parseResult2, new IfcStepModel(input2.buffer, itemIndex.elements)];
   }
+  /**
+   * Build a model by streaming the source through a bounded moving window
+   * (see buildIndexStreaming / M0) rather than parsing one resident buffer,
+   * then backing the model with a windowed provider over `store` — so the
+   * source is never held fully resident in the JS heap.
+   *
+   * `source` serves the parse (synchronous windowed reads — on a worker this
+   * is an OPFS sync-access handle; in node/tests a file descriptor or buffer)
+   * and `store` serves the model's post-parse property access (asynchronous
+   * windowed reads paged in on demand — OPFS `File.slice()` in the browser).
+   * Both view the same file bytes, so the file-absolute addresses the index
+   * records resolve identically through either.
+   *
+   * NOTE (M1 scope): this delivers the bounded-memory *parse*. Synchronous
+   * geometry extraction still needs its record ranges resident — as after
+   * `spillSourceToExternalStore` — so a caller that extracts geometry must
+   * `ensureResident` first (demand-driven geometry is M3). Property / index
+   * access works directly via the async surfaces.
+   *
+   * @param source Synchronous byte source feeding the streaming parse.
+   * @param store Async external store backing the windowed model.
+   * @param opts Optional window sizing: `pool` (parse window),
+   * `chunkBytes` / `maxResidentChunks` (model window).
+   * @return {[ParseResult, IfcStepModel | undefined]} The parse result and
+   * the windowed model.
+   */
+  parseStreamToModel(source, store, opts) {
+    if (store.byteLength !== source.byteLength) {
+      throw new Error(`Streaming store byteLength ${store.byteLength} does not match source byteLength ${source.byteLength}`);
+    }
+    const { columns, result } = buildColumnarIndexStreaming(source, this, opts?.pool ?? DEFAULT_STREAM_POOL_BYTES);
+    const provider = new WindowedStepBufferProvider(store, opts?.chunkBytes, opts?.maxResidentChunks);
+    return [result, new IfcStepModel(void 0, columns, provider)];
+  }
+  /**
+   * Cooperative twin of {@link parseStreamToModel}: the index build
+   * yields to the event loop and can fill windows from an async
+   * {@link ReadableByteSource} (an OPFS `File.slice()` store). The
+   * model is still windowed — geometry extract must
+   * `ensureResident` first.
+   *
+   * @param source Sync or async byte source feeding the parse.
+   * @param store Async external store backing the windowed model.
+   * @param opts Optional window sizing plus parse progress.
+   * @return {Promise<[ParseResult, IfcStepModel | undefined]>} The
+   * parse result and the windowed model.
+   */
+  async parseStreamToModelAsync(source, store, opts) {
+    if (store.byteLength !== source.byteLength) {
+      throw new Error(`Streaming store byteLength ${store.byteLength} does not match source byteLength ${source.byteLength}`);
+    }
+    const { columns, result } = await buildColumnarIndexStreamingAsync(source, this, opts?.pool ?? DEFAULT_STREAM_POOL_BYTES, void 0, opts?.onProgress);
+    const provider = new WindowedStepBufferProvider(store, opts?.chunkBytes, opts?.maxResidentChunks);
+    return [result, new IfcStepModel(void 0, columns, provider)];
+  }
 };
 IfcStepParser.Instance = new IfcStepParser();
 var ifc_step_parser_default = IfcStepParser;