@bldrs-ai/conway 1.445.1339 → 1.448.1345

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.445.1339";
+var versionString = "Conway v1.448.1345";
 
 // 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

package/compiled/examples/cli-bundled.cjs

@@ -14965,7 +14965,7 @@ ${t5.join("\n")}` : "";
 var import_process = require("process");
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.445.1339";
+var versionString = "Conway v1.448.1345";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -20498,6 +20498,67 @@ var StepVtableBuilder = class {
   }
 };
 
+// compiled/src/step/parsing/uint32_sink.js
+var Uint32Sink = class {
+  /**
+   * @param initialCapacity Initial element capacity.
+   */
+  constructor(initialCapacity = 1024) {
+    this.length_ = 0;
+    this.data_ = new Uint32Array(Math.max(1, initialCapacity));
+  }
+  /** @return {number} Element count appended since the last reset. */
+  get length() {
+    return this.length_;
+  }
+  /**
+   * A view of exactly the appended elements. Only valid until the next
+   * append (which may reallocate) — copy it if it must outlive that.
+   *
+   * @return {Uint32Array} View over [0, length).
+   */
+  get view() {
+    return this.data_.subarray(0, this.length_);
+  }
+  /** Drop all appended elements, keeping the allocated capacity. */
+  reset() {
+    this.length_ = 0;
+  }
+  /**
+   * Append one value, growing geometrically when full.
+   *
+   * @param value The value to append.
+   */
+  push(value) {
+    if (this.length_ === this.data_.length) {
+      const grown = new Uint32Array(this.data_.length * 2);
+      grown.set(this.data_);
+      this.data_ = grown;
+    }
+    this.data_[this.length_++] = value;
+  }
+};
+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 {
 };
@@ -21054,6 +21115,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;
@@ -26594,28 +26697,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
@@ -87166,47 +87289,6 @@ var yargs_default = Yargs;
 // compiled/src/ifc/ifc_command_line_main.js
 var import_fs = __toESM(require("fs"), 1);
 
-// compiled/src/step/parsing/uint32_sink.js
-var Uint32Sink = class {
-  /**
-   * @param initialCapacity Initial element capacity.
-   */
-  constructor(initialCapacity = 1024) {
-    this.length_ = 0;
-    this.data_ = new Uint32Array(Math.max(1, initialCapacity));
-  }
-  /** @return {number} Element count appended since the last reset. */
-  get length() {
-    return this.length_;
-  }
-  /**
-   * A view of exactly the appended elements. Only valid until the next
-   * append (which may reallocate) — copy it if it must outlive that.
-   *
-   * @return {Uint32Array} View over [0, length).
-   */
-  get view() {
-    return this.data_.subarray(0, this.length_);
-  }
-  /** Drop all appended elements, keeping the allocated capacity. */
-  reset() {
-    this.length_ = 0;
-  }
-  /**
-   * Append one value, growing geometrically when full.
-   *
-   * @param value The value to append.
-   */
-  push(value) {
-    if (this.length_ === this.data_.length) {
-      const grown = new Uint32Array(this.data_.length * 2);
-      grown.set(this.data_);
-      this.data_ = grown;
-    }
-    this.data_[this.length_++] = value;
-  }
-};
-
 // compiled/src/core/native_pool.js
 var ObjectPool = class {
   /**
@@ -87787,6 +87869,10 @@ function extractColorOrFactorMultiply(from, surfaceColor, alpha = 1) {
     ];
   }
 }
+var FACES_FIELD_OFFSET = 2;
+var FACES_FIELD_BASE_OFFSET = 1;
+var FACES_FIELD_DEPTH = 4;
+var COORD_INDEX_FIELD_OFFSET = 0;
 var POLYGONAL_INDEX_SINK_CAPACITY = 65536;
 var POLYGONAL_FACE_SINK_CAPACITY = 16384;
 var IfcGeometryExtraction = class _IfcGeometryExtraction {
@@ -88173,49 +88259,21 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
     }
   }
   /**
-   * @param entity
-   * @param temporary
-   * @param isRelVoid
-   * @return {ExtractResult}
-   */
-  extractPolygonalFaceSet(entity, temporary = false, isRelVoid = false) {
-    const result = ExtractResult.COMPLETE;
-    if (this.polygonalSinksInUse_) {
-      throw new Error("extractPolygonalFaceSet re-entered: the shared index sinks are already in use");
-    }
-    this.polygonalSinksInUse_ = true;
-    const allIndices = this.polygonalIndexSink_;
-    const allStartIndices = this.polygonalStartIndexSink_;
-    const polygonalFaceBufferOffsets = this.polygonalFaceOffsetSink_;
-    const startIndicesBufferOffsets = this.polygonalStartOffsetSink_;
-    allIndices.reset();
-    allStartIndices.reset();
-    polygonalFaceBufferOffsets.reset();
-    startIndicesBufferOffsets.reset();
-    let indicesPerFace = -1;
-    entity.Faces.forEach((polygonalFace) => {
-      polygonalFaceBufferOffsets.push(allIndices.length);
-      startIndicesBufferOffsets.push(allStartIndices.length);
-      let coordIndex = 0;
-      if (polygonalFace instanceof IfcIndexedPolygonalFaceWithVoids) {
-        indicesPerFace = polygonalFace.CoordIndex.length;
-        allStartIndices.push(0);
-        coordIndex += indicesPerFace;
-        for (const index of polygonalFace.CoordIndex) {
-          allIndices.push(index);
-        }
-        polygonalFace.InnerCoordIndices.forEach((innerIndices) => {
-          allStartIndices.push(coordIndex);
-          for (const index of innerIndices) {
-            allIndices.push(index);
-          }
-          coordIndex += innerIndices.length;
-        });
-      } else {
-        indicesPerFace = polygonalFace.extractIntegerArrayInto(0, 0, 3, allIndices);
-        allStartIndices.push(0);
-      }
-    });
+   * Hand a faceset's accumulated indices to wasm and register the
+   * resulting mesh. Shared by the fast reference-level path and the
+   * generated-getter fallback so they cannot diverge.
+   *
+   * @param entity The faceset.
+   * @param temporary Is this a temporary (preview//operand) extraction?
+   * @param isRelVoid Is this geometry a rel-void operand?
+   * @param indicesPerFace Index count of the last face processed.
+   * @param allIndices Face indices, concatenated.
+   * @param allStartIndices Per-face start indices.
+   * @param polygonalFaceBufferOffsets Per-face offsets into allIndices.
+   * @param startIndicesBufferOffsets Per-face offsets into allStartIndices.
+   * @return {ExtractResult} The extraction result.
+   */
+  finishPolygonalFaceSet_(entity, temporary, isRelVoid, indicesPerFace, allIndices, allStartIndices, polygonalFaceBufferOffsets, startIndicesBufferOffsets) {
     polygonalFaceBufferOffsets.push(allIndices.length);
     startIndicesBufferOffsets.push(allStartIndices.length);
     const indicesArray = allIndices.view;
@@ -88227,7 +88285,6 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
     const startIndicesBufferOffsetsArray = startIndicesBufferOffsets.view;
     const startIndicesBufferOffsetsArrayPtr = this.arrayToWasmHeap(startIndicesBufferOffsetsArray);
     const polygonalFaceVector = this.wasmModule.buildIndexedPolygonalFaceVector(indicesArrayPtr, indicesArray.length, startIndicesArrayPtr, polygonalFaceBufferOffsetsArrayPtr, polygonalFaceBufferOffsetsArray.length, startIndicesBufferOffsetsArrayPtr, startIndicesBufferOffsetsArray.length);
-    this.polygonalSinksInUse_ = false;
     const pointsParseBuffer = this.conwayModel.nativeParseBuffer();
     if (!entity.Coordinates.extractParseBuffer(0, 0, 0, pointsParseBuffer, this.wasmModule, true)) {
       pointsParseBuffer.resize(0);
@@ -88258,6 +88315,102 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
     } else {
       this.model.voidGeometry.add(canonicalMesh);
     }
+    return ExtractResult.COMPLETE;
+  }
+  /**
+   * Extract a polygonal faceset.
+   *
+   * The index sinks are extractor-scoped, so a nested faceset extraction
+   * reached from inside this one would silently clobber them. Nothing
+   * recurses there today, so this guards the invariant rather than a
+   * live bug — but the release must survive a throw: per-record
+   * extraction errors are caught upstream and are expected on malformed
+   * models, and a leaked flag would turn one bad record into a failure
+   * for every remaining faceset.
+   *
+   * @param entity The faceset.
+   * @param temporary Is this a temporary (preview/operand) extraction?
+   * @param isRelVoid Is this geometry a rel-void operand?
+   * @return {ExtractResult} The extraction result.
+   */
+  extractPolygonalFaceSet(entity, temporary = false, isRelVoid = false) {
+    if (this.polygonalSinksInUse_) {
+      throw new Error("extractPolygonalFaceSet re-entered: the shared index sinks are already in use");
+    }
+    this.polygonalSinksInUse_ = true;
+    try {
+      return this.extractPolygonalFaceSetGuarded_(entity, temporary, isRelVoid);
+    } finally {
+      this.polygonalSinksInUse_ = false;
+    }
+  }
+  /**
+   * @param entity
+   * @param temporary
+   * @param isRelVoid
+   * @return {ExtractResult}
+   */
+  extractPolygonalFaceSetGuarded_(entity, temporary, isRelVoid) {
+    const result = ExtractResult.COMPLETE;
+    const allIndices = this.polygonalIndexSink_;
+    const allStartIndices = this.polygonalStartIndexSink_;
+    const polygonalFaceBufferOffsets = this.polygonalFaceOffsetSink_;
+    const startIndicesBufferOffsets = this.polygonalStartOffsetSink_;
+    allIndices.reset();
+    allStartIndices.reset();
+    polygonalFaceBufferOffsets.reset();
+    startIndicesBufferOffsets.reset();
+    let indicesPerFace = -1;
+    let fastPathOk = true;
+    const facesWalked = entity.forEachReferenceInField(FACES_FIELD_OFFSET, FACES_FIELD_BASE_OFFSET, FACES_FIELD_DEPTH, (expressID) => {
+      if (expressID === void 0) {
+        fastPathOk = false;
+        return false;
+      }
+      const count = this.model.extractIntegerArrayByExpressIDInto(expressID, COORD_INDEX_FIELD_OFFSET, entity_types_ifc_gen_default.IFCINDEXEDPOLYGONALFACE, allIndices);
+      if (count === void 0) {
+        fastPathOk = false;
+        return false;
+      }
+      polygonalFaceBufferOffsets.push(allIndices.length - count);
+      startIndicesBufferOffsets.push(allStartIndices.length);
+      allStartIndices.push(0);
+      indicesPerFace = count;
+      return true;
+    });
+    if (fastPathOk && facesWalked) {
+      this.finishPolygonalFaceSet_(entity, temporary, isRelVoid, indicesPerFace, allIndices, allStartIndices, polygonalFaceBufferOffsets, startIndicesBufferOffsets);
+      return result;
+    }
+    allIndices.reset();
+    allStartIndices.reset();
+    polygonalFaceBufferOffsets.reset();
+    startIndicesBufferOffsets.reset();
+    indicesPerFace = -1;
+    entity.Faces.forEach((polygonalFace) => {
+      polygonalFaceBufferOffsets.push(allIndices.length);
+      startIndicesBufferOffsets.push(allStartIndices.length);
+      let coordIndex = 0;
+      if (polygonalFace instanceof IfcIndexedPolygonalFaceWithVoids) {
+        indicesPerFace = polygonalFace.CoordIndex.length;
+        allStartIndices.push(0);
+        coordIndex += indicesPerFace;
+        for (const index of polygonalFace.CoordIndex) {
+          allIndices.push(index);
+        }
+        polygonalFace.InnerCoordIndices.forEach((innerIndices) => {
+          allStartIndices.push(coordIndex);
+          for (const index of innerIndices) {
+            allIndices.push(index);
+          }
+          coordIndex += innerIndices.length;
+        });
+      } else {
+        indicesPerFace = polygonalFace.extractIntegerArrayInto(0, 0, 3, allIndices);
+        allStartIndices.push(0);
+      }
+    });
+    this.finishPolygonalFaceSet_(entity, temporary, isRelVoid, indicesPerFace, allIndices, allStartIndices, polygonalFaceBufferOffsets, startIndicesBufferOffsets);
     return result;
   }
   /**