@bldrs-ai/conway 1.399.1223 → 1.401.1237

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.399.1223";
+var versionString = "Conway v1.401.1237";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -1286,6 +1286,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.
    *
@@ -2538,6 +2569,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(input2, onRecordBoundary, onRecordIndexed, onProgress) {
+    const parser211 = this.parseDataBlockIncremental(input2, 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 —
@@ -2575,7 +2634,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(input2) {
+  *parseDataBlockIncremental(input2, onRecordBoundary, onRecordIndexed) {
     const indexResult = { elements: [] };
     const match = input2.match;
     const comment = () => match(commentParser2);
@@ -2622,7 +2681,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 +2775,7 @@ var StepParser = class extends StepHeaderParser {
       if ((++parsedElementCount & PARSE_PROGRESS_ELEMENT_MASK) === 0) {
         yield input2.cursor;
       }
+      onRecordBoundary?.(input2);
       if (!charws(HASH2)) {
         if (tokenws(END_SECTION)) {
           return parseResult2(ParseResult.COMPLETE);
@@ -2738,7 +2798,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,6 +2811,7 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
+        onRecordIndexed?.(indexResult.elements.length, expressID, 0);
         indexResult.elements.push({
           address: startElement2,
           length: input2.address - startElement2,
@@ -2769,7 +2830,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) {
@@ -2842,6 +2903,7 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
+      onRecordIndexed?.(indexResult.elements.length, expressID, foundItem);
       indexResult.elements.push({
         address: startElement,
         length: input2.address - startElement,
@@ -4920,18 +4982,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;
@@ -70694,11 +70762,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);
@@ -70712,7 +70782,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 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);
+    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.
@@ -70745,6 +70884,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;