@bldrs-ai/conway 1.509.1435 → 1.511.1441

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.509.1435";
+var versionString = "Conway v1.511.1441";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -2609,7 +2609,9 @@ var StepParser = class extends StepHeaderParser {
       if (next.done === true) {
         return next.value;
       }
-      onProgress?.(next.value);
+      if (typeof next.value === "number") {
+        onProgress?.(next.value);
+      }
     }
   }
   /**
@@ -2621,7 +2623,8 @@ var StepParser = class extends StepHeaderParser {
    *
    * @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.
+   * buffer; the callback may rebase the buffer's window in place. Must be
+   * synchronous on this driver — a returned Promise is a caller bug.
    * @param onRecordIndexed Called as each top-level record is indexed, with
    * its localID, expressID and typeID (0 for external-mapping records) — the
    * seam for incremental semantic consumers (type index, roots registry,
@@ -2637,6 +2640,9 @@ var StepParser = class extends StepHeaderParser {
       if (next.done === true) {
         return next.value;
       }
+      if (typeof next.value !== "number") {
+        throw new Error("parseDataBlockStreamed: async window slide requires parseDataBlockStreamedAsync");
+      }
       onProgress?.(next.value);
     }
   }
@@ -2649,7 +2655,9 @@ var StepParser = class extends StepHeaderParser {
    *
    * @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.
+   * 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.
@@ -2666,6 +2674,10 @@ var StepParser = class extends StepHeaderParser {
       if (next.done === true) {
         return next.value;
       }
+      if (typeof next.value !== "number") {
+        await next.value;
+        continue;
+      }
       onProgress?.(next.value);
       if (Date.now() - lastYield >= yieldIntervalMs) {
         await yieldToEventLoop();
@@ -2693,7 +2705,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();
@@ -2857,7 +2871,10 @@ var StepParser = class extends StepHeaderParser {
       if ((++parsedElementCount & PARSE_PROGRESS_ELEMENT_MASK) === 0) {
         yield input2.cursor;
       }
-      onRecordBoundary?.(input2);
+      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);
@@ -4400,6 +4417,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;
@@ -4580,7 +4661,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 = [];
@@ -4623,15 +4704,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
@@ -4701,7 +4830,7 @@ var StepVtableBuilder = class {
 var OPEN_PAREN3 = parsing_constants_default.OPEN_PAREN;
 var CLOSE_PAREN3 = parsing_constants_default.CLOSE_PAREN;
 var COMMA3 = parsing_constants_default.COMMA;
-var ZERO5 = parsing_constants_default.ZERO;
+var ZERO6 = parsing_constants_default.ZERO;
 var WHITESPACE4 = parsing_constants_default.WHITE_SPACE_SET;
 function extractIntegerArrayAt(buffer, cursor, endCursor, sink) {
   const marked = sink.length;
@@ -4770,7 +4899,7 @@ function extractUnsignedIntegerListAt(buffer, cursor, endCursor, sink) {
         return void 0;
       }
     }
-    const digit = buffer[cursor] - ZERO5;
+    const digit = buffer[cursor] - ZERO6;
     if (digit < 0 || digit > 9) {
       sink.truncate(marked);
       return void 0;
@@ -4778,7 +4907,7 @@ function extractUnsignedIntegerListAt(buffer, cursor, endCursor, sink) {
     let value = digit;
     ++cursor;
     while (cursor < endCursor) {
-      const next = buffer[cursor] - ZERO5;
+      const next = buffer[cursor] - ZERO6;
       if (next < 0 || next > 9) {
         break;
       }
@@ -5573,6 +5702,141 @@ 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).
+   * @return {Promise<Set<number>>} The local IDs that were visited.
+   */
+  async ensureResidentClosureByLocalID(localID, extraLocalIDs, seen = /* @__PURE__ */ new Set()) {
+    if (!this.isSourceExternal) {
+      return seen;
+    }
+    const stack = [localID];
+    if (extraLocalIDs !== void 0) {
+      for (const extra of extraLocalIDs) {
+        stack.push(extra);
+      }
+    }
+    while (stack.length > 0) {
+      const id = stack.pop();
+      if (seen.has(id) || id >= this.count_) {
+        continue;
+      }
+      seen.add(id);
+      await this.ensureResidentByLocalID(id);
+      this.pinByLocalID(id);
+      for (const expressID of this.scanRecordRefs_(id)) {
+        const referenced = this.expressIDMap_.get(expressID);
+        if (referenced !== void 0 && !seen.has(referenced)) {
+          stack.push(referenced);
+        }
+      }
+    }
+    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]);
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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.
    *
@@ -10729,6 +10993,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
@@ -71438,11 +71734,88 @@ function buildIndexStreaming(source, parser211, pool3, onRecordIndexed, sink) {
   }
 }
 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) {
   const sink = new ColumnarIndexSink();
   const { header, result, stats } = buildIndexStreaming(source, parser211, pool3, onRecordIndexed, sink);
   return { header, columns: sink.finalize(), result, stats };
 }
+async function buildColumnarIndexStreamingAsync(source, parser211, pool3, onRecordIndexed, onProgress, yieldIntervalMs) {
+  const sink = new ColumnarIndexSink();
+  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;
@@ -71512,6 +71885,27 @@ var IfcStepParser = class extends StepParser {
     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;