@bldrs-ai/conway 1.549.1515 → 1.553.1520

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.549.1515";
+var versionString = "Conway v1.553.1520";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -145,6 +145,27 @@ var Statistics = class {
   setGeometryMemory(value) {
     this.geometryMemory = value;
   }
+  /**
+   * Wasm linear-memory high-water mark in MB, from wasmHeapByteLength.
+   *
+   * @return {number | undefined} - wasm heap high-water, or undefined
+   */
+  getWasmHeapPeak() {
+    return this.wasmHeapPeak;
+  }
+  /**
+   * The wasm heap only ever grows, so a single reading of it IS the peak —
+   * no sampling loop and no forced GC. It is a different quantity from
+   * geometryMemory, and by a wide margin: on MB-Khaya an 8 MB live geometry
+   * payload sits under an 85 MB wasm heap, the gap being allocator overhead,
+   * fragmentation and the intermediate buffers a boolean leaves behind (see
+   * src/ifc/geometry_residency.ts). Neither substitutes for the other.
+   *
+   * @param value - wasm heap high-water in MB
+   */
+  setWasmHeapPeak(value) {
+    this.wasmHeapPeak = value;
+  }
   /**
    *
    * @return {string | undefined} - preprocessor version or undefined
@@ -278,7 +299,7 @@ var Statistics = class {
     const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
     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, ` + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
+    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, ` + 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.549.1515";
+var versionString = "Conway v1.553.1520";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -15819,6 +15819,27 @@ var Statistics = class {
   setGeometryMemory(value) {
     this.geometryMemory = value;
   }
+  /**
+   * Wasm linear-memory high-water mark in MB, from wasmHeapByteLength.
+   *
+   * @return {number | undefined} - wasm heap high-water, or undefined
+   */
+  getWasmHeapPeak() {
+    return this.wasmHeapPeak;
+  }
+  /**
+   * The wasm heap only ever grows, so a single reading of it IS the peak —
+   * no sampling loop and no forced GC. It is a different quantity from
+   * geometryMemory, and by a wide margin: on MB-Khaya an 8 MB live geometry
+   * payload sits under an 85 MB wasm heap, the gap being allocator overhead,
+   * fragmentation and the intermediate buffers a boolean leaves behind (see
+   * src/ifc/geometry_residency.ts). Neither substitutes for the other.
+   *
+   * @param value - wasm heap high-water in MB
+   */
+  setWasmHeapPeak(value) {
+    this.wasmHeapPeak = value;
+  }
   /**
    *
    * @return {string | undefined} - preprocessor version or undefined
@@ -15952,7 +15973,7 @@ var Statistics = class {
     const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
     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, ` + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
+    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, ` + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 
@@ -16324,7 +16345,10 @@ var Memory = class {
     const rss = (memoryUsage.rss / 1024 / 1024).toFixed(3);
     const heapTotal = (memoryUsage.heapTotal / 1024 / 1024).toFixed(3);
     const heapUsed = (memoryUsage.heapUsed / 1024 / 1024).toFixed(3);
-    return `Node Memory Usage: RSS ${rss} MB, Heap Total: ${heapTotal} MB, Heap Used: ${heapUsed} MB`;
+    const external = (memoryUsage.external / 1024 / 1024).toFixed(3);
+    const arrayBuffers = (memoryUsage.arrayBuffers / 1024 / 1024).toFixed(3);
+    const peakRss = (process.resourceUsage().maxRSS / 1024).toFixed(3);
+    return `Node Memory Usage: RSS ${rss} MB, Heap Total: ${heapTotal} MB, Heap Used: ${heapUsed} MB, Peak RSS: ${peakRss} MB, External: ${external} MB, ArrayBuffers: ${arrayBuffers} MB`;
   }
 };
 
@@ -27012,6 +27036,10 @@ function wasmHeapView(wasmModule, arrayType, pointer, elementCount) {
   const numBytes = elementCount * arrayType.BYTES_PER_ELEMENT;
   return new arrayType(reconcileHeapBuffer(wasmModule, address, numBytes), address, elementCount);
 }
+function wasmHeapByteLength(wasmModule) {
+  refreshHeapViews(wasmModule);
+  return currentHeapBuffer(wasmModule)?.byteLength ?? 0;
+}
 function arrayToWasmHeap(wasmModule, array) {
   const numBytes = array.length * array.BYTES_PER_ELEMENT;
   const arrayPtr = wasmModule._malloc(numBytes) >>> 0;
@@ -95450,6 +95478,10 @@ function geometryExtraction(model, limitCSGDepth = true, maxCSGDepth = 20, onPro
   const ONE_KB = 1024;
   const ONE_MB = ONE_KB * ONE_KB;
   statistics?.setGeometryMemory(conwayModel.model.geometry.calculateGeometrySize() / ONE_MB);
+  const wasmModule = conwaywasm.wasmModule;
+  if (wasmModule !== void 0) {
+    statistics?.setWasmHeapPeak(wasmHeapByteLength(wasmModule) / ONE_MB);
+  }
   const ifcProjectName = conwayModel.getIfcProjectName();
   if (ifcProjectName !== null) {
     statistics?.setProjectName(ifcProjectName);

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

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.549.1515";
+var versionString = "Conway v1.553.1520";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -16797,6 +16797,27 @@ var Statistics = class {
   setGeometryMemory(value) {
     this.geometryMemory = value;
   }
+  /**
+   * Wasm linear-memory high-water mark in MB, from wasmHeapByteLength.
+   *
+   * @return {number | undefined} - wasm heap high-water, or undefined
+   */
+  getWasmHeapPeak() {
+    return this.wasmHeapPeak;
+  }
+  /**
+   * The wasm heap only ever grows, so a single reading of it IS the peak —
+   * no sampling loop and no forced GC. It is a different quantity from
+   * geometryMemory, and by a wide margin: on MB-Khaya an 8 MB live geometry
+   * payload sits under an 85 MB wasm heap, the gap being allocator overhead,
+   * fragmentation and the intermediate buffers a boolean leaves behind (see
+   * src/ifc/geometry_residency.ts). Neither substitutes for the other.
+   *
+   * @param value - wasm heap high-water in MB
+   */
+  setWasmHeapPeak(value) {
+    this.wasmHeapPeak = value;
+  }
   /**
    *
    * @return {string | undefined} - preprocessor version or undefined
@@ -16930,7 +16951,7 @@ var Statistics = class {
     const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
     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, ` + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
+    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, ` + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 
@@ -17302,7 +17323,10 @@ var Memory = class {
     const rss = (memoryUsage.rss / 1024 / 1024).toFixed(3);
     const heapTotal = (memoryUsage.heapTotal / 1024 / 1024).toFixed(3);
     const heapUsed = (memoryUsage.heapUsed / 1024 / 1024).toFixed(3);
-    return `Node Memory Usage: RSS ${rss} MB, Heap Total: ${heapTotal} MB, Heap Used: ${heapUsed} MB`;
+    const external = (memoryUsage.external / 1024 / 1024).toFixed(3);
+    const arrayBuffers = (memoryUsage.arrayBuffers / 1024 / 1024).toFixed(3);
+    const peakRss = (process.resourceUsage().maxRSS / 1024).toFixed(3);
+    return `Node Memory Usage: RSS ${rss} MB, Heap Total: ${heapTotal} MB, Heap Used: ${heapUsed} MB, Peak RSS: ${peakRss} MB, External: ${external} MB, ArrayBuffers: ${arrayBuffers} MB`;
   }
 };
 
@@ -86173,7 +86197,7 @@ function geometryExtraction(model, limitCSGDepth = true, maxCSGDepth = 20) {
   const ONE_MB = ONE_KB * ONE_KB;
   const wasmModule = conwaywasm.wasmModule;
   if (wasmModule !== void 0) {
-    logger_default.info(`WASM heap high-water: ${(wasmHeapByteLength(wasmModule) / ONE_MB).toFixed(1)} MB`);
+    statistics?.setWasmHeapPeak(wasmHeapByteLength(wasmModule) / ONE_MB);
   }
   statistics?.setGeometryMemory(conwayModel.model.geometry.calculateGeometrySize() / ONE_MB);
   model.invalidate(true);

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.549.1515";
+var versionString = "Conway v1.553.1520";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -1059,6 +1059,27 @@ var Statistics = class {
   setGeometryMemory(value) {
     this.geometryMemory = value;
   }
+  /**
+   * Wasm linear-memory high-water mark in MB, from wasmHeapByteLength.
+   *
+   * @return {number | undefined} - wasm heap high-water, or undefined
+   */
+  getWasmHeapPeak() {
+    return this.wasmHeapPeak;
+  }
+  /**
+   * The wasm heap only ever grows, so a single reading of it IS the peak —
+   * no sampling loop and no forced GC. It is a different quantity from
+   * geometryMemory, and by a wide margin: on MB-Khaya an 8 MB live geometry
+   * payload sits under an 85 MB wasm heap, the gap being allocator overhead,
+   * fragmentation and the intermediate buffers a boolean leaves behind (see
+   * src/ifc/geometry_residency.ts). Neither substitutes for the other.
+   *
+   * @param value - wasm heap high-water in MB
+   */
+  setWasmHeapPeak(value) {
+    this.wasmHeapPeak = value;
+  }
   /**
    *
    * @return {string | undefined} - preprocessor version or undefined
@@ -1192,7 +1213,7 @@ var Statistics = class {
     const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
     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, ` + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
+    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, ` + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 

package/compiled/src/AP214E3_2010/ap214_command_line_main.js

@@ -405,12 +405,15 @@ function geometryExtraction(model, limitCSGDepth = true, maxCSGDepth = 20) {
     statistics?.setGeometryTime(executionTimeInMs);
     const ONE_KB = 1024;
     const ONE_MB = ONE_KB * ONE_KB;
+    // Recorded on the statistics rather than logged on its own line, so the one
+    // spelling of this number reaches the benchmark's `peakWasmHeapMb` column
+    // through the same load-status line as every other measurement (#552).
     // Measured through wasmHeapByteLength rather than HEAPU8.length: the
     // module's cached view can be a growth step behind the real heap (#485), and
     // a high-water figure that under-reports is worse than none.
     const wasmModule = conwaywasm.wasmModule;
     if (wasmModule !== void 0) {
-        Logger.info(`WASM heap high-water: ${(wasmHeapByteLength(wasmModule) / ONE_MB).toFixed(1)} MB`);
+        statistics?.setWasmHeapPeak(wasmHeapByteLength(wasmModule) / ONE_MB);
     }
     statistics?.setGeometryMemory(conwayModel.model.geometry.calculateGeometrySize() / (ONE_MB));
     model.invalidate(true);

package/compiled/src/AP214E3_2010/ap214_regression_main.js

@@ -9,6 +9,7 @@ import fsPromises from "fs/promises";
 import path from "path";
 import crypto from "crypto";
 import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+import { wasmHeapByteLength } from "../core/wasm_heap.js";
 import Logger from "../logging/logger.js";
 import Environment from "../utilities/environment.js";
 import { ExtractResult } from "../core/shared_constants.js";
@@ -35,22 +36,40 @@ function csvSafeString(from) {
 // Bytes per megabyte for memory-stat formatting in the perf CSV.
 // eslint-disable-next-line no-magic-numbers
 const BYTES_PER_MB = 1024 * 1024;
+// Kilobytes per megabyte, for resourceUsage().maxRSS which reports kB.
+// eslint-disable-next-line no-magic-numbers
+const KB_PER_MB = 1024;
 // Fixed-point precision for perf MB values.
 // eslint-disable-next-line no-magic-numbers
 const PERF_MB_PRECISION = 2;
+/** Placeholder for a column this row has no measurement for. */
+const UNMEASURED = "N/A";
 /**
  * Write a single-row per-file perf CSV at the given path, matching the
  * column layout of the IFC regression child so the batch aggregator can
  * merge STEP and IFC rows into one perf CSV. No-op when perfPath is empty.
  *
+ * `peakRssMb` is the process high-water mark; `rssMb`, `heapUsedMb`,
+ * `heapTotalMb`, `externalMb` and `arrayBuffersMb` are single instants
+ * sampled at write time, and `geometryMemoryMb` is conway's own vertex+index
+ * payload rather than a process metric. `arrayBuffersMb` is a subset of
+ * `externalMb`, and neither sees the wasm heap. See the fuller
+ * column-by-column note on the IFC child's copy of this function
+ * (`src/ifc/ifc_regression_main.ts`), which is the writer these columns have
+ * to stay identical to.
+ *
  * @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 geometryMemoryBytes Geometry payload conway allocated, in bytes, or
+ * undefined where no geometry was extracted (written as N/A).
+ * @param wasmHeapBytes Wasm linear-memory high-water in bytes, or undefined
+ * where the module was never brought up (written as N/A).
  */
-async function writePerfCsvIfRequested(perfPath, stepFile, status, parseTimeMs, geometryTimeMs, totalTimeMs) {
+async function writePerfCsvIfRequested(perfPath, stepFile, status, parseTimeMs, geometryTimeMs, totalTimeMs, geometryMemoryBytes, wasmHeapBytes) {
     if (perfPath.length === 0) {
         return;
     }
@@ -58,10 +77,23 @@ async function writePerfCsvIfRequested(perfPath, stepFile, status, parseTimeMs,
     const rssMb = (mem.rss / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
     const heapUsedMb = (mem.heapUsed / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
     const heapTotalMb = (mem.heapTotal / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
+    const externalMb = (mem.external / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
+    const arrayBuffersMb = (mem.arrayBuffers / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
+    // maxRSS is reported in kilobytes, unlike memoryUsage() which is in bytes.
+    const peakRssMb = (process.resourceUsage().maxRSS / KB_PER_MB).toFixed(PERF_MB_PRECISION);
+    const geometryMemoryMb = geometryMemoryBytes !== void 0 ?
+        (geometryMemoryBytes / BYTES_PER_MB).toFixed(PERF_MB_PRECISION) :
+        UNMEASURED;
+    const peakWasmHeapMb = wasmHeapBytes !== void 0 ?
+        (wasmHeapBytes / BYTES_PER_MB).toFixed(PERF_MB_PRECISION) :
+        UNMEASURED;
     const fileName = csvSafeString(path.basename(stepFile));
-    const header = "file,status,parseTimeMs,geometryTimeMs,totalTimeMs,rssMb,heapUsedMb,heapTotalMb\n";
+    const header = "file,status,parseTimeMs,geometryTimeMs,totalTimeMs,geometryMemoryMb," +
+        "peakWasmHeapMb,rssMb,peakRssMb,heapUsedMb,heapTotalMb,externalMb," +
+        "arrayBuffersMb\n";
     const row = `${fileName},${status},${parseTimeMs},${geometryTimeMs},${totalTimeMs},` +
-        `${rssMb},${heapUsedMb},${heapTotalMb}\n`;
+        `${geometryMemoryMb},${peakWasmHeapMb},${rssMb},${peakRssMb},` +
+        `${heapUsedMb},${heapTotalMb},${externalMb},${arrayBuffersMb}\n`;
     try {
         await fsPromises.writeFile(perfPath, header + row);
     }
@@ -206,7 +238,18 @@ function doWork() {
         const geometryTimeMs = geomEndMs - geomStartMs;
         const totalTimeMs = geomEndMs - parseStartMs;
         const perfStatus = extraction === void 0 ? "FAIL" : "OK";
-        await writePerfCsvIfRequested(perfPath, stepFile, perfStatus, parseTimeMs, geometryTimeMs, totalTimeMs);
+        // Sized before anything downstream can release meshes, and only on
+        // the OK path: a failed extraction leaves a partial cache whose size
+        // is not this model's geometry footprint.
+        const geometryMemoryBytes = extraction !== void 0 ?
+            model.geometry.calculateGeometrySize() : void 0;
+        // The heap is grow-only, so this is the run's high-water mark even
+        // though it is read once, after the fact. conwayGeom is the engine
+        // every extraction in this process runs against.
+        const wasmModule = conwayGeom.wasmModule;
+        const wasmHeapBytes = wasmModule !== void 0 ?
+            wasmHeapByteLength(wasmModule) : void 0;
+        await writePerfCsvIfRequested(perfPath, stepFile, perfStatus, parseTimeMs, geometryTimeMs, totalTimeMs, geometryMemoryBytes, wasmHeapBytes);
         // 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/core/wasm_heap.d.ts

@@ -125,10 +125,11 @@ export declare function wasmHeapView<TArray>(wasmModule: WasmHeapModule, arrayTy
  * trade. Do not put it in a loop.
  *
  * That the refresh cannot throw (see refreshHeapViews) matters more here than
- * at the other call site: this figure's only consumer is the AP214 CLI's
- * high-water log line, so an embind failure escaping would abort an otherwise
- * complete extraction from a log statement. A lagging number is the right
- * answer there.
+ * at the other call site: every consumer of this figure is reporting — the
+ * loaders' and CLIs' high-water statistic, and the regression children's
+ * `peakWasmHeapMb` perf column (#552) — so an embind failure escaping would
+ * abort an otherwise complete extraction from a measurement. A lagging number
+ * is the right answer there.
  *
  * @param wasmModule The module to measure.
  * @return {number} The heap's size in bytes, or 0 if it has no heap yet.

package/compiled/src/core/wasm_heap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wasm_heap.d.ts","sourceRoot":"","sources":["../../../src/core/wasm_heap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAKH;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAE,KAAK,EAAE,MAAM,GAAI,MAAM,CAAA;IAChC,KAAK,CAAE,OAAO,EAAE,MAAM,GAAI,IAAI,CAAA;IAC9B,MAAM,EAAE,UAAU,CAAA;IAElB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAA;IAE9B;;;;OAIG;IACH,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;KAAE,CAAA;IAEjD;;;OAGG;IACH,YAAY,CAAC,EAAE,UAAU;QAAE,SAAS,CAAE,KAAK,EAAE,MAAM,GAAI,IAAI,CAAC;QAAC,MAAM,IAAI,IAAI,CAAA;KAAE,CAAA;CAC9E;AAED,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,YAAY,GAAG,WAAW,CAAA;AAMrE;;;GAGG;AACH,MAAM,WAAW,wBAAwB,CAAE,MAAM;IAC/C,KAAM,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAI,MAAM,CAAA;IAC3E,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CACnC;AA6MD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAE,MAAM,EAChC,UAAU,EAAE,cAAc,EAC1B,SAAS,EAAE,wBAAwB,CAAE,MAAM,CAAE,EAC7C,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GAAI,MAAM,CASjC;AAGD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAAE,UAAU,EAAE,cAAc,GAAI,MAAM,CAKvE;AAGD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC3B,UAAU,EAAE,cAAc,EAAE,KAAK,EAAE,aAAa,GAAI,MAAM,CA8C7D;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC5B,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,SAAS,aAAa,EAAE,GAAI,MAAM,EAAE,CAqB/C;AAGD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAE,OAAO,EAAE,MAAM,IAAI,GAAI,IAAI,CAW1D;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAG,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,GAAI,CAAC,CAiBtE;AAGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CACnB,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAI,IAAI,CAkBlE"}
+{"version":3,"file":"wasm_heap.d.ts","sourceRoot":"","sources":["../../../src/core/wasm_heap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAKH;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAE,KAAK,EAAE,MAAM,GAAI,MAAM,CAAA;IAChC,KAAK,CAAE,OAAO,EAAE,MAAM,GAAI,IAAI,CAAA;IAC9B,MAAM,EAAE,UAAU,CAAA;IAElB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAA;IAE9B;;;;OAIG;IACH,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;KAAE,CAAA;IAEjD;;;OAGG;IACH,YAAY,CAAC,EAAE,UAAU;QAAE,SAAS,CAAE,KAAK,EAAE,MAAM,GAAI,IAAI,CAAC;QAAC,MAAM,IAAI,IAAI,CAAA;KAAE,CAAA;CAC9E;AAED,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,YAAY,GAAG,WAAW,CAAA;AAMrE;;;GAGG;AACH,MAAM,WAAW,wBAAwB,CAAE,MAAM;IAC/C,KAAM,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAI,MAAM,CAAA;IAC3E,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CACnC;AA6MD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAE,MAAM,EAChC,UAAU,EAAE,cAAc,EAC1B,SAAS,EAAE,wBAAwB,CAAE,MAAM,CAAE,EAC7C,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GAAI,MAAM,CASjC;AAGD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAE,UAAU,EAAE,cAAc,GAAI,MAAM,CAKvE;AAGD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC3B,UAAU,EAAE,cAAc,EAAE,KAAK,EAAE,aAAa,GAAI,MAAM,CA8C7D;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC5B,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,SAAS,aAAa,EAAE,GAAI,MAAM,EAAE,CAqB/C;AAGD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAE,OAAO,EAAE,MAAM,IAAI,GAAI,IAAI,CAW1D;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAG,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,GAAI,CAAC,CAiBtE;AAGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CACnB,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAI,IAAI,CAkBlE"}

package/compiled/src/core/wasm_heap.js

@@ -250,10 +250,11 @@ export function wasmHeapView(wasmModule, arrayType, pointer, elementCount) {
  * trade. Do not put it in a loop.
  *
  * That the refresh cannot throw (see refreshHeapViews) matters more here than
- * at the other call site: this figure's only consumer is the AP214 CLI's
- * high-water log line, so an embind failure escaping would abort an otherwise
- * complete extraction from a log statement. A lagging number is the right
- * answer there.
+ * at the other call site: every consumer of this figure is reporting — the
+ * loaders' and CLIs' high-water statistic, and the regression children's
+ * `peakWasmHeapMb` perf column (#552) — so an embind failure escaping would
+ * abort an otherwise complete extraction from a measurement. A lagging number
+ * is the right answer there.
  *
  * @param wasmModule The module to measure.
  * @return {number} The heap's size in bytes, or 0 if it has no heap yet.

package/compiled/src/ifc/ifc_command_line_main.js

@@ -9,6 +9,7 @@ import { IfcGeometryExtraction } from "./ifc_geometry_extraction.js";
 import { IfcPropertyExtraction } from "./ifc_property_extraction.js";
 import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
 import GeometryConvertor from "../core/geometry_convertor.js";
+import { wasmHeapByteLength } from "../core/wasm_heap.js";
 import GeometryAggregator from "../core/geometry_aggregator.js";
 import Logger, { LogLevel } from "../logging/logger.js";
 import { ProgressTracker } from "../core/progress.js";
@@ -545,6 +546,17 @@ function geometryExtraction(model, limitCSGDepth = true, maxCSGDepth = 20, onPro
     const ONE_KB = 1024;
     const ONE_MB = ONE_KB * ONE_KB;
     statistics?.setGeometryMemory(conwayModel.model.geometry.calculateGeometrySize() / (ONE_MB));
+    // The wasm heap, which nothing else here can see: geometryMemory above is
+    // the vertex+index payload only, and the JS-side heap/external figures do
+    // not include emscripten's linear memory at all. Grow-only, so one reading
+    // is the high-water mark. Measured through wasmHeapByteLength rather than
+    // HEAPU8.length: the module's cached view can be a growth step behind the
+    // real heap (#485), and a high-water figure that under-reports is worse
+    // than none.
+    const wasmModule = conwaywasm.wasmModule;
+    if (wasmModule !== void 0) {
+        statistics?.setWasmHeapPeak(wasmHeapByteLength(wasmModule) / ONE_MB);
+    }
     const ifcProjectName = conwayModel.getIfcProjectName();
     if (ifcProjectName !== null) {
         statistics?.setProjectName(ifcProjectName);

package/compiled/src/ifc/ifc_regression_main.js

@@ -14,6 +14,7 @@ import fsPromises from "fs/promises";
 import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
 import { IfcBooleanResult } from "./ifc4_gen/index.js";
 import { MemoizationCapture, RegressionCaptureState } from "../core/regression_capture_state.js";
+import { wasmHeapByteLength } from "../core/wasm_heap.js";
 import { materialHashes } from "./ifc_material_cache_node.js";
 import { dumpGeometryOBJs, geometryHashes } from "./ifc_model_geometry_node.js";
 import { curveHashes, dumpCurveOBJs } from "./ifc_model_curves_node.js";
@@ -39,28 +40,93 @@ function csvSafeString(from) {
 // Bytes per megabyte for memory-stat formatting in the perf CSV.
 // eslint-disable-next-line no-magic-numbers
 const BYTES_PER_MB = 1024 * 1024;
+// Kilobytes per megabyte, for resourceUsage().maxRSS which reports kB.
+// eslint-disable-next-line no-magic-numbers
+const KB_PER_MB = 1024;
 // Fixed-point precision for perf MB values.
 // eslint-disable-next-line no-magic-numbers
 const PERF_MB_PRECISION = 2;
+/** Placeholder for a column this row has no measurement for. */
+const UNMEASURED = "N/A";
 /**
  * Write a single-row per-file perf CSV at the given path. Memory snapshot is
  * taken at call time; for the OK path this is right after geometry extraction
  * — close to peak. No-op when perfPath is empty.
  *
- * Memory semantics: `rssMb` includes the conway-geom WASM heap (mmap'd into
- * the process) and is the load-bearing memory metric for geometry work.
+ * WHICH COLUMNS ARE PEAK AND WHICH ARE INSTANTS — they are not comparable and
+ * the difference is large (conway#552):
+ *
+ *   peakRssMb        PEAK. The kernel's high-water mark for this process
+ *                    (`resourceUsage().maxRSS`, kB), i.e. the number that
+ *                    decides whether a browser tab or a runner survives the
+ *                    load. Free to read and perturbs nothing.
+ *   rssMb            INSTANT. One `memoryUsage()` sample at write time. A run
+ *                    that transiently hit 5 GB and settled to 1 GB reports
+ *                    1 GB here and 5 GB in peakRssMb.
+ *   heapUsedMb       INSTANT, and *not* live set: it is live data plus
+ *                    whatever garbage GC has not collected yet, so it moves
+ *                    with GC timing. Measuring SKYLARK250 this way gives
+ *                    2547 MB where the same run's live heap after two forced
+ *                    full GCs is 981 MB. A live-heap column would need forced
+ *                    GC, which wrecks the timing columns, so it is not here.
+ *   heapTotalMb      INSTANT. V8's reserved heap.
+ *   externalMb       INSTANT. Off-heap bytes V8 knows about, which heapUsed
+ *                    does not include and which are a real part of the
+ *                    footprint: on MB-Khaya (31 MB IFC) `readFileSync` alone
+ *                    moves this 1.7 -> 33.1 MB while heapUsed does not move.
+ *   arrayBuffersMb   INSTANT, and a SUBSET of externalMb — the ArrayBuffer
+ *                    share of it, which is where the source buffer and the
+ *                    parse structures land (31.5 of that 33.1 MB).
+ *   geometryMemoryMb Not a process metric at all: the vertex+index PAYLOAD
+ *                    conway itself allocated for this model, summed by
+ *                    `calculateGeometrySize()` — what a consumer would copy
+ *                    out. Unlike rss/heap it excludes everything the harness
+ *                    happens to be holding, and unlike peakWasmHeapMb it
+ *                    excludes everything the allocator is holding.
+ *   peakWasmHeapMb   PEAK, and the only column that sees conway's native
+ *                    memory. Emscripten's linear memory grows and never
+ *                    shrinks, so one reading of `wasmHeapByteLength` IS the
+ *                    high-water mark — nothing to sample, nothing perturbed.
+ *                    Read through that helper rather than `HEAPU8.length`,
+ *                    whose cached view can be a growth step behind the real
+ *                    heap (#485); a high-water figure that under-reports is
+ *                    worse than none. This is NOT geometryMemoryMb: it
+ *                    includes allocator overhead, fragmentation and the
+ *                    intermediate buffers a boolean leaves behind, which on
+ *                    MB-Khaya is an 85 MB heap over an 8 MB live payload.
+ *
+ * There is deliberately no `heapUsed + external` total. It looks like a
+ * portable stand-in for RSS and is not one: on that same model it reads
+ * 284 MB against an RSS of 510 MB after geometry, and wasm init alone adds
+ * ~65 MB of RSS while moving `external` by under 2 MB. Emscripten's heap is
+ * structurally invisible to JS-side accounting, so such a total would be
+ * blind to exactly the memory this bench exists to track. peakRssMb is the
+ * headline.
+ *
+ * `rssMb` and `peakRssMb` include the conway-geom WASM heap (mmap'd into the
+ * process) and are the load-bearing memory metrics for geometry work.
  * `heapUsedMb` / `heapTotalMb` are V8-only — useful for tracking JS-side
  * allocation pressure but they exclude WASM-side buffers. Expect a large
  * gap between rss and heap on geometry-heavy models.
  *
+ * The column list here is shared with the AP214 regression child
+ * (`ap214_regression_main.ts`): `aggregatePerfCsvs` in
+ * `ifc_regression_batch_main.ts` keeps the header of whichever per-file CSV it
+ * reads first and concatenates the rest as rows, so a mixed IFC/STEP corpus
+ * mislabels every column if the two writers drift apart.
+ *
  * @param perfPath Path to write the CSV to. Empty string disables.
  * @param ifcFile Source IFC 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 geometryMemoryBytes Geometry payload conway allocated, in bytes, or
+ * undefined where no geometry was extracted (written as N/A).
+ * @param wasmHeapBytes Wasm linear-memory high-water in bytes, or undefined
+ * where the module was never brought up (written as N/A).
  */
-async function writePerfCsvIfRequested(perfPath, ifcFile, status, parseTimeMs, geometryTimeMs, totalTimeMs) {
+async function writePerfCsvIfRequested(perfPath, ifcFile, status, parseTimeMs, geometryTimeMs, totalTimeMs, geometryMemoryBytes, wasmHeapBytes) {
     if (perfPath.length === 0) {
         return;
     }
@@ -68,10 +134,23 @@ async function writePerfCsvIfRequested(perfPath, ifcFile, status, parseTimeMs, g
     const rssMb = (mem.rss / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
     const heapUsedMb = (mem.heapUsed / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
     const heapTotalMb = (mem.heapTotal / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
+    const externalMb = (mem.external / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
+    const arrayBuffersMb = (mem.arrayBuffers / BYTES_PER_MB).toFixed(PERF_MB_PRECISION);
+    // maxRSS is reported in kilobytes, unlike memoryUsage() which is in bytes.
+    const peakRssMb = (process.resourceUsage().maxRSS / KB_PER_MB).toFixed(PERF_MB_PRECISION);
+    const geometryMemoryMb = geometryMemoryBytes !== void 0 ?
+        (geometryMemoryBytes / BYTES_PER_MB).toFixed(PERF_MB_PRECISION) :
+        UNMEASURED;
+    const peakWasmHeapMb = wasmHeapBytes !== void 0 ?
+        (wasmHeapBytes / BYTES_PER_MB).toFixed(PERF_MB_PRECISION) :
+        UNMEASURED;
     const fileName = csvSafeString(path.basename(ifcFile));
-    const header = "file,status,parseTimeMs,geometryTimeMs,totalTimeMs,rssMb,heapUsedMb,heapTotalMb\n";
+    const header = "file,status,parseTimeMs,geometryTimeMs,totalTimeMs,geometryMemoryMb," +
+        "peakWasmHeapMb,rssMb,peakRssMb,heapUsedMb,heapTotalMb,externalMb," +
+        "arrayBuffersMb\n";
     const row = `${fileName},${status},${parseTimeMs},${geometryTimeMs},${totalTimeMs},` +
-        `${rssMb},${heapUsedMb},${heapTotalMb}\n`;
+        `${geometryMemoryMb},${peakWasmHeapMb},${rssMb},${peakRssMb},` +
+        `${heapUsedMb},${heapTotalMb},${externalMb},${arrayBuffersMb}\n`;
     try {
         await fsPromises.writeFile(perfPath, header + row);
     }
@@ -220,7 +299,19 @@ function doWork() {
         const geometryTimeMs = geomEndMs - geomStartMs;
         const totalTimeMs = geomEndMs - parseStartMs;
         const perfStatus = result === void 0 ? "FAIL" : "OK";
-        await writePerfCsvIfRequested(perfPath, ifcFile, perfStatus, parseTimeMs, geometryTimeMs, totalTimeMs);
+        // Sized before anything downstream can release meshes, and only on
+        // the OK path: a failed extraction leaves a partial cache whose size
+        // is not this model's geometry footprint.
+        const geometryMemoryBytes = result !== void 0 ?
+            model.geometry.calculateGeometrySize() : void 0;
+        // The heap is grow-only, so this is the run's high-water mark even
+        // though it is read once, after the fact. geometryExtraction hands
+        // back the engine it brought up; there is no heap to measure when
+        // it failed before that.
+        const wasmModule = result?.[1].wasmModule;
+        const wasmHeapBytes = wasmModule !== void 0 ?
+            wasmHeapByteLength(wasmModule) : void 0;
+        await writePerfCsvIfRequested(perfPath, ifcFile, perfStatus, parseTimeMs, geometryTimeMs, totalTimeMs, geometryMemoryBytes, wasmHeapBytes);
         // 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(ifcFile));

package/compiled/src/loaders/conway_model_loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conway_model_loader.d.ts","sourceRoot":"","sources":["../../../src/loaders/conway_model_loader.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,gBAAgB,EAAmB,MAAM,kBAAkB,CAAA;AACpE,OAAO,EAAE,SAAS,EAAmB,MAAM,sBAAsB,CAAA;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAerC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAE/B;;;OAGG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAA;IAE7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAE1B,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAE3B;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAE,IAAI,EAAE,SAAS,KAAM,IAAI,CAAA;CAC1C;AAED;;;;GAIG;AACH,qBAAa,iBAAiB;IAE5B;;;;;;;;;OASG;WACiB,kBAAkB,CAClC,IAAI,EAAE,UAAU,EAChB,aAAa,GAAE,OAAc,EAC7B,eAAe,GAAE,MAAW,EAC5B,OAAO,GAAE,MAAU,EACnB,OAAO,CAAC,EAAE,gBAAgB,GAAI,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CA0c1D"}
+{"version":3,"file":"conway_model_loader.d.ts","sourceRoot":"","sources":["../../../src/loaders/conway_model_loader.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,gBAAgB,EAAmB,MAAM,kBAAkB,CAAA;AACpE,OAAO,EAAE,SAAS,EAAmB,MAAM,sBAAsB,CAAA;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AA4CrC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAE/B;;;OAGG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAA;IAE7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAE1B,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAE3B;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAE,IAAI,EAAE,SAAS,KAAM,IAAI,CAAA;CAC1C;AAED;;;;GAIG;AACH,qBAAa,iBAAiB;IAE5B;;;;;;;;;OASG;WACiB,kBAAkB,CAClC,IAAI,EAAE,UAAU,EAChB,aAAa,GAAE,OAAc,EAC7B,eAAe,GAAE,MAAW,EAC5B,OAAO,GAAE,MAAU,EACnB,OAAO,CAAC,EAAE,gBAAgB,GAAI,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CA8c1D"}

package/compiled/src/loaders/conway_model_loader.js

@@ -13,8 +13,32 @@ import Memory from "../memory/memory.js";
 import ParsingBuffer from "../parsing/parsing_buffer.js";
 import { ParseResult } from "../step/parsing/step_parser.js";
 import { extractModelInfo, parseFileHeader } from "./loading_utilities.js";
+import { wasmHeapByteLength } from "../core/wasm_heap.js";
 const ONE_KB = 1024;
 const ONE_MB = ONE_KB * ONE_KB;
+/**
+ * Record the wasm heap's high-water mark on the run's statistics.
+ *
+ * The wasm heap only grows, so one reading of it is already the peak — there
+ * is nothing to sample and nothing to perturb. This is the only column that
+ * sees conway's native memory at all: `heapUsed`/`external` cannot (wasm init
+ * alone moves RSS by ~65 MB while moving `external` by under 2 MB), and
+ * `geometryMemory` is the vertex+index payload only, which on MB-Khaya is
+ * 8 MB live under an 85 MB wasm heap.
+ *
+ * Measured through wasmHeapByteLength rather than HEAPU8.length: the module's
+ * cached view can be a growth step behind the real heap (#485), and a
+ * high-water figure that under-reports is worse than none.
+ *
+ * @param statistics The run's statistics.
+ * @param conwayWasm The geometry engine whose heap to measure.
+ */
+function recordWasmHeapPeak(statistics, conwayWasm) {
+    const wasmModule = conwayWasm.wasmModule;
+    if (wasmModule !== void 0) {
+        statistics.setWasmHeapPeak(wasmHeapByteLength(wasmModule) / ONE_MB);
+    }
+}
 /**
  * Static class for loading a model from a Uint 8 array...
  *
@@ -134,6 +158,7 @@ export class ConwayModelLoader {
                     tracker?.endPhase();
                     statistics.setGeometryTime(executionTimeInMs);
                     statistics.setGeometryMemory(conwayModel.model.geometry.calculateGeometrySize() / (ONE_MB));
+                    recordWasmHeapPeak(statistics, conwayWasm);
                     statistics.setGeometryTypeCounts(conwayModel.geometryTypeCounts);
                     model.invalidate(true);
                     if (extractionResult !== ExtractResult.COMPLETE) {
@@ -264,6 +289,7 @@ export class ConwayModelLoader {
                     tracker?.endPhase();
                     statistics.setGeometryTime(executionTimeInMs);
                     statistics.setGeometryMemory(conwayModel.model.geometry.calculateGeometrySize() / (ONE_MB));
+                    recordWasmHeapPeak(statistics, conwayWasm);
                     const ifcProjectName = conwayModel.getIfcProjectName();
                     if (ifcProjectName !== null) {
                         statistics.setProjectName(ifcProjectName);

package/compiled/src/memory/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/memory/memory.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IAEX,UAAU,WAAW;QACjB,MAAM,CAAC,EAAE;YACL,eAAe,EAAE,MAAM,CAAA;YACvB,eAAe,EAAE,MAAM,CAAA;YACvB,cAAc,EAAE,MAAM,CAAA;SACzB,CAAA;KACJ;CACJ;AAKD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB;;;OAGG;IACH,MAAM,CAAC,gBAAgB,IAAI,MAAM;IAiBjC;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,IAAI,MAAM,GAAG,SAAS;IAiBvC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAYjC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;CAY/B"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/memory/memory.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IAEX,UAAU,WAAW;QACjB,MAAM,CAAC,EAAE;YACL,eAAe,EAAE,MAAM,CAAA;YACvB,eAAe,EAAE,MAAM,CAAA;YACvB,cAAc,EAAE,MAAM,CAAA;SACzB,CAAA;KACJ;CACJ;AAKD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB;;;OAGG;IACH,MAAM,CAAC,gBAAgB,IAAI,MAAM;IAiBjC;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,IAAI,MAAM,GAAG,SAAS;IAiBvC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAYjC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;CAoC/B"}