@bldrs-ai/conway 1.536.1507 → 1.543.1513

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.536.1507";
+var versionString = "Conway v1.543.1513";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -11137,6 +11137,18 @@ function releaseQuietly(release) {
   }
 }
 
+// compiled/src/step/dangling_reference_error.js
+var DanglingReferenceError = class extends Error {
+  /**
+   * @param expressID The referenced record that is not in the index.
+   */
+  constructor(expressID) {
+    super(`Reference to #${expressID} is not in the index`);
+    this.expressID = expressID;
+    this.name = "DanglingReferenceError";
+  }
+};
+
 // compiled/src/step/step_entity_base.js
 var IfcTokenType;
 (function(IfcTokenType2) {
@@ -11328,16 +11340,38 @@ var StepEntityBase = class {
     }
     return value;
   }
+  /**
+   * Classify a reference field that failed to resolve.
+   *
+   * `getElementByExpressID` / `getTypedElementByExpressID` answer
+   * `undefined` for two opposite causes: the record is not in the index at
+   * all, or it is indexed but is the wrong entity type. A mid-parse prefix
+   * reader must tell them apart — the first may resolve once more of the
+   * file is scanned, the second never will — so the absent case gets its
+   * own error type (see {@link DanglingReferenceError}). Called only on a
+   * throwing path, so the extra index lookup costs nothing in the common
+   * case.
+   *
+   * @param expressID The reference's target, or undefined when the field
+   * did not hold a reference at all (an unresolved inline element).
+   * @return {Error} The error to throw.
+   */
+  unresolvedReferenceError_(expressID) {
+    if (expressID !== void 0 && this.model.resolveExpressID(expressID) === void 0) {
+      return new DanglingReferenceError(expressID);
+    }
+    return new Error("Value in STEP was incorrectly typed");
+  }
   extractReference(offset, baseOffset, depth, optional) {
     const [cursor, endCursor, buffer] = this.getOffsetAndEndCursor(offset, baseOffset, depth);
     const expressID = stepExtractReference(buffer, cursor, endCursor);
     const value = expressID !== void 0 ? this.model.getElementByExpressID(expressID) : this.model.getInlineElementByAddress(extractInlineElementAddress(buffer, cursor, endCursor));
     if (value === void 0) {
       if (!optional) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       if (!this.model.nullOnErrors && stepExtractOptional(buffer, cursor, endCursor) !== null) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       return null;
     }
@@ -11515,10 +11549,10 @@ var StepEntityBase = class {
     const value = expressID !== void 0 ? model2.getTypedElementByExpressID(expressID, entityConstructor) : model2.getTypedInlineElementByAddress(extractInlineElementAddress(buffer, cursor, endCursor), entityConstructor);
     if (value === void 0) {
       if (!optional) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       if (!model2.nullOnErrors && stepExtractOptional(buffer, cursor, endCursor) !== null) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       return null;
     }

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.536.1507";
+var versionString = "Conway v1.543.1513";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -27074,6 +27074,18 @@ function freeAll(wasmModule, pointers) {
   }
 }
 
+// compiled/src/step/dangling_reference_error.js
+var DanglingReferenceError = class extends Error {
+  /**
+   * @param expressID The referenced record that is not in the index.
+   */
+  constructor(expressID) {
+    super(`Reference to #${expressID} is not in the index`);
+    this.expressID = expressID;
+    this.name = "DanglingReferenceError";
+  }
+};
+
 // compiled/src/step/step_entity_base.js
 var IfcTokenType;
 (function(IfcTokenType2) {
@@ -27265,16 +27277,38 @@ var StepEntityBase = class {
     }
     return value;
   }
+  /**
+   * Classify a reference field that failed to resolve.
+   *
+   * `getElementByExpressID` / `getTypedElementByExpressID` answer
+   * `undefined` for two opposite causes: the record is not in the index at
+   * all, or it is indexed but is the wrong entity type. A mid-parse prefix
+   * reader must tell them apart — the first may resolve once more of the
+   * file is scanned, the second never will — so the absent case gets its
+   * own error type (see {@link DanglingReferenceError}). Called only on a
+   * throwing path, so the extra index lookup costs nothing in the common
+   * case.
+   *
+   * @param expressID The reference's target, or undefined when the field
+   * did not hold a reference at all (an unresolved inline element).
+   * @return {Error} The error to throw.
+   */
+  unresolvedReferenceError_(expressID) {
+    if (expressID !== void 0 && this.model.resolveExpressID(expressID) === void 0) {
+      return new DanglingReferenceError(expressID);
+    }
+    return new Error("Value in STEP was incorrectly typed");
+  }
   extractReference(offset, baseOffset, depth, optional) {
     const [cursor, endCursor, buffer] = this.getOffsetAndEndCursor(offset, baseOffset, depth);
     const expressID = stepExtractReference(buffer, cursor, endCursor);
     const value = expressID !== void 0 ? this.model.getElementByExpressID(expressID) : this.model.getInlineElementByAddress(extractInlineElementAddress(buffer, cursor, endCursor));
     if (value === void 0) {
       if (!optional) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       if (!this.model.nullOnErrors && stepExtractOptional(buffer, cursor, endCursor) !== null) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       return null;
     }
@@ -27452,10 +27486,10 @@ var StepEntityBase = class {
     const value = expressID !== void 0 ? model.getTypedElementByExpressID(expressID, entityConstructor) : model.getTypedInlineElementByAddress(extractInlineElementAddress(buffer, cursor, endCursor), entityConstructor);
     if (value === void 0) {
       if (!optional) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       if (!model.nullOnErrors && stepExtractOptional(buffer, cursor, endCursor) !== null) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       return null;
     }
@@ -88505,6 +88539,20 @@ var yargs_default = Yargs;
 // compiled/src/ifc/ifc_command_line_main.js
 var import_fs = __toESM(require("fs"), 1);
 
+// compiled/src/ifc/dangling_placement_error.js
+var DanglingPlacementError = class extends Error {
+  /**
+   * @param productLocalID The product that could not be placed.
+   * @param cause The underlying dangling-reference error.
+   */
+  constructor(productLocalID, cause) {
+    super(`product ${productLocalID} placement is not resolvable in this prefix: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.productLocalID = productLocalID;
+    this.cause = cause;
+    this.name = "DanglingPlacementError";
+  }
+};
+
 // compiled/src/core/native_pool.js
 var ObjectPool = class {
   /**
@@ -89228,6 +89276,7 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
     this.deferDanglingPlacements = false;
     this.freeVectorPolygonalFaces_ = [];
     this.extractionMapsPrepared_ = false;
+    this.aggregateTargetsPaged_ = false;
     this.csgMemoization = !this.lowMemoryMode;
     this.quietRecoverableLogging = false;
     this.materials = model.materials;
@@ -92738,6 +92787,12 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
    * IFCLOCALPLACEMENT ancestors and their axis/point records included,
    * since `extractPlacement` resolves them through the same layer.
    *
+   * Only an unresolved reference (`DanglingReferenceError`) is tagged as
+   * a deferral. A placement that is malformed rather than unscanned still
+   * throws, and still stops the product being extracted, but propagates
+   * untagged so the preview does not queue it for a retry that can never
+   * come good — see the catch below.
+   *
    * The throw intentionally propagates: the demand seam
    * (`extractProductGeometryByLocalID` callers, the preview adapter's
    * per-unit catch) already treats a throwing product as
@@ -92759,6 +92814,11 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
       if (objectPlacement !== null) {
         this.extractPlacement(objectPlacement);
       }
+    } catch (error) {
+      if (error instanceof DanglingReferenceError) {
+        throw new DanglingPlacementError(product.localID, error);
+      }
+      throw error;
     } finally {
       model.nullOnErrors = priorNullOnErrors;
     }
@@ -93440,27 +93500,118 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
     const targets = /* @__PURE__ */ new Set();
     const productTypes = new Set(IfcProduct.query);
     for (const relAggregate of this.model.types(IfcRelAggregates)) {
+      this.addAggregateTargets_(relAggregate, targets, productTypes);
+    }
+    this.aggregateTargetLocalIDs_ = targets;
+    return targets;
+  }
+  /**
+   * Windowed twin of {@link aggregateTargetLocalIDs}: page each
+   * relationship record before scanning it, so the set is COMPLETE rather
+   * than whatever this instance's LRU happened to still hold.
+   *
+   * **This is a correctness fix, not a prefetch.** The sync walk reads each
+   * `IfcRelAggregates` record's bytes, and on a windowed source those pages
+   * are routinely gone by the first pump — the parse walked past them
+   * hundreds of megabytes ago. The per-record catch then swallows the
+   * non-resident read, the incomplete set is **cached for the model's
+   * life**, and every child it failed to record stays in the per-product
+   * worklist *as well as* in the aggregates pass. That product is then
+   * emitted twice: once with the uncut/placeholder content the deferral
+   * exists to suppress, and again from the aggregates pass. Measured on
+   * `aggregate_master_voids.ifc` behind 512-byte windows: 0 targets against
+   * a resident open's 1, and 3 demand products against 2.
+   *
+   * Paged in bounded waves, and the scan happens INSIDE each wave rather
+   * than after all of them: a model with many assemblies would otherwise
+   * need every relationship record resident at once, which is the residency
+   * ceiling this is supposed to respect.
+   *
+   * A non-resident read still throws from here — after this has paged the
+   * record, that is a defect in the paging, not a property of the file.
+   *
+   * @param waveSize Relationship records paged and scanned at once.
+   * @return {Promise<Set<number>>} The same set the sync twin caches.
+   */
+  async ensureAggregateTargetLocalIDs(waveSize = _IfcGeometryExtraction.AGGREGATE_TARGET_WAVE_SIZE_) {
+    if (!this.model.isSourceExternal) {
+      return this.aggregateTargetLocalIDs();
+    }
+    if (this.aggregateTargetsPaged_) {
+      return this.aggregateTargetLocalIDs_;
+    }
+    const targets = /* @__PURE__ */ new Set();
+    const productTypes = new Set(IfcProduct.query);
+    const wave = Math.max(1, Math.floor(waveSize));
+    let pending = [];
+    const drain = async () => {
+      const pinned = /* @__PURE__ */ new Set();
       try {
-        relAggregate.forEachReferenceInField(REL_AGGREGATES_RELATED_OFFSET, REL_AGGREGATES_RELATED_BASE, REL_AGGREGATES_RELATED_DEPTH, (expressID) => {
-          if (expressID === void 0) {
-            return true;
-          }
-          const relatedLocalID = this.model.resolveExpressID(expressID);
-          if (relatedLocalID === void 0) {
-            return true;
-          }
-          const typeID = this.model.typeIDOf(relatedLocalID);
-          if (typeID !== void 0 && productTypes.has(typeID)) {
-            targets.add(relatedLocalID);
-          }
-          return true;
-        });
-      } catch {
+        for (const relAggregate of pending) {
+          pinned.add(relAggregate.localID);
+          this.model.pinByLocalID(relAggregate.localID);
+        }
+        await Promise.all([...pinned].map((localID) => this.model.ensureResidentByLocalID(localID)));
+        for (const relAggregate of pending) {
+          this.addAggregateTargets_(relAggregate, targets, productTypes, true);
+        }
+      } finally {
+        this.model.releaseSourceViews(pinned);
+        this.model.unpinLocalIDs(pinned);
+        pending = [];
+      }
+    };
+    for (const relAggregate of this.model.types(IfcRelAggregates)) {
+      pending.push(relAggregate);
+      if (pending.length >= wave) {
+        await drain();
       }
     }
+    if (pending.length > 0) {
+      await drain();
+    }
     this.aggregateTargetLocalIDs_ = targets;
+    this.aggregateTargetsPaged_ = true;
     return targets;
   }
+  /**
+   * Record one relationship's product children.
+   *
+   * Shared by the sync and paged walks so there is a single definition of
+   * what an aggregate target is. Reads only this relationship's own record:
+   * children resolve through the express map and the typeID column, so the
+   * scan never hydrates a child product (doing so paged most of the file
+   * during demand prep).
+   *
+   * @param relAggregate The relationship to scan.
+   * @param targets Accumulator.
+   * @param productTypes The IfcProduct type set.
+   * @param strictResidency When set, a non-resident read propagates instead
+   * of being tolerated — for the paged walk, which has already made the
+   * record resident and so can only reach that error through a defect.
+   */
+  addAggregateTargets_(relAggregate, targets, productTypes, strictResidency = false) {
+    try {
+      relAggregate.forEachReferenceInField(REL_AGGREGATES_RELATED_OFFSET, REL_AGGREGATES_RELATED_BASE, REL_AGGREGATES_RELATED_DEPTH, (expressID) => {
+        if (expressID === void 0) {
+          return true;
+        }
+        const relatedLocalID = this.model.resolveExpressID(expressID);
+        if (relatedLocalID === void 0) {
+          return true;
+        }
+        const typeID = this.model.typeIDOf(relatedLocalID);
+        if (typeID !== void 0 && productTypes.has(typeID)) {
+          targets.add(relatedLocalID);
+        }
+        return true;
+      });
+    } catch (error) {
+      if (strictResidency && error instanceof StepBufferNotResidentError) {
+        throw error;
+      }
+    }
+  }
   /**
    * One-time extraction setup shared by the whole-model walk and the
    * per-product demand path (Phase B2): linear scaling factor and the
@@ -94084,6 +94235,7 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
     }
   }
 };
+IfcGeometryExtraction.AGGREGATE_TARGET_WAVE_SIZE_ = 512;
 
 // compiled/src/ifc/ifc_property_extraction.js
 var PropertyExtractResult;
@@ -94431,6 +94583,10 @@ function formatModelLine(info) {
   const detail = parts.length > 0 ? ` \u2014 ${parts.join(", ")}` : "";
   return `Model: ${name}${detail}`;
 }
+function formatPreviewLine(preview) {
+  const first = preview.firstMeshMs !== void 0 ? `first mesh ${formatSeconds(preview.firstMeshMs)}` : "no mesh";
+  return `Preview: ${first}, ${preview.meshes} meshes from ${preview.emitted} units, ${preview.deferred} deferred (${preview.deferredOnPlacement} on placements), ${preview.retried} retried`;
+}
 function heapDeltaSuffix(state) {
   if (state.startHeapMb === void 0 || state.lastHeapMb === void 0) {
     return "";
@@ -94465,6 +94621,21 @@ var LoadLogAccumulator = class {
     this.modelLine_ = formatModelLine(info);
     return this.modelLine_;
   }
+  /**
+   * Record what the parse-time preview delivered — kept with the report
+   * and rendered between the stage lines and Total.
+   *
+   * Not a stage: the preview runs *inside* Parsing, so feeding it through
+   * onProgress would close the Parsing stage and reopen it, splitting one
+   * parse across two lines.
+   *
+   * @param preview The channel's reported yield.
+   * @return {string} The formatted preview line.
+   */
+  setPreviewStats(preview) {
+    this.previewLine_ = formatPreviewLine(preview);
+    return this.previewLine_;
+  }
   /**
    * Feed one progress event; returns the finished stage's line when this
    * event closed a stage (so callers can mirror it to a console/log once).
@@ -94565,8 +94736,9 @@ var LoadLogAccumulator = class {
     return `Total: ${formatSeconds(duration)}${heap}`;
   }
   /**
-   * The full report: model line (if known), finished stage lines, then the
-   * Total line. Call closeCurrentStage() first at load end.
+   * The full report: model line (if known), finished stage lines, the
+   * preview line (if reported), then the Total line. Call
+   * closeCurrentStage() first at load end.
    *
    * @return {string[]} All report lines.
    */
@@ -94576,6 +94748,9 @@ var LoadLogAccumulator = class {
       lines.push(this.modelLine_);
     }
     lines.push(...this.finished_);
+    if (this.previewLine_ !== void 0) {
+      lines.push(this.previewLine_);
+    }
     lines.push(this.totalLine());
     return lines;
   }

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

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.536.1507";
+var versionString = "Conway v1.543.1513";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -22962,6 +22962,18 @@ function releaseQuietly(release) {
   }
 }
 
+// compiled/src/step/dangling_reference_error.js
+var DanglingReferenceError = class extends Error {
+  /**
+   * @param expressID The referenced record that is not in the index.
+   */
+  constructor(expressID) {
+    super(`Reference to #${expressID} is not in the index`);
+    this.expressID = expressID;
+    this.name = "DanglingReferenceError";
+  }
+};
+
 // compiled/src/step/step_entity_base.js
 var IfcTokenType;
 (function(IfcTokenType2) {
@@ -23153,16 +23165,38 @@ var StepEntityBase = class {
     }
     return value;
   }
+  /**
+   * Classify a reference field that failed to resolve.
+   *
+   * `getElementByExpressID` / `getTypedElementByExpressID` answer
+   * `undefined` for two opposite causes: the record is not in the index at
+   * all, or it is indexed but is the wrong entity type. A mid-parse prefix
+   * reader must tell them apart — the first may resolve once more of the
+   * file is scanned, the second never will — so the absent case gets its
+   * own error type (see {@link DanglingReferenceError}). Called only on a
+   * throwing path, so the extra index lookup costs nothing in the common
+   * case.
+   *
+   * @param expressID The reference's target, or undefined when the field
+   * did not hold a reference at all (an unresolved inline element).
+   * @return {Error} The error to throw.
+   */
+  unresolvedReferenceError_(expressID) {
+    if (expressID !== void 0 && this.model.resolveExpressID(expressID) === void 0) {
+      return new DanglingReferenceError(expressID);
+    }
+    return new Error("Value in STEP was incorrectly typed");
+  }
   extractReference(offset, baseOffset, depth, optional) {
     const [cursor, endCursor, buffer] = this.getOffsetAndEndCursor(offset, baseOffset, depth);
     const expressID = stepExtractReference(buffer, cursor, endCursor);
     const value = expressID !== void 0 ? this.model.getElementByExpressID(expressID) : this.model.getInlineElementByAddress(extractInlineElementAddress(buffer, cursor, endCursor));
     if (value === void 0) {
       if (!optional) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       if (!this.model.nullOnErrors && stepExtractOptional(buffer, cursor, endCursor) !== null) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       return null;
     }
@@ -23340,10 +23374,10 @@ var StepEntityBase = class {
     const value = expressID !== void 0 ? model.getTypedElementByExpressID(expressID, entityConstructor) : model.getTypedInlineElementByAddress(extractInlineElementAddress(buffer, cursor, endCursor), entityConstructor);
     if (value === void 0) {
       if (!optional) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       if (!model.nullOnErrors && stepExtractOptional(buffer, cursor, endCursor) !== null) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       return null;
     }

package/compiled/examples/validator-bundled.cjs

@@ -944,7 +944,7 @@ var EntityTypesIfcCount = 909;
 var entity_types_ifc_gen_default = EntityTypesIfc;
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.536.1507";
+var versionString = "Conway v1.543.1513";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -11135,6 +11135,18 @@ function releaseQuietly(release) {
   }
 }
 
+// compiled/src/step/dangling_reference_error.js
+var DanglingReferenceError = class extends Error {
+  /**
+   * @param expressID The referenced record that is not in the index.
+   */
+  constructor(expressID) {
+    super(`Reference to #${expressID} is not in the index`);
+    this.expressID = expressID;
+    this.name = "DanglingReferenceError";
+  }
+};
+
 // compiled/src/step/step_entity_base.js
 var IfcTokenType;
 (function(IfcTokenType2) {
@@ -11326,16 +11338,38 @@ var StepEntityBase = class {
     }
     return value;
   }
+  /**
+   * Classify a reference field that failed to resolve.
+   *
+   * `getElementByExpressID` / `getTypedElementByExpressID` answer
+   * `undefined` for two opposite causes: the record is not in the index at
+   * all, or it is indexed but is the wrong entity type. A mid-parse prefix
+   * reader must tell them apart — the first may resolve once more of the
+   * file is scanned, the second never will — so the absent case gets its
+   * own error type (see {@link DanglingReferenceError}). Called only on a
+   * throwing path, so the extra index lookup costs nothing in the common
+   * case.
+   *
+   * @param expressID The reference's target, or undefined when the field
+   * did not hold a reference at all (an unresolved inline element).
+   * @return {Error} The error to throw.
+   */
+  unresolvedReferenceError_(expressID) {
+    if (expressID !== void 0 && this.model.resolveExpressID(expressID) === void 0) {
+      return new DanglingReferenceError(expressID);
+    }
+    return new Error("Value in STEP was incorrectly typed");
+  }
   extractReference(offset, baseOffset, depth, optional) {
     const [cursor, endCursor, buffer] = this.getOffsetAndEndCursor(offset, baseOffset, depth);
     const expressID = stepExtractReference(buffer, cursor, endCursor);
     const value = expressID !== void 0 ? this.model.getElementByExpressID(expressID) : this.model.getInlineElementByAddress(extractInlineElementAddress(buffer, cursor, endCursor));
     if (value === void 0) {
       if (!optional) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       if (!this.model.nullOnErrors && stepExtractOptional(buffer, cursor, endCursor) !== null) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       return null;
     }
@@ -11513,10 +11547,10 @@ var StepEntityBase = class {
     const value = expressID !== void 0 ? model2.getTypedElementByExpressID(expressID, entityConstructor) : model2.getTypedInlineElementByAddress(extractInlineElementAddress(buffer, cursor, endCursor), entityConstructor);
     if (value === void 0) {
       if (!optional) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       if (!model2.nullOnErrors && stepExtractOptional(buffer, cursor, endCursor) !== null) {
-        throw new Error("Value in STEP was incorrectly typed");
+        throw this.unresolvedReferenceError_(expressID);
       }
       return null;
     }

package/compiled/src/compat/web-ifc/geometry_shard_coordination.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=geometry_shard_coordination.test.d.ts.map

package/compiled/src/compat/web-ifc/geometry_shard_coordination.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry_shard_coordination.test.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/geometry_shard_coordination.test.ts"],"names":[],"mappings":""}