@bldrs-ai/conway 1.399.1223 → 1.401.1237

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.399.1223";
+var versionString = "Conway v1.401.1237";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -2200,6 +2200,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.
    *
@@ -3452,6 +3483,34 @@ var StepParser = class extends StepHeaderParser {
       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.
+   * @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.
+   * @param onProgress Optional byte-cursor progress callback.
+   * @return {BlockParseResult} The parsing result, including the index and result enum.
+   */
+  parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed, onProgress) {
+    const parser211 = this.parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed);
+    while (true) {
+      const next = parser211.next();
+      if (next.done === true) {
+        return next.value;
+      }
+      onProgress?.(next.value);
+    }
+  }
   /**
    * Cooperative variant of parseDataBlock: identical parse (same generator
    * body), but periodically awaits a macrotask so the event loop can run —
@@ -3489,7 +3548,7 @@ 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(input) {
+  *parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed) {
     const indexResult = { elements: [] };
     const match = input.match;
     const comment = () => match(commentParser2);
@@ -3536,7 +3595,7 @@ var StepParser = class extends StepHeaderParser {
         return syntaxError();
       }
       whitespace();
-      const startElement = input.cursor;
+      const startElement = input.address;
       let stackDepth = 1;
       const savedInlineElements = inlineElements;
       inlineElements = void 0;
@@ -3630,6 +3689,7 @@ var StepParser = class extends StepHeaderParser {
       if ((++parsedElementCount & PARSE_PROGRESS_ELEMENT_MASK) === 0) {
         yield input.cursor;
       }
+      onRecordBoundary?.(input);
       if (!charws(HASH2)) {
         if (tokenws(END_SECTION)) {
           return parseResult2(ParseResult.COMPLETE);
@@ -3652,7 +3712,7 @@ var StepParser = class extends StepHeaderParser {
         }
         whitespace();
         inlineElements = void 0;
-        const startElement2 = input.cursor;
+        const startElement2 = input.address;
         while (!charws(CLOSE_PAREN2)) {
           input.begin();
           const elementResult = parseInlineElement(expressID);
@@ -3665,6 +3725,7 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
+        onRecordIndexed?.(indexResult.elements.length, expressID, 0);
         indexResult.elements.push({
           address: startElement2,
           length: input.address - startElement2,
@@ -3683,7 +3744,7 @@ var StepParser = class extends StepHeaderParser {
         return syntaxError();
       }
       whitespace();
-      const startElement = input.cursor;
+      const startElement = input.address;
       let stackDepth = 1;
       inlineElements = void 0;
       while (stackDepth > 0) {
@@ -3756,6 +3817,7 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
+      onRecordIndexed?.(indexResult.elements.length, expressID, foundItem);
       indexResult.elements.push({
         address: startElement,
         length: input.address - startElement,
@@ -4918,18 +4980,24 @@ var StepModelBase = class {
    * 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_);
     const localElementIndex = elementIndex;
     let where = 0;
     const firstInlineElement = localElementIndex.length;
@@ -70692,11 +70760,13 @@ var IfcStepModel = class extends StepModelBase {
    * 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);
@@ -70710,7 +70780,76 @@ var IfcStepModel = class extends StepModelBase {
   }
 };
 
+// compiled/src/step/parsing/streaming_index_builder.js
+function buildIndexStreaming(source, parser211, pool3, onRecordIndexed) {
+  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 input = new ParsingBuffer(window2, 0, windowLen);
+    const [header, headerResult] = parser211.parseHeader(input);
+    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 + input.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(input, onRecordBoundary, onRecordIndexed);
+    const stoppedShort = result !== ParseResult.COMPLETE;
+    const notAtEof = windowStartFile + windowLen < fileSize;
+    if (stoppedShort && notAtEof) {
+      windowBytes *= 2;
+      continue;
+    }
+    const lastRecordLen = windowStartFile + input.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;
+
 // compiled/src/ifc/ifc_step_parser.js
+var DEFAULT_STREAM_POOL_BYTES = 1024 * 1024;
 var IfcStepParser = class extends StepParser {
   /**
    * Construct the IFC step parser.
@@ -70743,6 +70882,40 @@ var IfcStepParser = class extends StepParser {
     const [itemIndex, parseResult2] = await this.parseDataBlockAsync(input, onProgress);
     return [parseResult2, new IfcStepModel(input.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 { elements, result } = buildIndexStreaming(source, this, opts?.pool ?? DEFAULT_STREAM_POOL_BYTES);
+    const provider = new WindowedStepBufferProvider(store, opts?.chunkBytes, opts?.maxResidentChunks);
+    return [result, new IfcStepModel(void 0, elements, provider)];
+  }
 };
 IfcStepParser.Instance = new IfcStepParser();
 var ifc_step_parser_default = IfcStepParser;

package/compiled/src/ifc/ifc_step_model.d.ts

@@ -8,6 +8,7 @@ import IfcStepExternalMapping from "./ifc_step_external_mapping.js";
 import IfcModelCurves from "./ifc_model_curves.js";
 import { CsgMemoization } from "../core/csg_operations.js";
 import { IfcMaterialCache } from "./ifc_material_cache.js";
+import { StepBufferProvider } from "../step/step_buffer_provider.js";
 /**
  * Represents an IFC model deserialized from step.
  */
@@ -26,9 +27,11 @@ export default class IfcStepModel extends StepModelBase<EntityTypesIfc> {
      * 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: Uint8Array, elementIndex: StepIndexEntry<EntityTypesIfc>[]);
+    constructor(buffer: Uint8Array | undefined, elementIndex: StepIndexEntry<EntityTypesIfc>[], provider?: StepBufferProvider);
 }
 //# sourceMappingURL=ifc_step_model.d.ts.map

package/compiled/src/ifc/ifc_step_model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ifc_step_model.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,cAAqC,MAAM,iCAAiC,CAAA;AACnF,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAE1D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,sBAAsB,MAAM,6BAA6B,CAAA;AAChE,OAAO,cAAc,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAKvD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa,CAAE,cAAc,CAAE;IAEvE,SAAgB,SAAS,EAAE,aAAa,CAAE,cAAc,CAAE,CAAA;IAC1D,SAAgB,mBAAmB,gCAAyB;IAC5D,SAAgB,QAAQ,mBAA+B;IACvD,SAAgB,YAAY,mBAAqC;IACjE,SAAgB,QAAQ,kBAA4B;IACpD,SAAgB,MAAM,iBAA2B;IACjD,SAAgB,aAAa,iBAAuB;IACpD,SAAgB,SAAS,mBAA+B;IACxD,SAAgB,aAAa,mBAAqC;IAClE,SAAgB,cAAc,wBAAiB;IAE/C;;;;;;OAMG;gBAEC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,cAAc,CAAE,cAAc,CAAE,EAAE;CAKrD"}
+{"version":3,"file":"ifc_step_model.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,cAAqC,MAAM,iCAAiC,CAAA;AACnF,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAE1D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,sBAAsB,MAAM,6BAA6B,CAAA;AAChE,OAAO,cAAc,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AAKjE;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa,CAAE,cAAc,CAAE;IAEvE,SAAgB,SAAS,EAAE,aAAa,CAAE,cAAc,CAAE,CAAA;IAC1D,SAAgB,mBAAmB,gCAAyB;IAC5D,SAAgB,QAAQ,mBAA+B;IACvD,SAAgB,YAAY,mBAAqC;IACjE,SAAgB,QAAQ,kBAA4B;IACpD,SAAgB,MAAM,iBAA2B;IACjD,SAAgB,aAAa,iBAAuB;IACpD,SAAgB,SAAS,mBAA+B;IACxD,SAAgB,aAAa,mBAAqC;IAClE,SAAgB,cAAc,wBAAiB;IAE/C;;;;;;;;OAQG;gBAEC,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,YAAY,EAAE,cAAc,CAAE,cAAc,CAAE,EAAE,EAChD,QAAQ,CAAC,EAAE,kBAAkB;CAKlC"}

package/compiled/src/ifc/ifc_step_model.js

@@ -17,11 +17,13 @@ export default class IfcStepModel extends StepModelBase {
      * 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(SchemaIfc, buffer, elementIndex);
+    constructor(buffer, elementIndex, provider) {
+        super(SchemaIfc, buffer, elementIndex, provider);
         this.externalMappingType = IfcStepExternalMapping;
         this.geometry = new IfcModelGeometry(this);
         this.voidGeometry = new IfcModelGeometry(this, true);

package/compiled/src/ifc/ifc_step_parser.d.ts

@@ -2,6 +2,8 @@ import ParsingBuffer from "../parsing/parsing_buffer.js";
 import StepParser, { ParseProgressCallback, ParseResult } from "../step/parsing/step_parser.js";
 import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
 import IfcStepModel from "./ifc_step_model.js";
+import { ByteSource } from "../step/parsing/byte_source.js";
+import { StepExternalByteStore } from "../step/step_buffer_provider.js";
 /**
  * Parser for taking IFC file serialized in step and turning them into a lazily parsed model.
  */
@@ -42,5 +44,39 @@ export default class IfcStepParser extends StepParser<EntityTypesIfc> {
         ParseResult,
         IfcStepModel | undefined
     ]>;
+    /**
+     * 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: ByteSource, store: StepExternalByteStore, opts?: {
+        pool?: number;
+        chunkBytes?: number;
+        maxResidentChunks?: number;
+    }): [
+        ParseResult,
+        IfcStepModel | undefined
+    ];
 }
 //# sourceMappingURL=ifc_step_parser.d.ts.map

package/compiled/src/ifc/ifc_step_parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ifc_step_parser.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_parser.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,2BAA2B,CAAA;AACrD,OAAO,UAAU,EAAE,EAAC,qBAAqB,EAAE,WAAW,EAAC,MAAM,6BAA6B,CAAA;AAC1F,OAAO,cAAc,MAAM,iCAAiC,CAAA;AAE5D,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAE3C;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU,CAAE,cAAc,CAAE;IACrE;;OAEG;;IAKH;;;;;OAKG;IACH,gBAAuB,QAAQ,gBAAsB;IAErD;;;;;;;OAOG;IACI,gBAAgB,CACnB,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,qBAAqB,GAAI,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC;IAMjF;;;;;;;;OAQG;IACU,qBAAqB,CAC9B,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,qBAAqB,GAClC,OAAO,CAAC,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC,CAAC;CAKrD"}
+{"version":3,"file":"ifc_step_parser.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_parser.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,2BAA2B,CAAA;AACrD,OAAO,UAAU,EAAE,EAAC,qBAAqB,EAAE,WAAW,EAAC,MAAM,6BAA6B,CAAA;AAC1F,OAAO,cAAc,MAAM,iCAAiC,CAAA;AAE5D,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAExD,OAAO,EACL,qBAAqB,EAEtB,MAAM,8BAA8B,CAAA;AAOrC;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU,CAAE,cAAc,CAAE;IACrE;;OAEG;;IAKH;;;;;OAKG;IACH,gBAAuB,QAAQ,gBAAsB;IAErD;;;;;;;OAOG;IACI,gBAAgB,CACnB,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,qBAAqB,GAAI,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC;IAMjF;;;;;;;;OAQG;IACU,qBAAqB,CAC9B,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,qBAAqB,GAClC,OAAO,CAAC,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC,CAAC;IAMpD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,kBAAkB,CACrB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,qBAAqB,EAC5B,IAAI,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;KAAE,GACzE;QAAC,WAAW;QAAE,YAAY,GAAG,SAAS;KAAC;CAgB5C"}

package/compiled/src/ifc/ifc_step_parser.js

@@ -1,6 +1,11 @@
 import StepParser from "../step/parsing/step_parser.js";
 import EntitTypesIfcSearch from "./ifc4_gen/entity_types_search.gen.js";
 import IfcStepModel from "./ifc_step_model.js";
+import { buildIndexStreaming } from "../step/parsing/streaming_index_builder.js";
+import { WindowedStepBufferProvider, } from "../step/step_buffer_provider.js";
+/** Default moving-window size for the streaming index build (1 MiB). */
+// eslint-disable-next-line no-magic-numbers
+const DEFAULT_STREAM_POOL_BYTES = 1024 * 1024;
 /**
  * Parser for taking IFC file serialized in step and turning them into a lazily parsed model.
  */
@@ -36,6 +41,41 @@ class IfcStepParser extends StepParser {
         const [itemIndex, parseResult] = await this.parseDataBlockAsync(input, onProgress);
         return [parseResult, new IfcStepModel(input.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 { elements, result } = buildIndexStreaming(source, this, opts?.pool ?? DEFAULT_STREAM_POOL_BYTES);
+        const provider = new WindowedStepBufferProvider(store, opts?.chunkBytes, opts?.maxResidentChunks);
+        return [result, new IfcStepModel(void 0, elements, provider)];
+    }
 }
 /**
  * An easily accessible and re-usable instance of the parser.

package/compiled/src/ifc/ifc_stream_model.test.d.ts

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

package/compiled/src/ifc/ifc_stream_model.test.d.ts.map

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

package/compiled/src/ifc/ifc_stream_model.test.js

@@ -0,0 +1,70 @@
+/* eslint-disable no-magic-numbers */
+// M1 core: a model built by streaming the source through a bounded window
+// (parseStreamToModel) must decode records byte-identically to the resident
+// parse — reading them on demand through the windowed provider after
+// ensureResident, with the source never held fully resident.
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import IfcStepParser from "./ifc_step_parser.js";
+import { BufferByteSource } from "../step/parsing/byte_source.js";
+import { InMemoryStepByteStore } from "../step/step_buffer_provider.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import { IfcRoot } from "./ifc4_gen/index.js";
+let bytes;
+/**
+ * Decode every IfcRoot-derived entity's GlobalId + Name from a model into a
+ * stable map — the attributes are read from the record bytes, so this
+ * exercises the actual byte path (resident buffer vs windowed provider).
+ *
+ * @param model The model to read from.
+ * @return {Map<number, string>} expressID → "GlobalId|Name".
+ */
+function rootAttributes(model) {
+    const out = new Map();
+    for (const expressID of model.expressIDsOfTypes(IfcRoot)) {
+        const entity = model.getElementByExpressID(expressID);
+        if (entity === void 0) {
+            continue;
+        }
+        const globalId = typeof entity.GlobalId === "string" ? entity.GlobalId : "";
+        const name = typeof entity.Name === "string" ? entity.Name : "";
+        out.set(expressID, `${globalId}|${name}`);
+    }
+    return out;
+}
+beforeAll(() => {
+    bytes = new Uint8Array(fs.readFileSync("data/index.ifc"));
+});
+describe("parseStreamToModel", () => {
+    test("streamed windowed model decodes records identically to the resident parse", async () => {
+        // Resident ground truth.
+        const residentInput = new ParsingBuffer(bytes);
+        IfcStepParser.Instance.parseHeader(residentInput);
+        const [, residentModel] = IfcStepParser.Instance.parseDataToModel(residentInput);
+        const expected = rootAttributes(residentModel);
+        expect(expected.size).toBeGreaterThan(10);
+        // Streamed: tiny parse window forces slides; tiny model chunks force
+        // paging. Same bytes behind both the sync source and the async store.
+        const [result, streamModel] = IfcStepParser.Instance.parseStreamToModel(new BufferByteSource(bytes), new InMemoryStepByteStore(bytes), { pool: 4 * 1024, chunkBytes: 512, maxResidentChunks: 3 });
+        expect(result).toBe(ParseResult.COMPLETE);
+        expect(streamModel.isSourceExternal).toBe(true);
+        // Page each record in on demand, then decode; must match resident.
+        const actual = new Map();
+        for (const expressID of streamModel.expressIDsOfTypes(IfcRoot)) {
+            await streamModel.ensureResidentByExpressID(expressID);
+            const entity = streamModel.getElementByExpressID(expressID);
+            if (entity === void 0) {
+                continue;
+            }
+            const globalId = typeof entity.GlobalId === "string" ? entity.GlobalId : "";
+            const name = typeof entity.Name === "string" ? entity.Name : "";
+            actual.set(expressID, `${globalId}|${name}`);
+        }
+        expect(actual).toEqual(expected);
+    }, 60000);
+    test("rejects a store whose size does not match the source", () => {
+        expect(() => IfcStepParser.Instance.parseStreamToModel(new BufferByteSource(bytes), new InMemoryStepByteStore(bytes.subarray(0, bytes.length - 1))))
+            .toThrow(/does not match/);
+    });
+});

package/compiled/src/parsing/parsing_buffer.d.ts

@@ -61,6 +61,29 @@ export default class ParsingBuffer {
      * of the buffer.
      */
     reinit(buffer: Uint8Array, initialOffset: number, endOffset: number): void;
+    /**
+     * 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: Uint8Array, cursorInWindow: number, endInWindow: number, addressBase: number): void;
     /**
      * Construct this with a buffer, initial offset into the buffer and an end offset.
      *

package/compiled/src/parsing/parsing_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parsing_buffer.d.ts","sourceRoot":"","sources":["../../../src/parsing/parsing_buffer.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,gBAAgB,CAAA;AAKvC,OAAO,EACL,YAAY,EACZ,uBAAuB,IAAI,qBAAqB,EACjD,MAAM,iBAAiB,CAAA;AAkCxB;;GAEG;AACH,MAAM,WAAW,eAAe;IAE5B,KAAK,CAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAI,MAAM,GAAG,SAAS,CAAC;CACtF;AAED;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,aAAa;aAyFH,MAAM,EAAE,UAAU;IAtF/C,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,cAAc,CAAQ;IAE9B,OAAO,CAAC,YAAY,CAAe;IAEnC,SAAgB,GAAG,EAAE,MAAM,CAAA;IAE3B;;;;OAIG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;OAIG;IACH,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED;;;;OAIG;IACH,IAAW,UAAU,IAAI,OAAO,CAI/B;IAED;;;;OAIG;IACH,IAAW,QAAQ,IAAI,OAAO,CAI7B;IAED;;;;;OAKG;IACH,IAAW,OAAO,IAAI,MAAM,CAG3B;IAED;;;;;;;;OAQG;IACI,MAAM,CAAE,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAU3E;;;;;;;OAOG;gBAC0B,MAAM,EAAE,UAAU,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;IAO3F;;OAEG;IACI,KAAK,QAAO,IAAI,CAGtB;IAED;;;;OAIG;IACI,QAAQ,UAAY,UAAU,KAAI,IAAI,CAiB5C;IAED;;;;;OAKG;IACI,MAAM,QAAO,IAAI,CAKvB;IAED;;;;;OAKG;IACI,QAAQ,QAAO,IAAI,CASzB;IAED;;;;OAIG;IACI,UAAU,QAAO,OAAO,CAsB9B;IAED;;;;;;OAMG;IACI,KAAK,YAAc,YAAY,KAAI,OAAO,CAyBhD;IAED;;;;;OAKG;IACI,OAAO,QAAO,OAAO,CAU3B;IAED;;;;;;OAMG;IACI,KAAK,YACC,CACP,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,KAAM,MAAM,GAAG,SAAS,KAAI,OAAO,CAUnD;IAED;;;;;;OAMG;IACI,QAAQ,eAAkB,CAAC,MAAM,OAAO,CAAC,EAAE,KAAI,OAAO,CAY5D;IACD;;;;;;;;OAQG;IACI,UAAU,eAAkB,CAAC,MAAM,OAAO,CAAC,EAAE,KAAI,OAAO,CAgB9D;IAED;;;;;;OAMG;IACI,MAAM,eAAkB,CAAC,MAAM,OAAO,CAAC,EAAE,KAAI,OAAO,CAY1D;IAED;;;;;OAKG;IACI,QAAQ,QAAO,OAAO,CAU5B;IAED;;;;;OAKG;IACI,IAAI,UAAY,qBAAqB,KAAI,OAAO,CAStD;IAED;;;;;OAKG;IACI,OAAO,YAAc,YAAY,KAAI,MAAM,GAAG,SAAS,CA4B7D;IAED;;;;;OAKG;IACI,GAAG,QAAO,OAAO,CAEvB;IAED;;;;;OAKG;IACI,IAAI,QAAO,OAAO,CAExB;IAED;;;;;OAKG;IACI,IAAI,QAAO,OAAO,CAUxB;IAED;;OAEG;IACI,IAAI,IAAI,IAAI;IAMnB;;;;OAIG;IACI,IAAI,IAAI,MAAM,GAAG,SAAS;IASjC;;;;OAIG;IACI,GAAG,IAAI,MAAM,GAAG,SAAS;IAShC;;;;;;OAMG;IACI,QAAQ,QAAO,MAAM,GAAG,SAAS,CAkIvC;IAED;;;;;;OAMG;IACI,YAAY,QAAO,MAAM,GAAG,SAAS,CAwC3C;IAED;;;;;;OAMG;IACI,WAAW,QAAO,MAAM,GAAG,SAAS,CA4D1C;CAEF"}
+{"version":3,"file":"parsing_buffer.d.ts","sourceRoot":"","sources":["../../../src/parsing/parsing_buffer.ts"],"names":[],"mappings":"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"}

package/compiled/src/parsing/parsing_buffer.js

@@ -86,6 +86,37 @@ export default class ParsingBuffer {
         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.
      *