@bldrs-ai/conway 1.509.1435 → 1.511.1441

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

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // 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
 function pThreadsAllowed() {
@@ -18348,7 +18348,9 @@ var StepParser = class extends StepHeaderParser {
       if (next.done === true) {
         return next.value;
       }
-      onProgress?.(next.value);
+      if (typeof next.value === "number") {
+        onProgress?.(next.value);
+      }
     }
   }
   /**
@@ -18360,7 +18362,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,
@@ -18376,6 +18379,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);
     }
   }
@@ -18388,7 +18394,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.
@@ -18405,6 +18413,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();
@@ -18432,7 +18444,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();
@@ -18596,7 +18610,10 @@ var StepParser = class extends StepHeaderParser {
       if ((++parsedElementCount & PARSE_PROGRESS_ELEMENT_MASK) === 0) {
         yield input.cursor;
       }
-      onRecordBoundary?.(input);
+      const slide = onRecordBoundary?.(input);
+      if (slide !== void 0 && typeof slide.then === "function") {
+        yield slide;
+      }
       if (!charws(HASH2)) {
         if (tokenws(END_SECTION)) {
           return parseResult(ParseResult.COMPLETE);
@@ -20022,6 +20039,70 @@ var yargs_default = Yargs;
 // compiled/src/AP214E3_2010/ap214_command_line_main.js
 var import_fs = __toESM(require("fs"), 1);
 
+// 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;
@@ -20202,7 +20283,7 @@ var WindowedStepBufferProvider = class {
     const firstChunk = Math.floor(address2 / chunkBytes);
     const lastChunk = Math.floor((address2 + 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 = [];
@@ -20245,15 +20326,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(address2, length) {
+    for (const chunkIndex of this.chunkSpan_(address2, length)) {
+      this.addPin_(chunkIndex, 1);
+    }
+  }
+  /**
+   * Drop one {@link pinRange} hold.
+   *
+   * @param address Absolute start of the range.
+   * @param length Length of the range.
+   */
+  unpinRange(address2, length) {
+    for (const chunkIndex of this.chunkSpan_(address2, 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_(address2, length) {
+    const chunkBytes = this.chunkBytes_;
+    const firstChunk = Math.floor(address2 / chunkBytes);
+    const lastChunk = Math.floor((address2 + 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
@@ -20323,7 +20452,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;
@@ -20392,7 +20521,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;
@@ -20400,7 +20529,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;
       }
@@ -21195,6 +21324,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 address2 = this.address_[localID];
+    const length = this.length_[localID];
+    const acquisition = this.bufferProvider_.acquire(address2, length);
+    const viewStart = address2 - 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.
    *
@@ -22534,6 +22798,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