@bldrs-ai/conway 1.567.1542 → 1.569.1545

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.567.1542";
+var versionString = "Conway v1.569.1545";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -121,6 +121,31 @@ var Statistics = class {
   setGeometryTime(value) {
     this.geometryTime = value;
   }
+  /**
+   * Which pipeline measured this row (conway#555).
+   *
+   * The perf columns are not all comparable across pipelines: the IFC
+   * regression child runs with `RegressionCaptureState.memoization = FULL`,
+   * which keeps CSG temporaries in the map `calculateGeometrySize()` sums,
+   * so its `Geometry Memory` reads ~30% above the CLI's for the same model
+   * (MB-Khaya, 22.3 vs 16.8 MB). Retention has a matching caveat — the
+   * loader brings up a `ConwayGeometry` per load and the regression children
+   * do not. Naming the writer is what lets a reader, and
+   * `scripts/gen_delta_csv.cjs`, tell those apart instead of differencing
+   * across them.
+   *
+   * @return {string | undefined} - the writer label, or undefined
+   */
+  getWriter() {
+    return this.writer;
+  }
+  /**
+   *
+   * @param value - a stable pipeline identifier, e.g. `ifc-cli`
+   */
+  setWriter(value) {
+    this.writer = value;
+  }
   /**
    *
    * @return {number | undefined} - total execution time or undefined
@@ -361,7 +386,7 @@ var Statistics = class {
     const retained = `Retained RSS Delta: ${formatRetained(this.retainedRss)}, Retained Heap-Used Delta: ${formatRetained(this.retainedHeapUsed)}, Retained External Delta: ${formatRetained(this.retainedExternal)}, `;
     const breakdown = this.formatGeometryTypeCounts();
     const geometryTypes = breakdown !== void 0 ? `, Geometry Types: ${breakdown}` : "";
-    return `[${dateString}]: Load Status: ${this.loadStatus}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, WASM Heap High-Water: ${this.wasmHeapPeak?.toFixed(3)} MB, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
+    return `[${dateString}]: Load Status: ${this.loadStatus}, Writer: ${this.writer ?? "N/A"}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, WASM Heap High-Water: ${this.wasmHeapPeak?.toFixed(3)} MB, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 

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.567.1542";
+var versionString = "Conway v1.569.1545";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -15795,6 +15795,31 @@ var Statistics = class {
   setGeometryTime(value) {
     this.geometryTime = value;
   }
+  /**
+   * Which pipeline measured this row (conway#555).
+   *
+   * The perf columns are not all comparable across pipelines: the IFC
+   * regression child runs with `RegressionCaptureState.memoization = FULL`,
+   * which keeps CSG temporaries in the map `calculateGeometrySize()` sums,
+   * so its `Geometry Memory` reads ~30% above the CLI's for the same model
+   * (MB-Khaya, 22.3 vs 16.8 MB). Retention has a matching caveat — the
+   * loader brings up a `ConwayGeometry` per load and the regression children
+   * do not. Naming the writer is what lets a reader, and
+   * `scripts/gen_delta_csv.cjs`, tell those apart instead of differencing
+   * across them.
+   *
+   * @return {string | undefined} - the writer label, or undefined
+   */
+  getWriter() {
+    return this.writer;
+  }
+  /**
+   *
+   * @param value - a stable pipeline identifier, e.g. `ifc-cli`
+   */
+  setWriter(value) {
+    this.writer = value;
+  }
   /**
    *
    * @return {number | undefined} - total execution time or undefined
@@ -16035,7 +16060,7 @@ var Statistics = class {
     const retained = `Retained RSS Delta: ${formatRetained(this.retainedRss)}, Retained Heap-Used Delta: ${formatRetained(this.retainedHeapUsed)}, Retained External Delta: ${formatRetained(this.retainedExternal)}, `;
     const breakdown = this.formatGeometryTypeCounts();
     const geometryTypes = breakdown !== void 0 ? `, Geometry Types: ${breakdown}` : "";
-    return `[${dateString}]: Load Status: ${this.loadStatus}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, WASM Heap High-Water: ${this.wasmHeapPeak?.toFixed(3)} MB, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
+    return `[${dateString}]: Load Status: ${this.loadStatus}, Writer: ${this.writer ?? "N/A"}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, WASM Heap High-Water: ${this.wasmHeapPeak?.toFixed(3)} MB, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 
@@ -93591,13 +93616,56 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
       return this.aggregateTargetLocalIDs_;
     }
     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.addAggregateTargets_(relAggregate, targets);
     }
     this.aggregateTargetLocalIDs_ = targets;
     return targets;
   }
+  /**
+   * The per-relationship product counts the PAGED walk collected, handed
+   * over and dropped in one call.
+   *
+   * Counts are how many products the aggregates pass will extract for a
+   * relationship — the size of the unit of work
+   * {@link extractRelAggregateGeometryIncremental} steps through — which the
+   * demand pump needs to report progress in products rather than in
+   * relationships (conway#565: SKYLARK250 puts ~1,960 products under one
+   * relationship, so a relationship-counted bar sat at 1/2 for the whole
+   * load).
+   *
+   * **Collected only on the windowed walk, and only because that is the one
+   * place it is free.** {@link ensureAggregateTargetLocalIDs} already pages
+   * and scans every `IfcRelAggregates` record, so the count is the number it
+   * was discarding. A resident model has no such moment worth capturing —
+   * it can read the same records at adopt time for nothing — so the sync
+   * walk collects nothing at all and the whole-model extraction, which
+   * shares that walk, retains nothing.
+   *
+   * **Handed over rather than cached** (conway#569 review). The prefix the
+   * pump builds from these is itself the durable structure; keeping a second
+   * copy for the model's life is retention with no reader. Measured on an
+   * adverse model — 50,000 relationships over 100,000 products, the shape
+   * where relationship count approaches product count — the map holds
+   * 1.75 MB at 36.7 bytes per relationship. Not fatal beside the 16.4 MB
+   * the target Set from the same walk retains, but it is avoidable, and
+   * `setGeometryShard` refuses to run once a worklist exists so the prefix
+   * is built exactly once and there is nothing to hand it to twice.
+   *
+   * **The same number the resident pump derives for itself**, from the same
+   * call: {@link aggregateRelatedProductCount}. Approximate in one
+   * direction only — a `RelatedObjects` list that needs the generated
+   * getter counts 0 — and the pump's own drain condition, not this number,
+   * decides when the pass is finished.
+   *
+   * @return {Map<number, number> | undefined} Counts keyed by relationship
+   * localID, or undefined where no paged walk ran. The caller owns it.
+   */
+  takeAggregateRelatedProductCounts() {
+    const counts = this.pagedAggregateProductCounts_;
+    this.pagedAggregateProductCounts_ = void 0;
+    return counts;
+  }
   /**
    * Windowed twin of {@link aggregateTargetLocalIDs}: page each
    * relationship record before scanning it, so the set is COMPLETE rather
@@ -93634,7 +93702,7 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
       return this.aggregateTargetLocalIDs_;
     }
     const targets = /* @__PURE__ */ new Set();
-    const productTypes = new Set(IfcProduct.query);
+    const counts = /* @__PURE__ */ new Map();
     const wave = Math.max(1, Math.floor(waveSize));
     let pending = [];
     const drain = async () => {
@@ -93646,7 +93714,8 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
         }
         await Promise.all([...pinned].map((localID) => this.model.ensureResidentByLocalID(localID)));
         for (const relAggregate of pending) {
-          this.addAggregateTargets_(relAggregate, targets, productTypes, true);
+          this.addAggregateTargets_(relAggregate, targets, true);
+          counts.set(relAggregate.localID, this.aggregateRelatedProductCount(relAggregate));
         }
       } finally {
         this.model.releaseSourceViews(pinned);
@@ -93664,6 +93733,7 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
       await drain();
     }
     this.aggregateTargetLocalIDs_ = targets;
+    this.pagedAggregateProductCounts_ = counts;
     this.aggregateTargetsPaged_ = true;
     return targets;
   }
@@ -93672,30 +93742,62 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
    *
    * 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).
+   * the entries are scanned as `#N` references off the record's own bytes,
+   * never through `relAggregate.RelatedObjects` — that generated getter
+   * memoizes the materialised array onto the relationship, which is the
+   * 2.7 GB retention of conway#549 §4.1 and, on a windowed source, pages
+   * most of the file during demand prep.
+   *
+   * Classification goes through {@link relatedProductByExpressID_}, the
+   * same call the aggregates pass makes, so deferral and extraction cannot
+   * disagree about which entries are products. The typeID column cannot
+   * answer this: a STEP complex instance is recorded under type 0
+   * (`EXTERNALMAPPINGCONTAINER`) while `getTypedElementByExpressID` finds
+   * the `IfcProduct` among its `multiMapping` variants, so a column test
+   * left a complex product out of the target set and both passes then
+   * extracted it — one product, two scene instances (conway#566 left this
+   * one in place deliberately; it is milder than the paging divergence
+   * that PR fixed, because it costs a duplicate extraction rather than a
+   * non-resident read).
+   *
+   * Materialising to classify costs no source bytes and no residency:
+   * `getTypedElementByExpressID` builds its descriptor from the columns
+   * (`makeDescriptor`) and the entity constructor has an empty body, so
+   * nothing here can throw `StepBufferNotResidentError` on a windowed
+   * source. What it does add is one cached descriptor per related object
+   * — ~117 B (conway#549 §4.3) against a set the aggregates pass
+   * materialises in full anyway, so ~233 KB on SKYLARK250's 1,992
+   * children. It does NOT touch a child's closure: the B-rep subtree is
+   * only reachable through the generated getters, which this never calls.
+   *
+   * A throw from the classification abandons the rest of the
+   * relationship, which is what the pass does with the same entry — its
+   * permissive catch drops the remaining products too. Recording targets
+   * past that point would defer products the pass will never reach, i.e.
+   * extract them in neither pass.
+   *
+   * Deliberately NOT the place the progress denominator is counted, even
+   * though the entries pass through here for free and, since conway#568,
+   * through the same classification: `targets` is a Set over the WHOLE
+   * model, so a product reached through two relationships collapses into
+   * one entry here while costing the pass a step in each. See
+   * {@link aggregateRelatedProductCount}.
    *
    * @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) {
+  addAggregateTargets_(relAggregate, targets, 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);
+        const relatedProduct = this.relatedProductByExpressID_(expressID);
+        if (relatedProduct !== void 0) {
+          targets.add(relatedProduct.localID);
         }
         return true;
       });
@@ -94138,10 +94240,10 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
    * `IfcProduct` among its `multiMapping` variants, and the product would
    * then be extracted without ever being paged (conway#566 review).
    *
-   * Note {@link aggregateTargetLocalIDs} still reads the column, and has the
-   * same blind spot — a complex product is not deferred, so it is extracted
-   * by both passes. That is pre-existing and independent of paging: it costs
-   * a duplicate extraction, not a non-resident read.
+   * {@link aggregateTargetLocalIDs} classifies through the same call for
+   * the same reason — a column test there left a complex product out of
+   * the deferral set, so both passes extracted it. See
+   * {@link addAggregateTargets_}.
    *
    * Seam for {@link AggregateExtractPager}, which lives in this module.
    *
@@ -94169,6 +94271,53 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
     }
     return productLocalIDs;
   }
+  /**
+   * How many products the aggregates pass will actually extract from one
+   * relationship — the size of the unit of work
+   * {@link extractRelAggregateGeometryIncremental} steps through, and the
+   * per-relationship term of the demand pumps' progress denominator
+   * (conway#565).
+   *
+   * **Derived through the pass's own path** —
+   * {@link relatedAggregateProductLocalIDs} and so
+   * {@link relatedProductByExpressID_} — rather than counted off the
+   * target scan, which has the same entries in hand for free.
+   *
+   * The boundary is why. An entry the classification throws on — a
+   * reference that resolves to nothing, or to something that is not an
+   * `IfcObjectDefinition` — ENDS the relationship: the pass's permissive
+   * catch abandons every product after it. A count that skipped the bad
+   * entry and kept going put work in the denominator that would never run,
+   * and the bar then jumped the whole abandoned tail when the relationship
+   * terminated (conway#569 review). On SKYLARK's shape — one relationship
+   * over ~1,960 products — that jump is the entire bar.
+   * {@link relatedAggregateProductLocalIDs} stops where the pass stops;
+   * {@link addAggregateTargets_}, whose Set collapses a product shared by
+   * two relationships, could not carry the number anyway.
+   *
+   * It is still only a PREDICTION of where the pass stops — see the
+   * `TODO(conway#574)` in `IfcApiProxyIfc.demandProgress_`.
+   *
+   * Costs no source bytes beyond the relationship's own record:
+   * `getTypedElementByExpressID` builds its descriptor from the columns
+   * (conway#566 swept exactly this call over SKYLARK250's 7,818,778
+   * records behind an exhausted window — 0 throws, 0 store bytes). That is
+   * what lets the paged walk call it inside a wave, where only the
+   * relationship record is resident, as well as the resident pump calling
+   * it at worklist-adopt time.
+   *
+   * **0 for a `RelatedObjects` list only the generated getter can
+   * resolve** — an inline entity, `$` or junk. Counting those exactly means
+   * materialising the array both callers exist to avoid, and an under-count
+   * only pauses the bar short of full: `remaining` is derived from the
+   * cursors, never from this.
+   *
+   * @param relAggregate The relationship to cost.
+   * @return {number} Related products the aggregates pass will extract.
+   */
+  aggregateRelatedProductCount(relAggregate) {
+    return this.relatedAggregateProductLocalIDs(relAggregate)?.length ?? 0;
+  }
   /**
    * Page the closures of a contiguous run of
    * {@link relatedAggregateProductLocalIDs} entries.
@@ -94218,7 +94367,15 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
         hop.push(localID);
         await this.model.ensureResidentByLocalID(localID);
       }
-      const related = relAggregate.RelatedObjects;
+      let related;
+      try {
+        related = relAggregate.RelatedObjects;
+      } catch (error) {
+        if (error instanceof StepBufferNotResidentError) {
+          throw error;
+        }
+        return;
+      }
       if (related !== null && related !== void 0) {
         for (const product of related) {
           await this.ensureResidentForProductExtract(product.localID, pinned, leafSpans);
@@ -94290,21 +94447,29 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
    * @param relAggregate The relationship to read.
    * @return {number[] | undefined} The related objects' express IDs in
    * record order, or undefined when the list holds an entry that is not a
-   * `#N` reference — an inline entity, `$`, or junk. Only the generated
-   * getter can resolve (or reject) those, so the caller falls back to it
-   * rather than guessing.
+   * `#N` reference — an inline entity, `$`, junk, or a field that is not a
+   * list at all. Only the generated getter can resolve (or reject) those,
+   * so the caller falls back to it rather than guessing. A non-residency
+   * failure propagates instead: see the catch.
    */
   relatedObjectExpressIDs_(relAggregate) {
     const expressIDs = [];
     let allReferences = true;
-    relAggregate.forEachReferenceInField(REL_AGGREGATES_RELATED_OFFSET, REL_AGGREGATES_RELATED_BASE, REL_AGGREGATES_RELATED_DEPTH, (expressID) => {
-      if (expressID === void 0) {
-        allReferences = false;
-        return false;
+    try {
+      relAggregate.forEachReferenceInField(REL_AGGREGATES_RELATED_OFFSET, REL_AGGREGATES_RELATED_BASE, REL_AGGREGATES_RELATED_DEPTH, (expressID) => {
+        if (expressID === void 0) {
+          allReferences = false;
+          return false;
+        }
+        expressIDs.push(expressID);
+        return true;
+      });
+    } catch (error) {
+      if (error instanceof StepBufferNotResidentError) {
+        throw error;
       }
-      expressIDs.push(expressID);
-      return true;
-    });
+      return void 0;
+    }
     return allReferences ? expressIDs : void 0;
   }
   /**
@@ -95708,6 +95873,7 @@ function doWork() {
     if (statistics !== void 0) {
       const dataParseTime = parseDataTimeEnd - parseDataTimeStart;
       statistics.setLoadStatus("OK");
+      statistics.setWriter("ifc-cli");
       statistics.setParseTime(dataParseTime);
       statistics.setTotalTime(allTime);
       let FILE_NAME = stepHeader.headers.get("FILE_NAME");

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

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.567.1542";
+var versionString = "Conway v1.569.1545";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -16773,6 +16773,31 @@ var Statistics = class {
   setGeometryTime(value) {
     this.geometryTime = value;
   }
+  /**
+   * Which pipeline measured this row (conway#555).
+   *
+   * The perf columns are not all comparable across pipelines: the IFC
+   * regression child runs with `RegressionCaptureState.memoization = FULL`,
+   * which keeps CSG temporaries in the map `calculateGeometrySize()` sums,
+   * so its `Geometry Memory` reads ~30% above the CLI's for the same model
+   * (MB-Khaya, 22.3 vs 16.8 MB). Retention has a matching caveat — the
+   * loader brings up a `ConwayGeometry` per load and the regression children
+   * do not. Naming the writer is what lets a reader, and
+   * `scripts/gen_delta_csv.cjs`, tell those apart instead of differencing
+   * across them.
+   *
+   * @return {string | undefined} - the writer label, or undefined
+   */
+  getWriter() {
+    return this.writer;
+  }
+  /**
+   *
+   * @param value - a stable pipeline identifier, e.g. `ifc-cli`
+   */
+  setWriter(value) {
+    this.writer = value;
+  }
   /**
    *
    * @return {number | undefined} - total execution time or undefined
@@ -17013,7 +17038,7 @@ var Statistics = class {
     const retained = `Retained RSS Delta: ${formatRetained(this.retainedRss)}, Retained Heap-Used Delta: ${formatRetained(this.retainedHeapUsed)}, Retained External Delta: ${formatRetained(this.retainedExternal)}, `;
     const breakdown = this.formatGeometryTypeCounts();
     const geometryTypes = breakdown !== void 0 ? `, Geometry Types: ${breakdown}` : "";
-    return `[${dateString}]: Load Status: ${this.loadStatus}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, WASM Heap High-Water: ${this.wasmHeapPeak?.toFixed(3)} MB, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
+    return `[${dateString}]: Load Status: ${this.loadStatus}, Writer: ${this.writer ?? "N/A"}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, WASM Heap High-Water: ${this.wasmHeapPeak?.toFixed(3)} MB, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 
@@ -86105,6 +86130,7 @@ async function doWork() {
     if (statistics !== void 0) {
       const dataParseTime = parseDataTimeEnd - parseDataTimeStart;
       statistics.setLoadStatus("OK");
+      statistics.setWriter("ap214-cli");
       statistics.setParseTime(dataParseTime);
       statistics.setTotalTime(allTime);
       let FILE_NAME = stepHeader.headers.get("FILE_NAME");

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.567.1542";
+var versionString = "Conway v1.569.1545";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -1035,6 +1035,31 @@ var Statistics = class {
   setGeometryTime(value) {
     this.geometryTime = value;
   }
+  /**
+   * Which pipeline measured this row (conway#555).
+   *
+   * The perf columns are not all comparable across pipelines: the IFC
+   * regression child runs with `RegressionCaptureState.memoization = FULL`,
+   * which keeps CSG temporaries in the map `calculateGeometrySize()` sums,
+   * so its `Geometry Memory` reads ~30% above the CLI's for the same model
+   * (MB-Khaya, 22.3 vs 16.8 MB). Retention has a matching caveat — the
+   * loader brings up a `ConwayGeometry` per load and the regression children
+   * do not. Naming the writer is what lets a reader, and
+   * `scripts/gen_delta_csv.cjs`, tell those apart instead of differencing
+   * across them.
+   *
+   * @return {string | undefined} - the writer label, or undefined
+   */
+  getWriter() {
+    return this.writer;
+  }
+  /**
+   *
+   * @param value - a stable pipeline identifier, e.g. `ifc-cli`
+   */
+  setWriter(value) {
+    this.writer = value;
+  }
   /**
    *
    * @return {number | undefined} - total execution time or undefined
@@ -1275,7 +1300,7 @@ var Statistics = class {
     const retained = `Retained RSS Delta: ${formatRetained(this.retainedRss)}, Retained Heap-Used Delta: ${formatRetained(this.retainedHeapUsed)}, Retained External Delta: ${formatRetained(this.retainedExternal)}, `;
     const breakdown = this.formatGeometryTypeCounts();
     const geometryTypes = breakdown !== void 0 ? `, Geometry Types: ${breakdown}` : "";
-    return `[${dateString}]: Load Status: ${this.loadStatus}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, WASM Heap High-Water: ${this.wasmHeapPeak?.toFixed(3)} MB, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
+    return `[${dateString}]: Load Status: ${this.loadStatus}, Writer: ${this.writer ?? "N/A"}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, WASM Heap High-Water: ${this.wasmHeapPeak?.toFixed(3)} MB, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 

package/compiled/src/AP214E3_2010/ap214_command_line_main.js

@@ -217,6 +217,7 @@ async function doWork() {
         if (statistics !== void 0) {
             const dataParseTime = parseDataTimeEnd - parseDataTimeStart;
             statistics.setLoadStatus("OK");
+            statistics.setWriter("ap214-cli");
             statistics.setParseTime(dataParseTime);
             statistics.setTotalTime(allTime);
             let FILE_NAME = stepHeader.headers.get("FILE_NAME");

package/compiled/src/AP214E3_2010/ap214_regression_main.js

@@ -45,6 +45,18 @@ const KB_PER_MB = 1024;
 const PERF_MB_PRECISION = 2;
 /** Placeholder for a column this row has no measurement for. */
 const UNMEASURED = "N/A";
+/**
+ * This child's value for the `writer` column (conway#555).
+ *
+ * Distinct from the IFC child's for a reason that is easy to miss: the two
+ * run as separate processes and `RegressionCaptureState.memoization` is a
+ * process-global, so the IFC child's `FULL` — which keeps CSG temporaries in
+ * the map `calculateGeometrySize()` sums — does not apply here. A mixed
+ * IFC/STEP corpus therefore aggregates two capture modes into one
+ * `geometryMemoryMb` column, which is precisely what this column exists to
+ * disclose.
+ */
+const PERF_WRITER = "ap214-regression";
 /**
  * Capture the end-of-load memory figures for a perf row.
  *
@@ -80,17 +92,23 @@ function capturePerfMemory(geometryMemoryBytes, wasmHeapBytes) {
  * was not exposed to settle with. No `retainedWasmHeapMb` — the wasm heap is
  * grow-only, so over one cycle it could only restate `peakWasmHeapMb`.
  *
+ * `writer` names the pipeline (conway#555) and `totalTimeMs` is the load's
+ * wall clock rather than the sum of the two stage columns (conway#562), with
+ * that sum kept as `parsePlusGeometryMs`. Both changes are described in full
+ * on the IFC child's copy.
+ *
  * @param perfPath Path to write the CSV to. Empty string disables.
  * @param stepFile Source STEP file path (basename used as the row key).
  * @param status OK or FAIL.
  * @param parseTimeMs Parse stage duration in ms.
  * @param geometryTimeMs Geometry extraction duration in ms.
- * @param totalTimeMs Sum of parse + geometry in ms.
+ * @param totalTimeMs The load's wall clock — file read through teardown.
+ * @param parsePlusGeometryMs The sum of the two stage columns above.
  * @param memory The row's memory figures, captured at the points in the load
  * each is defined at. Defaults to capturing the end-of-load instants here,
  * which is what the FAIL paths want — they have nothing else to report.
  */
-async function writePerfCsvIfRequested(perfPath, stepFile, status, parseTimeMs, geometryTimeMs, totalTimeMs, memory = capturePerfMemory()) {
+async function writePerfCsvIfRequested(perfPath, stepFile, status, parseTimeMs, geometryTimeMs, totalTimeMs, parsePlusGeometryMs, memory = capturePerfMemory()) {
     if (perfPath.length === 0) {
         return;
     }
@@ -116,10 +134,12 @@ async function writePerfCsvIfRequested(perfPath, stepFile, status, parseTimeMs,
     const retainedExternalMb = retained !== void 0 ?
         retained.externalMb.toFixed(PERF_MB_PRECISION) : UNMEASURED;
     const fileName = csvSafeString(path.basename(stepFile));
-    const header = "file,status,parseTimeMs,geometryTimeMs,totalTimeMs,geometryMemoryMb," +
+    const header = "file,status,writer,parseTimeMs,geometryTimeMs,totalTimeMs," +
+        "parsePlusGeometryMs,geometryMemoryMb," +
         "peakWasmHeapMb,rssMb,peakRssMb,heapUsedMb,heapTotalMb,externalMb," +
         "arrayBuffersMb,retainedRssMb,retainedHeapUsedMb,retainedExternalMb\n";
-    const row = `${fileName},${status},${parseTimeMs},${geometryTimeMs},${totalTimeMs},` +
+    const row = `${fileName},${status},${PERF_WRITER},${parseTimeMs},${geometryTimeMs},` +
+        `${totalTimeMs},${parsePlusGeometryMs},` +
         `${geometryMemoryMb},${peakWasmHeapMb},${rssMb},${peakRssMb},` +
         `${heapUsedMb},${heapTotalMb},${externalMb},${arrayBuffersMb},` +
         `${retainedRssMb},${retainedHeapUsedMb},${retainedExternalMb}\n`;
@@ -213,6 +233,10 @@ function doWork() {
         // reason recorded on that function: the batch passes `--expose-gc` to
         // every child, not just the ones given `--perf`.
         const memoryBaseline = await settleAndSampleMemoryForPerf(perfPath);
+        // Where `totalTimeMs` starts (conway#562): after the settle, so the
+        // retention samples stay outside every timed column, and before the
+        // file read, which is real load cost no stage clock could see.
+        const loadStartMs = Date.now();
         try {
             stepBuffer = fs.readFileSync(stepFile);
         }
@@ -268,7 +292,7 @@ function doWork() {
         const parseEndMs = Date.now();
         const parseTimeMs = parseEndMs - parseStartMs;
         if (model === void 0) {
-            await writePerfCsvIfRequested(perfPath, stepFile, "FAIL", parseTimeMs, 0, parseTimeMs);
+            await writePerfCsvIfRequested(perfPath, stepFile, "FAIL", parseTimeMs, 0, Date.now() - loadStartMs, parseTimeMs);
             displayErrors(stepFile);
             return;
         }
@@ -277,7 +301,9 @@ function doWork() {
         const extraction = geometryExtraction(model);
         const geomEndMs = Date.now();
         const geometryTimeMs = geomEndMs - geomStartMs;
-        const totalTimeMs = geomEndMs - parseStartMs;
+        // The sum `totalTimeMs` used to hold — an identity by construction,
+        // since `geomStartMs` is taken on the line after `parseEndMs`.
+        const parsePlusGeometryMs = geomEndMs - parseStartMs;
         const perfStatus = extraction === void 0 ? "FAIL" : "OK";
         // Sized before anything downstream can release meshes, and only on
         // the OK path: a failed extraction leaves a partial cache whose size
@@ -301,8 +327,10 @@ function doWork() {
         // the blessed output beats saving the work. The settle below IS
         // gated; see `memoryBaseline` above.
         model.invalidate(true);
+        // Closes on the teardown, before the retained settle.
+        const totalTimeMs = Date.now() - loadStartMs;
         memory.retained = retainedMemoryMb(memoryBaseline, await settleAndSampleMemoryForPerf(perfPath));
-        await writePerfCsvIfRequested(perfPath, stepFile, perfStatus, parseTimeMs, geometryTimeMs, totalTimeMs, memory);
+        await writePerfCsvIfRequested(perfPath, stepFile, perfStatus, parseTimeMs, geometryTimeMs, totalTimeMs, parsePlusGeometryMs, memory);
         // AFTP sizing pass: no-op unless the wasm module was built with
         // CONWAY_ALLOC_TELEMETRY (see conway-geom structures/alloc_telemetry.h).
         conwayGeom.dumpAllocTelemetry(path.basename(stepFile));

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

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

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

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