@bldrs-ai/conway 1.398.1224 → 1.400.1226

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.398.1224";
+var versionString = "Conway v1.400.1226";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -4975,18 +4975,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;
@@ -70749,11 +70755,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);
@@ -70767,7 +70775,76 @@ var IfcStepModel = class extends StepModelBase {
   }
 };
 
+// compiled/src/step/parsing/streaming_index_builder.js
+function buildIndexStreaming(source, parser211, pool3) {
+  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);
+    const stoppedShort = result !== ParseResult.COMPLETE;
+    const notAtEof = windowStartFile + windowLen < fileSize;
+    if (stoppedShort && notAtEof) {
+      windowBytes *= 2;
+      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;
+
 // compiled/src/ifc/ifc_step_parser.js
+var DEFAULT_STREAM_POOL_BYTES = 1024 * 1024;
 var IfcStepParser = class extends StepParser {
   /**
    * Construct the IFC step parser.
@@ -70800,6 +70877,40 @@ 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 { 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/examples/cli-bundled.cjs

@@ -14965,7 +14965,7 @@ ${t5.join("\n")}` : "";
 var import_process = require("process");
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.398.1224";
+var versionString = "Conway v1.400.1226";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -20789,18 +20789,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;
@@ -86594,11 +86600,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);
@@ -86612,7 +86620,76 @@ var IfcStepModel = class extends StepModelBase {
   }
 };
 
+// compiled/src/step/parsing/streaming_index_builder.js
+function buildIndexStreaming(source, parser210, pool3) {
+  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] = parser210.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] = parser210.parseDataBlockStreamed(input, onRecordBoundary);
+    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.
@@ -86645,6 +86722,40 @@ var IfcStepParser = class 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)];
+  }
 };
 IfcStepParser.Instance = new IfcStepParser();
 var ifc_step_parser_default = IfcStepParser;

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

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.398.1224";
+var versionString = "Conway v1.400.1226";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -20580,18 +20580,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;

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.398.1224";
+var versionString = "Conway v1.400.1226";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -4973,18 +4973,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;
@@ -70747,11 +70753,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);
@@ -70765,7 +70773,76 @@ var IfcStepModel = class extends StepModelBase {
   }
 };
 
+// compiled/src/step/parsing/streaming_index_builder.js
+function buildIndexStreaming(source, parser211, pool3) {
+  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);
+    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.
@@ -70798,6 +70875,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"}