@bldrs-ai/conway 1.379.1191 → 1.381.1195

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 Web-Ifc Shim v1.379.1191";
+var versionString = "Conway v1.381.1195";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -187,6 +187,52 @@ var Statistics = class {
   setMemoryStatistics(value) {
     this.memoryStatistics = value;
   }
+  /**
+   *
+   * @return {number | undefined} - number of products extracted
+   */
+  getProductCount() {
+    return this.productCount;
+  }
+  /**
+   *
+   * @param value - number of products extracted
+   */
+  setProductCount(value) {
+    this.productCount = value;
+  }
+  /**
+   *
+   * @return {Map<string, number> | undefined} - geometry type breakdown
+   * (entity type name -> count of unique geometry definitions extracted)
+   */
+  getGeometryTypeCounts() {
+    return this.geometryTypeCounts;
+  }
+  /**
+   *
+   * @param value - geometry type breakdown map
+   */
+  setGeometryTypeCounts(value) {
+    this.geometryTypeCounts = value;
+  }
+  /**
+   * Format the geometry-type breakdown as a compact sorted list, e.g.
+   * "IFCEXTRUDEDAREASOLID×3421 IFCFACETEDBREP×212 (+3 more)".
+   *
+   * @param maxEntries - cap on listed types (rest summarized)
+   * @return {string | undefined} the formatted breakdown, if any
+   */
+  // eslint-disable-next-line no-magic-numbers
+  formatGeometryTypeCounts(maxEntries = 12) {
+    if (this.geometryTypeCounts === void 0 || this.geometryTypeCounts.size === 0) {
+      return void 0;
+    }
+    const sorted = Array.from(this.geometryTypeCounts.entries()).sort((leftEntry, rightEntry) => rightEntry[1] - leftEntry[1]);
+    const shown = sorted.slice(0, maxEntries).map(([name, count]) => `${name}\xD7${count}`).join(" ");
+    const remainder = sorted.length - maxEntries;
+    return remainder > 0 ? `${shown} (+${remainder} more)` : shown;
+  }
   /**
    * prints statistics
    */
@@ -229,7 +275,10 @@ var Statistics = class {
     } else {
       versionStr = "Version not defined";
     }
-    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, Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}`;
+    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;
   }
 };
 

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 Web-Ifc Shim v1.379.1191";
+var versionString = "Conway v1.381.1195";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -15844,6 +15844,52 @@ var Statistics = class {
   setMemoryStatistics(value) {
     this.memoryStatistics = value;
   }
+  /**
+   *
+   * @return {number | undefined} - number of products extracted
+   */
+  getProductCount() {
+    return this.productCount;
+  }
+  /**
+   *
+   * @param value - number of products extracted
+   */
+  setProductCount(value) {
+    this.productCount = value;
+  }
+  /**
+   *
+   * @return {Map<string, number> | undefined} - geometry type breakdown
+   * (entity type name -> count of unique geometry definitions extracted)
+   */
+  getGeometryTypeCounts() {
+    return this.geometryTypeCounts;
+  }
+  /**
+   *
+   * @param value - geometry type breakdown map
+   */
+  setGeometryTypeCounts(value) {
+    this.geometryTypeCounts = value;
+  }
+  /**
+   * Format the geometry-type breakdown as a compact sorted list, e.g.
+   * "IFCEXTRUDEDAREASOLID×3421 IFCFACETEDBREP×212 (+3 more)".
+   *
+   * @param maxEntries - cap on listed types (rest summarized)
+   * @return {string | undefined} the formatted breakdown, if any
+   */
+  // eslint-disable-next-line no-magic-numbers
+  formatGeometryTypeCounts(maxEntries = 12) {
+    if (this.geometryTypeCounts === void 0 || this.geometryTypeCounts.size === 0) {
+      return void 0;
+    }
+    const sorted = Array.from(this.geometryTypeCounts.entries()).sort((leftEntry, rightEntry) => rightEntry[1] - leftEntry[1]);
+    const shown = sorted.slice(0, maxEntries).map(([name, count]) => `${name}\xD7${count}`).join(" ");
+    const remainder = sorted.length - maxEntries;
+    return remainder > 0 ? `${shown} (+${remainder} more)` : shown;
+  }
   /**
    * prints statistics
    */
@@ -15886,7 +15932,10 @@ var Statistics = class {
     } else {
       versionStr = "Version not defined";
     }
-    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, Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}`;
+    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;
   }
 };
 
@@ -87125,6 +87174,7 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
     this.circleSegments = 12;
     this.pointBuffer = null;
     this.csgMemoization = true;
+    this.geometryTypeCounts = /* @__PURE__ */ new Map();
     this.csgDepth = 0;
     this.freeVectorPolygonalFaces_ = [];
     this.csgMemoization = !this.lowMemoryMode;
@@ -89748,6 +89798,14 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
       this.scene.popTransform();
     }
   }
+  /**
+   * Increment the geometry-type breakdown counter for a type name.
+   *
+   * @param name The entity type name.
+   */
+  countGeometryType(name) {
+    this.geometryTypeCounts.set(name, (this.geometryTypeCounts.get(name) ?? 0) + 1);
+  }
   /**
    * Extract a representation item, including its geometry if necessary,
    * adding it to the current scene walk.
@@ -89779,7 +89837,9 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
     }
     if (from instanceof IfcMappedItem) {
       return;
-    } else if (from instanceof IfcPolygonalFaceSet) {
+    }
+    this.countGeometryType(entity_types_ifc_gen_default[from.type]);
+    if (from instanceof IfcPolygonalFaceSet) {
       const faceSetResult = this.extractPolygonalFaceSet(from, false, isRelVoid);
       if (faceSetResult !== ExtractResult.COMPLETE) {
         logger_default.warning(`Face set express ID: ${from.expressID} extraction incomplete.`);
@@ -91569,77 +91629,284 @@ var GeometryAggregator = class {
   }
 };
 
-// compiled/src/cli/cli_progress_renderer.js
-var PHASE_LABELS = {
-  headerParse: "Parsing header",
-  dataParse: "Parsing model data",
-  geometry: "Extracting geometry",
-  sceneBuild: "Building scene",
-  serialize: "Writing output"
+// compiled/src/core/progress_log.js
+var STAGE_LABELS = {
+  download: "Download",
+  headerParse: "Parsing",
+  dataParse: "Parsing",
+  geometry: "Geometry",
+  sceneBuild: "Scene",
+  serialize: "Writing",
+  convert: "Convert"
 };
+var BAR_FULL_DOTS = 16;
 var PERCENT = 100;
-var DEFAULT_NON_TTY_INTERVAL_MS = 2e3;
 var MS_PER_SECOND = 1e3;
+var SECONDS_DECIMALS = 3;
+var MB_DECIMALS = 6;
+function stageLabel(phase) {
+  const known = STAGE_LABELS[phase];
+  if (known !== void 0) {
+    return known;
+  }
+  return phase.charAt(0).toUpperCase() + phase.slice(1);
+}
+function formatBar(percent) {
+  if (percent === void 0 || !isFinite(percent)) {
+    return "[...]";
+  }
+  const clamped = Math.max(0, Math.min(PERCENT, percent));
+  const dotCount = Math.round(clamped / PERCENT * BAR_FULL_DOTS);
+  return `[0%${".".repeat(dotCount)}${Math.floor(clamped)}%]`;
+}
+function formatSeconds(milliseconds) {
+  return `${(milliseconds / MS_PER_SECOND).toFixed(SECONDS_DECIMALS)}s`;
+}
+function formatMb(megabytes) {
+  return megabytes.toFixed(MB_DECIMALS);
+}
+function formatModelLine(info) {
+  const parts = [];
+  if (info.schema !== void 0 && info.schema !== "") {
+    parts.push(info.schema);
+  }
+  if (info.byteLength !== void 0) {
+    parts.push(`${(info.byteLength / (1024 * 1024)).toFixed(1)} MB`);
+  }
+  if (info.originatingSystem !== void 0 && info.originatingSystem !== "") {
+    const preprocessor = info.preprocessorVersion !== void 0 && info.preprocessorVersion !== "" ? ` (${info.preprocessorVersion})` : "";
+    parts.push(`${info.originatingSystem}${preprocessor}`);
+  } else if (info.preprocessorVersion !== void 0 && info.preprocessorVersion !== "") {
+    parts.push(info.preprocessorVersion);
+  }
+  const name = info.fileName !== void 0 && info.fileName !== "" ? info.fileName : "(unnamed)";
+  const detail = parts.length > 0 ? ` \u2014 ${parts.join(", ")}` : "";
+  return `Model: ${name}${detail}`;
+}
+function heapDeltaSuffix(state) {
+  if (state.startHeapMb === void 0 || state.lastHeapMb === void 0) {
+    return "";
+  }
+  const delta = state.lastHeapMb - state.startHeapMb;
+  const sign = delta >= 0 ? "+" : "-";
+  return `, ${sign}${formatMb(Math.abs(delta))} MB heap`;
+}
+function formatStageLine(state, final) {
+  const duration = state.lastElapsedMs - state.startElapsedMs;
+  const heap = heapDeltaSuffix(state);
+  const determinate = state.percent !== void 0;
+  if (final && !(determinate && state.percent < PERCENT)) {
+    return `${state.label}: ${formatSeconds(duration)}${heap}`;
+  }
+  const bar = formatBar(determinate ? state.percent : void 0);
+  return `${state.label} ${bar} ${formatSeconds(duration)}${heap}`;
+}
+var LoadLogAccumulator = class {
+  constructor() {
+    this.finished_ = [];
+    this.lastElapsedMs_ = 0;
+  }
+  /**
+   * Record the model line (from header info) — kept with the report.
+   *
+   * @param info The model header info.
+   * @return {string} The formatted model line.
+   */
+  setModelInfo(info) {
+    this.modelLine_ = formatModelLine(info);
+    return this.modelLine_;
+  }
+  /**
+   * Feed one progress event; returns the finished stage's line when this
+   * event closed a stage (so callers can mirror it to a console/log once).
+   *
+   * @param event The progress event.
+   * @return {string | undefined} The line for a just-finished stage, if any.
+   */
+  onProgress(event) {
+    const label = stageLabel(event.phase);
+    this.firstElapsedMs_ ??= event.elapsedMs;
+    this.lastElapsedMs_ = event.elapsedMs;
+    if (event.memoryMb !== void 0) {
+      this.firstHeapMb_ ??= event.memoryMb;
+      this.lastHeapMb_ = event.memoryMb;
+    }
+    let closedLine;
+    if (this.current_ === void 0 || this.current_.label !== label) {
+      closedLine = this.closeCurrentStage(event.elapsedMs, event.memoryMb);
+      this.current_ = {
+        label,
+        startElapsedMs: event.elapsedMs,
+        lastElapsedMs: event.elapsedMs,
+        startHeapMb: event.memoryMb,
+        lastHeapMb: event.memoryMb
+      };
+    }
+    const current = this.current_;
+    current.lastElapsedMs = event.elapsedMs;
+    if (event.memoryMb !== void 0) {
+      current.startHeapMb ??= event.memoryMb;
+      current.lastHeapMb = event.memoryMb;
+    }
+    if (event.total !== void 0 && event.total > 0) {
+      current.percent = event.completed / event.total * PERCENT;
+    }
+    return closedLine;
+  }
+  /**
+   * Close any open stage (e.g. at load end) and freeze its line. When an
+   * end point is given, the stage is extended to it first (a stage ends
+   * when the next begins, or when the load finishes).
+   *
+   * @param atElapsedMs Elapsed ms to extend the stage to before freezing.
+   * @param atMemoryMb Heap MB to extend the stage to before freezing.
+   * @return {string | undefined} The closed stage's line, if one was open.
+   */
+  closeCurrentStage(atElapsedMs, atMemoryMb) {
+    if (this.current_ === void 0) {
+      return void 0;
+    }
+    if (atElapsedMs !== void 0) {
+      this.current_.lastElapsedMs = atElapsedMs;
+      this.lastElapsedMs_ = atElapsedMs;
+    }
+    if (atMemoryMb !== void 0) {
+      this.current_.lastHeapMb = atMemoryMb;
+      this.lastHeapMb_ = atMemoryMb;
+    }
+    const line = formatStageLine(this.current_, true);
+    this.finished_.push(line);
+    this.current_ = void 0;
+    return line;
+  }
+  /**
+   * The live line for the running stage, if any.
+   *
+   * @return {string | undefined} The current stage's animated line.
+   */
+  currentLine() {
+    if (this.current_ === void 0) {
+      return void 0;
+    }
+    return formatStageLine(this.current_, false);
+  }
+  /**
+   * Lines for finished stages, in completion order.
+   *
+   * @return {string[]} The frozen stage lines.
+   */
+  finishedLines() {
+    return this.finished_.slice();
+  }
+  /**
+   * The separate before/after Total line: overall wall clock and heap
+   * observation, not a sum of stages.
+   *
+   * @return {string} e.g. "Total: 44.7s, 512 → 1110 MB heap"
+   */
+  totalLine() {
+    const duration = this.lastElapsedMs_ - (this.firstElapsedMs_ ?? 0);
+    let heap = "";
+    if (this.firstHeapMb_ !== void 0 && this.lastHeapMb_ !== void 0) {
+      heap = `, ${formatMb(this.firstHeapMb_)} \u2192 ${formatMb(this.lastHeapMb_)} MB heap`;
+    }
+    return `Total: ${formatSeconds(duration)}${heap}`;
+  }
+  /**
+   * The full report: model line (if known), finished stage lines, then the
+   * Total line. Call closeCurrentStage() first at load end.
+   *
+   * @return {string[]} All report lines.
+   */
+  allLines() {
+    const lines = [];
+    if (this.modelLine_ !== void 0) {
+      lines.push(this.modelLine_);
+    }
+    lines.push(...this.finished_);
+    lines.push(this.totalLine());
+    return lines;
+  }
+};
+
+// compiled/src/cli/cli_progress_renderer.js
+var DEFAULT_NON_TTY_INTERVAL_MS = 2e3;
 var CliProgressRenderer = class {
   /**
    * Construct this against an output stream.
    *
    * @param out The stream to render to (default stderr).
-   * @param nonTtyIntervalMs Minimum ms between lines when not a TTY.
+   * @param nonTtyIntervalMs Minimum ms between live lines when not a TTY.
    */
   constructor(out = process.stderr, nonTtyIntervalMs = DEFAULT_NON_TTY_INTERVAL_MS) {
     this.out = out;
     this.nonTtyIntervalMs = nonTtyIntervalMs;
+    this.log = new LoadLogAccumulator();
     this.lastLineLength = 0;
     this.lastPrintTime = 0;
     this.onProgress = (event) => {
+      const closedLine = this.log.onProgress(event);
+      if (closedLine !== void 0) {
+        this.freezeLine(closedLine);
+      }
+      const currentLine = this.log.currentLine();
+      if (currentLine === void 0) {
+        return;
+      }
       const now = Date.now();
-      const phaseChanged = event.phase !== this.lastPhase;
-      if (!this.out.isTTY && !phaseChanged && now - this.lastPrintTime < this.nonTtyIntervalMs) {
+      if (!this.out.isTTY && now - this.lastPrintTime < this.nonTtyIntervalMs) {
         return;
       }
-      this.lastPhase = event.phase;
       this.lastPrintTime = now;
-      const line = this.format(event);
       if (this.out.isTTY) {
-        const padded = line.padEnd(this.lastLineLength);
-        this.lastLineLength = line.length;
+        const padded = currentLine.padEnd(this.lastLineLength);
+        this.lastLineLength = currentLine.length;
         this.out.write(`\r${padded}`);
       } else {
-        this.out.write(`${line}
+        this.out.write(`${currentLine}
 `);
       }
     };
   }
   /**
-   * Finish rendering — terminates the TTY status line so subsequent output
-   * (log table, statistics) starts on a fresh line.
+   * Print the early model line (from header info).
+   *
+   * @param info The model header info.
    */
-  done() {
-    if (this.out.isTTY && this.lastLineLength > 0) {
-      this.out.write("\n");
+  onModelInfo(info) {
+    const line = this.log.setModelInfo(info);
+    this.freezeLine(line);
+  }
+  /**
+   * Finish rendering: freeze any running stage's line and print the
+   * separate before/after Total line.
+   *
+   * @param atElapsedMs Optional load-end elapsed ms, so the final stage's
+   * duration covers the time until the load finished (not just until its
+   * last progress event).
+   * @param atMemoryMb Optional load-end heap MB.
+   */
+  done(atElapsedMs, atMemoryMb) {
+    const closedLine = this.log.closeCurrentStage(atElapsedMs, atMemoryMb);
+    if (closedLine !== void 0) {
+      this.freezeLine(closedLine);
     }
-    this.lastLineLength = 0;
-    this.lastPhase = void 0;
+    this.freezeLine(this.log.totalLine());
   }
   /**
-   * Format one event as a status line.
+   * Print a line permanently, replacing any animated line on a TTY.
    *
-   * @param event The progress event.
-   * @return {string} e.g. "Extracting geometry 42% (3800/9000 products) 12.4s 512MB"
+   * @param line The line to freeze.
    */
-  format(event) {
-    const label = PHASE_LABELS[event.phase] ?? event.phase;
-    const elapsedSeconds = (event.elapsedMs / MS_PER_SECOND).toFixed(1);
-    let counts;
-    if (event.total !== void 0 && event.total > 0) {
-      const percent = Math.floor(event.completed / event.total * PERCENT);
-      counts = `${percent}% (${event.completed}/${event.total} ${event.unit})`;
+  freezeLine(line) {
+    if (this.out.isTTY && this.lastLineLength > 0) {
+      this.out.write(`\r${line.padEnd(this.lastLineLength)}
+`);
     } else {
-      counts = `${event.completed} ${event.unit}`;
+      this.out.write(`${line}
+`);
     }
-    const memory = event.memoryMb !== void 0 ? ` ${Math.round(event.memoryMb)}MB` : "";
-    return `${label} ${counts} ${elapsedSeconds}s${memory}`;
+    this.lastLineLength = 0;
   }
 };
 
@@ -91669,6 +91936,36 @@ function parseFileHeader(input) {
   }
   return result;
 }
+var FILE_NAME_NAME = 0;
+var FILE_NAME_PREPROCESSOR = 5;
+var FILE_NAME_ORIGINATING_SYSTEM = 6;
+function extractModelInfo(stepHeader, byteLength) {
+  const info = { byteLength };
+  const schemaRaw = stepHeader.headers.get("FILE_SCHEMA");
+  if (schemaRaw !== void 0) {
+    const match = schemaRaw.match(/'([^']+)'/);
+    info.schema = match !== null ? match[1] : schemaRaw;
+  }
+  let fileNameRaw = stepHeader.headers.get("FILE_NAME");
+  if (fileNameRaw !== void 0) {
+    fileNameRaw = fileNameRaw.substring(1, fileNameRaw.length - 1);
+    const fields = parseFileHeader(fileNameRaw);
+    const unquote = (value) => {
+      if (value === void 0) {
+        return void 0;
+      }
+      const trimmed = value.trim();
+      return trimmed.replace(/^'/, "").replace(/'$/, "");
+    };
+    const name = unquote(fields[FILE_NAME_NAME]);
+    if (name !== void 0 && name !== "") {
+      info.fileName = name;
+    }
+    info.preprocessorVersion = unquote(fields[FILE_NAME_PREPROCESSOR]);
+    info.originatingSystem = unquote(fields[FILE_NAME_ORIGINATING_SYSTEM]);
+  }
+  return info;
+}
 
 // compiled/src/ifc/ifc_command_line_main.js
 var modelID = 0;
@@ -91825,6 +92122,7 @@ function doWork() {
     tracker?.beginPhase("headerParse", "bytes", indexIfcBuffer.length);
     const [stepHeader, result0] = parser210.parseHeader(bufferInput);
     const headerDataTimeEnd = Date.now();
+    progressRenderer?.onModelInfo(extractModelInfo(stepHeader, indexIfcBuffer.length));
     switch (result0) {
       case ParseResult.COMPLETE:
         break;
@@ -91967,7 +92265,7 @@ function doWork() {
       }
       statistics.setMemoryStatistics(Memory.checkMemoryUsage());
     }
-    progressRenderer?.done();
+    progressRenderer?.done(Date.now() - allTimeStart, Memory.usedHeapMb());
     logger_default.displayLogs();
     logger_default.printStatistics(modelID);
   }).help().argv;

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

@@ -15912,7 +15912,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway Web-Ifc Shim v1.379.1191";
+var versionString = "Conway v1.381.1195";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -16791,6 +16791,52 @@ var Statistics = class {
   setMemoryStatistics(value) {
     this.memoryStatistics = value;
   }
+  /**
+   *
+   * @return {number | undefined} - number of products extracted
+   */
+  getProductCount() {
+    return this.productCount;
+  }
+  /**
+   *
+   * @param value - number of products extracted
+   */
+  setProductCount(value) {
+    this.productCount = value;
+  }
+  /**
+   *
+   * @return {Map<string, number> | undefined} - geometry type breakdown
+   * (entity type name -> count of unique geometry definitions extracted)
+   */
+  getGeometryTypeCounts() {
+    return this.geometryTypeCounts;
+  }
+  /**
+   *
+   * @param value - geometry type breakdown map
+   */
+  setGeometryTypeCounts(value) {
+    this.geometryTypeCounts = value;
+  }
+  /**
+   * Format the geometry-type breakdown as a compact sorted list, e.g.
+   * "IFCEXTRUDEDAREASOLID×3421 IFCFACETEDBREP×212 (+3 more)".
+   *
+   * @param maxEntries - cap on listed types (rest summarized)
+   * @return {string | undefined} the formatted breakdown, if any
+   */
+  // eslint-disable-next-line no-magic-numbers
+  formatGeometryTypeCounts(maxEntries = 12) {
+    if (this.geometryTypeCounts === void 0 || this.geometryTypeCounts.size === 0) {
+      return void 0;
+    }
+    const sorted = Array.from(this.geometryTypeCounts.entries()).sort((leftEntry, rightEntry) => rightEntry[1] - leftEntry[1]);
+    const shown = sorted.slice(0, maxEntries).map(([name, count]) => `${name}\xD7${count}`).join(" ");
+    const remainder = sorted.length - maxEntries;
+    return remainder > 0 ? `${shown} (+${remainder} more)` : shown;
+  }
   /**
    * prints statistics
    */
@@ -16833,7 +16879,10 @@ var Statistics = class {
     } else {
       versionStr = "Version not defined";
     }
-    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, Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}`;
+    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;
   }
 };
 
@@ -81151,6 +81200,7 @@ var AP214GeometryExtraction = class _AP214GeometryExtraction {
     this.csgMemoization = true;
     this.csgDepth = 0;
     this.freeVectorPolygonalFaces_ = [];
+    this.geometryTypeCounts = /* @__PURE__ */ new Map();
     this.csgMemoization = !this.lowMemoryMode;
     this.materials = model.materials;
     this.scene = new AP214SceneBuilder(model, conwayModel, this.materials);
@@ -82655,6 +82705,14 @@ var AP214GeometryExtraction = class _AP214GeometryExtraction {
       this.scene.popTransform();
     }
   }
+  /**
+   * Increment the geometry-type breakdown counter for a type name.
+   *
+   * @param name The entity type name.
+   */
+  countGeometryType(name) {
+    this.geometryTypeCounts.set(name, (this.geometryTypeCounts.get(name) ?? 0) + 1);
+  }
   /**
    * Extract a representation item, including its geometry if necessary,
    * adding it to the current scene walk.
@@ -82681,7 +82739,9 @@ var AP214GeometryExtraction = class _AP214GeometryExtraction {
     }
     if (from instanceof mapped_item) {
       return;
-    } else if (from instanceof boolean_result) {
+    }
+    this.countGeometryType(entity_types_ap214_gen_default[from.type]);
+    if (from instanceof boolean_result) {
       this.extractBooleanResult(from);
     } else if (from instanceof extruded_area_solid) {
       this.extractExtrudedAreaSolid(from, false);