@bldrs-ai/conway 1.538.1511 → 1.548.1514

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.538.1511";
+var versionString = "Conway v1.548.1514";
 
 // 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.538.1511";
+var versionString = "Conway v1.548.1514";
 
 // 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 {
   /**
@@ -92739,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
@@ -92760,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;
     }
@@ -94524,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 "";
@@ -94558,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).
@@ -94658,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.
    */
@@ -94669,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.538.1511";
+var versionString = "Conway v1.548.1514";
 
 // 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.538.1511";
+var versionString = "Conway v1.548.1514";
 
 // 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;
     }