@bldrs-ai/conway 1.513.1447 → 1.516.1463

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.513.1447";
+var versionString = "Conway v1.516.1463";
 
 // 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.
    *
@@ -5642,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.
@@ -5729,9 +5800,21 @@ 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;
     }
@@ -5762,13 +5845,34 @@ var StepModelBase = class {
         break;
       }
       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)) {
-            frontier.push(referenced);
+          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;
@@ -5855,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
@@ -6279,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;
@@ -71538,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.