@bldrs-ai/conway 1.549.1515 → 1.556.1524

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.556.1524";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -45,6 +45,10 @@ var BlendMode;
 })(BlendMode || (BlendMode = {}));
 
 // compiled/src/statistics/statistics.js
+var RETAINED_MB_PRECISION = 3;
+function formatRetained(value) {
+  return value !== void 0 ? `${value.toFixed(RETAINED_MB_PRECISION)} MB` : "N/A";
+}
 var Statistics = class {
   // Getters and setters
   /**
@@ -145,6 +149,84 @@ 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;
+  }
+  /**
+   * RSS still held after the model was torn down, over a settled pre-load
+   * baseline (conway#554).
+   *
+   * @return {number | undefined} - retained RSS in MB, or undefined where the
+   * settle could not run
+   */
+  getRetainedRss() {
+    return this.retainedRss;
+  }
+  /**
+   * Both samples behind this figure are settled (`gc(); await setImmediate();
+   * gc()`) and both sit outside the timed region, so recording it costs the
+   * timing columns nothing. Leave it undefined rather than passing an
+   * unsettled difference: that is GC-timing noise, and it would be read as a
+   * leak signal.
+   *
+   * @param value - retained RSS in MB, signed
+   */
+  setRetainedRss(value) {
+    this.retainedRss = value;
+  }
+  /**
+   * V8 live heap still held after teardown, over the settled pre-load
+   * baseline (conway#554).
+   *
+   * @return {number | undefined} - retained heapUsed in MB, or undefined
+   * where the settle could not run
+   */
+  getRetainedHeapUsed() {
+    return this.retainedHeapUsed;
+  }
+  /**
+   *
+   * @param value - retained heapUsed in MB, signed
+   */
+  setRetainedHeapUsed(value) {
+    this.retainedHeapUsed = value;
+  }
+  /**
+   * Off-heap bytes still held after teardown, over the settled pre-load
+   * baseline (conway#554). This is where a released source buffer or parse
+   * structure that is still pinned shows up; heapUsed cannot see them.
+   *
+   * @return {number | undefined} - retained external in MB, or undefined
+   * where the settle could not run
+   */
+  getRetainedExternal() {
+    return this.retainedExternal;
+  }
+  /**
+   *
+   * @param value - retained external in MB, signed
+   */
+  setRetainedExternal(value) {
+    this.retainedExternal = value;
+  }
   /**
    *
    * @return {string | undefined} - preprocessor version or undefined
@@ -276,9 +358,10 @@ var Statistics = class {
       versionStr = "Version not defined";
     }
     const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
+    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, ` + 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, ` + 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.549.1515";
+var versionString = "Conway v1.556.1524";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -15719,6 +15719,10 @@ function toAlphaMode(wasmModule, blendMode) {
 }
 
 // compiled/src/statistics/statistics.js
+var RETAINED_MB_PRECISION = 3;
+function formatRetained(value) {
+  return value !== void 0 ? `${value.toFixed(RETAINED_MB_PRECISION)} MB` : "N/A";
+}
 var Statistics = class {
   // Getters and setters
   /**
@@ -15819,6 +15823,84 @@ 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;
+  }
+  /**
+   * RSS still held after the model was torn down, over a settled pre-load
+   * baseline (conway#554).
+   *
+   * @return {number | undefined} - retained RSS in MB, or undefined where the
+   * settle could not run
+   */
+  getRetainedRss() {
+    return this.retainedRss;
+  }
+  /**
+   * Both samples behind this figure are settled (`gc(); await setImmediate();
+   * gc()`) and both sit outside the timed region, so recording it costs the
+   * timing columns nothing. Leave it undefined rather than passing an
+   * unsettled difference: that is GC-timing noise, and it would be read as a
+   * leak signal.
+   *
+   * @param value - retained RSS in MB, signed
+   */
+  setRetainedRss(value) {
+    this.retainedRss = value;
+  }
+  /**
+   * V8 live heap still held after teardown, over the settled pre-load
+   * baseline (conway#554).
+   *
+   * @return {number | undefined} - retained heapUsed in MB, or undefined
+   * where the settle could not run
+   */
+  getRetainedHeapUsed() {
+    return this.retainedHeapUsed;
+  }
+  /**
+   *
+   * @param value - retained heapUsed in MB, signed
+   */
+  setRetainedHeapUsed(value) {
+    this.retainedHeapUsed = value;
+  }
+  /**
+   * Off-heap bytes still held after teardown, over the settled pre-load
+   * baseline (conway#554). This is where a released source buffer or parse
+   * structure that is still pinned shows up; heapUsed cannot see them.
+   *
+   * @return {number | undefined} - retained external in MB, or undefined
+   * where the settle could not run
+   */
+  getRetainedExternal() {
+    return this.retainedExternal;
+  }
+  /**
+   *
+   * @param value - retained external in MB, signed
+   */
+  setRetainedExternal(value) {
+    this.retainedExternal = value;
+  }
   /**
    *
    * @return {string | undefined} - preprocessor version or undefined
@@ -15950,9 +16032,10 @@ var Statistics = class {
       versionStr = "Version not defined";
     }
     const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
+    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, ` + 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, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 
@@ -16324,7 +16407,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 +27098,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 +95540,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.556.1524";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -16697,6 +16697,10 @@ function toAlphaMode(wasmModule, blendMode) {
 }
 
 // compiled/src/statistics/statistics.js
+var RETAINED_MB_PRECISION = 3;
+function formatRetained(value) {
+  return value !== void 0 ? `${value.toFixed(RETAINED_MB_PRECISION)} MB` : "N/A";
+}
 var Statistics = class {
   // Getters and setters
   /**
@@ -16797,6 +16801,84 @@ 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;
+  }
+  /**
+   * RSS still held after the model was torn down, over a settled pre-load
+   * baseline (conway#554).
+   *
+   * @return {number | undefined} - retained RSS in MB, or undefined where the
+   * settle could not run
+   */
+  getRetainedRss() {
+    return this.retainedRss;
+  }
+  /**
+   * Both samples behind this figure are settled (`gc(); await setImmediate();
+   * gc()`) and both sit outside the timed region, so recording it costs the
+   * timing columns nothing. Leave it undefined rather than passing an
+   * unsettled difference: that is GC-timing noise, and it would be read as a
+   * leak signal.
+   *
+   * @param value - retained RSS in MB, signed
+   */
+  setRetainedRss(value) {
+    this.retainedRss = value;
+  }
+  /**
+   * V8 live heap still held after teardown, over the settled pre-load
+   * baseline (conway#554).
+   *
+   * @return {number | undefined} - retained heapUsed in MB, or undefined
+   * where the settle could not run
+   */
+  getRetainedHeapUsed() {
+    return this.retainedHeapUsed;
+  }
+  /**
+   *
+   * @param value - retained heapUsed in MB, signed
+   */
+  setRetainedHeapUsed(value) {
+    this.retainedHeapUsed = value;
+  }
+  /**
+   * Off-heap bytes still held after teardown, over the settled pre-load
+   * baseline (conway#554). This is where a released source buffer or parse
+   * structure that is still pinned shows up; heapUsed cannot see them.
+   *
+   * @return {number | undefined} - retained external in MB, or undefined
+   * where the settle could not run
+   */
+  getRetainedExternal() {
+    return this.retainedExternal;
+  }
+  /**
+   *
+   * @param value - retained external in MB, signed
+   */
+  setRetainedExternal(value) {
+    this.retainedExternal = value;
+  }
   /**
    *
    * @return {string | undefined} - preprocessor version or undefined
@@ -16928,9 +17010,10 @@ var Statistics = class {
       versionStr = "Version not defined";
     }
     const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
+    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, ` + 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, ` + retained + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 
@@ -17302,7 +17385,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 +86259,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.556.1524";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -959,6 +959,10 @@ var BlendMode;
 })(BlendMode || (BlendMode = {}));
 
 // compiled/src/statistics/statistics.js
+var RETAINED_MB_PRECISION = 3;
+function formatRetained(value) {
+  return value !== void 0 ? `${value.toFixed(RETAINED_MB_PRECISION)} MB` : "N/A";
+}
 var Statistics = class {
   // Getters and setters
   /**
@@ -1059,6 +1063,84 @@ 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;
+  }
+  /**
+   * RSS still held after the model was torn down, over a settled pre-load
+   * baseline (conway#554).
+   *
+   * @return {number | undefined} - retained RSS in MB, or undefined where the
+   * settle could not run
+   */
+  getRetainedRss() {
+    return this.retainedRss;
+  }
+  /**
+   * Both samples behind this figure are settled (`gc(); await setImmediate();
+   * gc()`) and both sit outside the timed region, so recording it costs the
+   * timing columns nothing. Leave it undefined rather than passing an
+   * unsettled difference: that is GC-timing noise, and it would be read as a
+   * leak signal.
+   *
+   * @param value - retained RSS in MB, signed
+   */
+  setRetainedRss(value) {
+    this.retainedRss = value;
+  }
+  /**
+   * V8 live heap still held after teardown, over the settled pre-load
+   * baseline (conway#554).
+   *
+   * @return {number | undefined} - retained heapUsed in MB, or undefined
+   * where the settle could not run
+   */
+  getRetainedHeapUsed() {
+    return this.retainedHeapUsed;
+  }
+  /**
+   *
+   * @param value - retained heapUsed in MB, signed
+   */
+  setRetainedHeapUsed(value) {
+    this.retainedHeapUsed = value;
+  }
+  /**
+   * Off-heap bytes still held after teardown, over the settled pre-load
+   * baseline (conway#554). This is where a released source buffer or parse
+   * structure that is still pinned shows up; heapUsed cannot see them.
+   *
+   * @return {number | undefined} - retained external in MB, or undefined
+   * where the settle could not run
+   */
+  getRetainedExternal() {
+    return this.retainedExternal;
+  }
+  /**
+   *
+   * @param value - retained external in MB, signed
+   */
+  setRetainedExternal(value) {
+    this.retainedExternal = value;
+  }
   /**
    *
    * @return {string | undefined} - preprocessor version or undefined
@@ -1190,9 +1272,10 @@ var Statistics = class {
       versionStr = "Version not defined";
     }
     const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
+    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, ` + 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, ` + 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

@@ -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);