@bldrs-ai/conway 1.447.1342 → 1.449.1351

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.447.1342";
+var versionString = "Conway v1.449.1351";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -4684,6 +4684,28 @@ var StepVtableBuilder = class {
   }
 };
 
+// compiled/src/step/parsing/uint32_sink.js
+function extractIntegerArrayAt(buffer, cursor, endCursor, sink) {
+  if (stepExtractOptional(buffer, cursor, endCursor) === null) {
+    return 0;
+  }
+  let count = 0;
+  let signedCursor0 = stepExtractArrayBegin(buffer, cursor, endCursor);
+  let readCursor = Math.abs(signedCursor0);
+  while (signedCursor0 >= 0) {
+    const value = stepExtractNumber(buffer, readCursor, endCursor);
+    if (value === void 0) {
+      throw new Error("Value in STEP was incorrectly typed");
+    }
+    readCursor = skipValue(buffer, readCursor, endCursor);
+    sink.push(value);
+    ++count;
+    signedCursor0 = stepExtractArrayToken(buffer, readCursor, endCursor);
+    readCursor = Math.abs(signedCursor0);
+  }
+  return count;
+}
+
 // compiled/src/indexing/index_set_constants.js
 var IndexSetConstants = class {
 };
@@ -5240,6 +5262,48 @@ var StepModelBase = class {
    * @param element The raw elment to populate the vtable entry for.
    * @return {boolean} Did the vtable entry populate correctly?
    */
+  /**
+   * Append a referenced record's unsigned-integer list field into `sink`
+   * without materialising the referenced entity.
+   *
+   * This is the reference-level twin of
+   * `StepEntityBase.extractIntegerArrayInto`, for hot loops that walk
+   * millions of small records (tessellated facesets) where constructing
+   * an entity per record dominates. It deliberately handles only the
+   * simple case and reports failure otherwise, so callers keep a
+   * correct fallback rather than this growing subtle special cases:
+   * the reference must resolve, be single-class (no multi-mapping),
+   * and be exactly `expectedTypeID` — which is what makes reading
+   * `offset` as a plain vtable slot equivalent to the generated
+   * getter's `getOffsetCursor( offset, _, _ )` (that only subtracts a
+   * base offset for multi-mapped records).
+   *
+   * @param expressID The referenced record's express ID.
+   * @param offset The field's vtable offset within the record.
+   * @param expectedTypeID The type the record must be.
+   * @param sink Receives the appended values.
+   * @return {number | undefined} Count appended, or undefined when the
+   * fast path does not apply and the caller must fall back.
+   */
+  extractIntegerArrayByExpressIDInto(expressID, offset, expectedTypeID, sink) {
+    const localID = this.expressIDMap_.get(expressID);
+    if (localID === void 0 || localID >= this.count_) {
+      return void 0;
+    }
+    const element = this.entry(localID);
+    if (element.multiMapping !== void 0 || element.typeID !== expectedTypeID) {
+      return void 0;
+    }
+    if (element.vtableIndex === void 0 && !this.populateVtableEntryRaw(element)) {
+      return void 0;
+    }
+    const vtable = element.vtable;
+    const buffer = element.buffer;
+    if (vtable === void 0 || buffer === void 0 || offset >= (element.vtableCount ?? 0)) {
+      return void 0;
+    }
+    return extractIntegerArrayAt(buffer, vtable[element.vtableIndex + offset], buffer.length, sink);
+  }
   populateVtableEntryRaw(element) {
     if (element.vtableIndex !== void 0 || element.typeID === 0) {
       return true;
@@ -10780,28 +10844,48 @@ var StepEntityBase = class {
    * @return {number} How many values were appended (0 when the field is
    * unset/optional-null).
    */
-  extractIntegerArrayInto(offset, baseOffset, depth, sink) {
+  /**
+   * Walk a reference-list field, handing each element's express ID to
+   * `onReference` without resolving it to an entity.
+   *
+   * Lets hot loops decide per element how to read the referenced record
+   * (see StepModelBase.extractIntegerArrayByExpressIDInto) instead of
+   * paying for an entity per element the way the generated list getters
+   * do. Inline (non-reference) elements yield `undefined`, and
+   * `onReference` returning false aborts the walk — together those let
+   * a caller bail out to the generated getter for anything it is not
+   * prepared to handle.
+   *
+   * @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 onReference Receives each element's express ID, or undefined
+   * for an inline element; return false to abort.
+   * @return {boolean} False if the walk was aborted, true otherwise.
+   */
+  forEachReferenceInField(offset, baseOffset, depth, onReference) {
     let cursor = this.getOffsetCursor(offset, baseOffset, depth);
     const buffer = this.buffer;
     const endCursor = buffer.length;
     if (stepExtractOptional(buffer, cursor, endCursor) === null) {
-      return 0;
+      return true;
     }
-    let count = 0;
     let signedCursor0 = stepExtractArrayBegin(buffer, cursor, endCursor);
     cursor = Math.abs(signedCursor0);
     while (signedCursor0 >= 0) {
-      const value = stepExtractNumber(buffer, cursor, endCursor);
-      if (value === void 0) {
-        throw new Error("Value in STEP was incorrectly typed");
+      if (!onReference(stepExtractReference(buffer, cursor, endCursor))) {
+        return false;
       }
       cursor = skipValue(buffer, cursor, endCursor);
-      sink.push(value);
-      ++count;
       signedCursor0 = stepExtractArrayToken(buffer, cursor, endCursor);
       cursor = Math.abs(signedCursor0);
     }
-    return count;
+    return true;
+  }
+  extractIntegerArrayInto(offset, baseOffset, depth, sink) {
+    const cursor = this.getOffsetCursor(offset, baseOffset, depth);
+    const buffer = this.buffer;
+    return extractIntegerArrayAt(buffer, cursor, buffer.length, sink);
   }
   /**
    * Extract a number at the particular vtable offset (i.e. the position