@bldrs-ai/conway 1.512.1444 → 1.514.1452

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.512.1444";
+var versionString = "Conway v1.514.1452";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -2678,7 +2678,10 @@ var StepParser = class extends StepHeaderParser {
         await next.value;
         continue;
       }
-      onProgress?.(next.value);
+      const progressed = onProgress?.(next.value);
+      if (progressed !== void 0 && typeof progressed.then === "function") {
+        await progressed;
+      }
       if (Date.now() - lastYield >= yieldIntervalMs) {
         await yieldToEventLoop();
         lastYield = Date.now();
@@ -5288,7 +5291,7 @@ var InterpolationSearchTable32 = class {
 };
 
 // compiled/src/step/step_model_base.js
-var StepModelBase = class {
+var StepModelBase = class _StepModelBase {
   /**
    * Construct this step model with its matching schema, a buffer to read from and an element index.
    *
@@ -5538,6 +5541,9 @@ var StepModelBase = class {
     if (element.vtableIndex === void 0 && !this.populateVtableEntryRaw(element)) {
       return void 0;
     }
+    if (element.buffer === void 0) {
+      this.populateBufferEntry(localID);
+    }
     const vtable = element.vtable;
     const buffer = element.buffer;
     if (vtable === void 0 || buffer === void 0 || offset >= (element.vtableCount ?? 0)) {
@@ -5607,6 +5613,11 @@ var StepModelBase = class {
     }
     const element = this.entry(localID);
     element.buffer = this.bufferProvider_.acquire(element.address, element.length).buffer;
+    if (element.multiMapping !== void 0) {
+      for (const mapped of element.multiMapping) {
+        mapped.buffer = this.bufferProvider_.acquire(mapped.address, mapped.length).buffer;
+      }
+    }
   }
   /**
    * Get the size in bytes of the backing buffer for this.
@@ -5634,6 +5645,74 @@ var StepModelBase = class {
   get residentSourceBytes() {
     return this.bufferProvider_.residentBytes;
   }
+  /**
+   * Column type of a record, or `undefined` if the id is unknown / untyped.
+   *
+   * @param localID The record.
+   * @return {number | undefined} The schema type id.
+   */
+  typeIDOf(localID) {
+    if (localID >= this.count_) {
+      return;
+    }
+    const typeID = this.typeID_[localID];
+    return typeID < 0 ? void 0 : typeID;
+  }
+  /**
+   * Absolute source address of a record.
+   *
+   * @param localID The record.
+   * @return {number | undefined} The address.
+   */
+  recordAddress(localID) {
+    return localID < this.count_ ? this.address_[localID] : void 0;
+  }
+  /**
+   * Source length of a record.
+   *
+   * @param localID The record.
+   * @return {number | undefined} The length.
+   */
+  recordLength(localID) {
+    return localID < this.count_ ? this.length_[localID] : void 0;
+  }
+  /**
+   * Pin an arbitrary source span (e.g. a faceset's packed Faces[] run).
+   *
+   * @param address Absolute start.
+   * @param length Length in bytes.
+   */
+  pinAddressRange(address, length) {
+    if (!this.isSourceExternal) {
+      return;
+    }
+    this.bufferProvider_.pinRange?.(address, length);
+  }
+  /**
+   * Drop one {@link pinAddressRange} hold.
+   *
+   * @param address Absolute start.
+   * @param length Length in bytes.
+   */
+  unpinAddressRange(address, length) {
+    if (!this.isSourceExternal) {
+      return;
+    }
+    this.bufferProvider_.unpinRange?.(address, length);
+  }
+  /**
+   * Page an arbitrary source span.
+   *
+   * @param address Absolute start.
+   * @param length Length in bytes.
+   * @return {Promise<void>} Resolves when resident.
+   */
+  async ensureResidentRange(address, length) {
+    if (!this.isSourceExternal) {
+      return;
+    }
+    await this.bufferProvider_.ensureResident(address, length);
+  }
   /**
    * Release the resident source buffer and serve subsequent record
    * reads from fixed-size windows paged in from an external store.
@@ -5721,32 +5800,80 @@ var StepModelBase = class {
    * @param localID Seed record.
    * @param extraLocalIDs Additional seeds (voids, styles, materials).
    * @param seen Optional set to extend (also skips already-pinned IDs).
+   * @param descend If set, records for which this returns false are
+   * still visited (pinned, in `seen`) but their `#refs` are not
+   * followed — e.g. an `IfcPolygonalFaceSet` whose Faces[] payload
+   * is paged as one span afterwards.
+   * @param leafSpans Optional out-array of coalesced pin ranges for
+   * {@link spanLeaf} children — caller must {@link unpinAddressRange}
+   * each.
+   * @param spanLeaf If set, matching children are *not* visited
+   * (absent from `seen`); their bytes are one pin span. Packed
+   * extract reads `IfcIndexedPolygonalFace.CoordIndex` as integers —
+   * following those faces pinned ~78k records per PSB product. If
+   * omitted, `!descend` children use this span path (test helper).
    * @return {Promise<Set<number>>} The local IDs that were visited.
    */
-  async ensureResidentClosureByLocalID(localID, extraLocalIDs, seen = /* @__PURE__ */ new Set()) {
+  async ensureResidentClosureByLocalID(localID, extraLocalIDs, seen = /* @__PURE__ */ new Set(), descend, leafSpans, spanLeaf) {
     if (!this.isSourceExternal) {
       return seen;
     }
-    const stack = [localID];
+    const frontier = [];
+    const enqueue = (id) => {
+      if (id < this.count_ && !seen.has(id)) {
+        frontier.push(id);
+      }
+    };
+    enqueue(localID);
     if (extraLocalIDs !== void 0) {
       for (const extra of extraLocalIDs) {
-        stack.push(extra);
+        enqueue(extra);
       }
     }
-    while (stack.length > 0) {
-      const id = stack.pop();
-      if (seen.has(id) || id >= this.count_) {
-        continue;
+    while (frontier.length > 0) {
+      const wave = [];
+      for (const id of frontier) {
+        if (seen.has(id) || id >= this.count_) {
+          continue;
+        }
+        seen.add(id);
+        this.pinByLocalID(id);
+        wave.push(id);
+      }
+      frontier.length = 0;
+      if (wave.length === 0) {
+        break;
       }
-      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);
+      await Promise.all(wave.map((id) => this.ensureResidentByLocalID(id)));
+      const waveSpans = [];
+      for (const id of wave) {
+        if (descend !== void 0 && !descend(id)) {
+          continue;
+        }
+        const skipped = [];
+        for (const expressID of this.scanRecordRefs_(id)) {
+          const referenced = this.expressIDMap_.get(expressID);
+          if (referenced === void 0 || seen.has(referenced)) {
+            continue;
+          }
+          const leaf = spanLeaf !== void 0 ? spanLeaf(referenced) : descend !== void 0 && !descend(referenced);
+          if (leaf) {
+            skipped.push(referenced);
+            continue;
+          }
+          frontier.push(referenced);
+        }
+        if (skipped.length > 0) {
+          for (const span of this.spansOf_(skipped)) {
+            this.pinAddressRange(span.address, span.length);
+            waveSpans.push(span);
+            leafSpans?.push(span);
+          }
         }
       }
+      if (waveSpans.length > 0) {
+        await Promise.all(waveSpans.map((span) => this.ensureResidentRange(span.address, span.length)));
+      }
     }
     return seen;
   }
@@ -5832,6 +5959,99 @@ var StepModelBase = class {
     }
     return this.ensureResidentClosureByLocalID(localID, extraLocalIDs, seen);
   }
+  /**
+   * Source spans covering the records referenced by `expressIDs` from
+   * `fromIndex` onward. A packed Faces[] run is consecutive in parse
+   * order — two express-ID lookups then cover the whole range. Sparse
+   * sets are coalesced into tight runs so intervening file is not
+   * pinned.
+   *
+   * @param expressIDs Referenced express IDs (e.g. a faceset's #refs).
+   * @param fromIndex First index to include (skip Coordinates at [0]).
+   * @return {{address: number, length: number}[]} The spans.
+   */
+  spansOfExpressIDs(expressIDs, fromIndex = 0) {
+    let minExpressID = Infinity;
+    let maxExpressID = 0;
+    let count = 0;
+    for (let i = fromIndex; i < expressIDs.length; ++i) {
+      const expressID = expressIDs[i];
+      if (expressID < minExpressID) {
+        minExpressID = expressID;
+      }
+      if (expressID > maxExpressID) {
+        maxExpressID = expressID;
+      }
+      ++count;
+    }
+    if (count === 0 || !Number.isFinite(minExpressID)) {
+      return [];
+    }
+    const minLocal = this.expressIDMap_.get(minExpressID);
+    const maxLocal = this.expressIDMap_.get(maxExpressID);
+    if (minLocal === void 0 || maxLocal === void 0) {
+      return [];
+    }
+    const lo = Math.min(minLocal, maxLocal);
+    const hi = Math.max(minLocal, maxLocal);
+    if (hi - lo + 1 === count) {
+      const address = this.address_[lo];
+      const end = this.address_[hi] + this.length_[hi];
+      if (end <= address) {
+        return [];
+      }
+      return [{ address, length: end - address }];
+    }
+    const locals = [];
+    for (let i = fromIndex; i < expressIDs.length; ++i) {
+      const localID = this.expressIDMap_.get(expressIDs[i]);
+      if (localID !== void 0) {
+        locals.push(localID);
+      }
+    }
+    return this.spansOf_(locals);
+  }
+  /**
+   * Coalesce `localIDs` into tight source runs. Records more than
+   * {@link LEAF_SPAN_COALESCE_GAP_} apart stay separate so a sparse
+   * Faces[] list does not pin the file between them.
+   *
+   * @param localIDs The records.
+   * @return {{address: number, length: number}[]} The spans.
+   */
+  spansOf_(localIDs) {
+    const items = [];
+    for (const id of localIDs) {
+      if (id >= this.count_) {
+        continue;
+      }
+      items.push({
+        address: this.address_[id],
+        length: this.length_[id]
+      });
+    }
+    items.sort((a2, b) => a2.address - b.address);
+    const spans = [];
+    let run;
+    for (const item of items) {
+      if (run === void 0) {
+        run = { address: item.address, length: item.length };
+        continue;
+      }
+      const runEnd = run.address + run.length;
+      if (item.address <= runEnd + _StepModelBase.LEAF_SPAN_COALESCE_GAP_) {
+        const end = Math.max(runEnd, item.address + item.length);
+        run.length = end - run.address;
+        continue;
+      }
+      spans.push(run);
+      run = { address: item.address, length: item.length };
+    }
+    if (run !== void 0) {
+      spans.push(run);
+    }
+    return spans;
+  }
   /**
    * Express IDs referenced by a resident record (`#<id>` tokens in its
    * text, including multi-mapped class records). The record itself
@@ -6256,6 +6476,8 @@ var StepModelBase = class {
     return this.geometry?.getByLocalID(node.localID);
   }
 };
+StepModelBase.LEAF_SPAN_COALESCE_GAP_ = 1024;
+var step_model_base_default = StepModelBase;
 
 // compiled/src/core/entity_field_description.js
 var FieldDescriptionKind;
@@ -11265,6 +11487,7 @@ var StepEntityBase = class {
    */
   extractParseBuffer(offset, baseOffset, depth, result, module2, optional) {
     offset -= this.multiReference_ !== void 0 ? baseOffset : 0;
+    this.guaranteeBuffer();
     const internalReference = this.guaranteeVTable(depth);
     if (offset >= internalReference.vtableCount) {
       throw new Error("Couldn't read field due to too few fields in record");
@@ -11468,6 +11691,9 @@ var StepEntityBase = class {
           throw new Error("Entity does not have matching table entry to read from model");
         }
       }
+      if (classReference.buffer === void 0) {
+        this.model.populateBufferEntry(this.localID);
+      }
       this.internalReference_.buffer = classReference.buffer;
       return classReference;
     }
@@ -11478,6 +11704,9 @@ var StepEntityBase = class {
         throw new Error("Entity does not have matching table entry to read from model");
       }
     }
+    if (internalReference.buffer === void 0) {
+      this.guaranteeBuffer();
+    }
     return internalReference;
   }
   /**
@@ -71508,7 +71737,7 @@ var IfcMaterialCache = class {
 
 // compiled/src/ifc/ifc_step_model.js
 var indexerInstance = new StepTypeIndexer(EntityTypesIfcCount);
-var IfcStepModel = class extends StepModelBase {
+var IfcStepModel = class extends step_model_base_default {
   /**
    * Construct this model given a buffer containing the data and the parsed data index on that,
    * adding the typeIndex on top of that.