benchforge 0.1.0

package/src/table-util/test/TableValueExtractor.ts

@@ -0,0 +1,100 @@
+/** Extract numeric values from benchmark tables with Unicode borders. */
+
+/** Extract a numeric value from a table by row name and column header. */
+export function extractValue(
+  table: string,
+  row: string,
+  column: string,
+  group?: string,
+): number | undefined {
+  const lines = trimmedBody(table);
+  const dataRow = lines.find(l => l.includes(row));
+  if (!dataRow) return undefined;
+
+  const colIndex = group
+    ? getGroupColumnIndex(lines, group, column)
+    : getColumnIndex(
+        lines.find(line => line.includes(column)),
+        column,
+      );
+
+  if (colIndex === undefined) return undefined;
+  return parseCell(dataRow, colIndex);
+}
+
+/** @return the table lines w/borders and blank rows removed */
+function trimmedBody(table: string): string[] {
+  return table
+    .split("\n")
+    .filter(line => line.includes("║"))
+    .map(line => line.replaceAll("║", "").trim())
+    .filter(line => !line.match(/^[\s│]+$/));
+}
+
+/** Get the column index for a specific group and column combination. */
+function getGroupColumnIndex(
+  lines: string[],
+  group: string,
+  column: string,
+): number | undefined {
+  // assume the first line with the group or column name is the header line
+  const groupLine = lines.find(line => line.includes(group));
+  const columnLine = lines.find(line => line.includes(column));
+  if (!columnLine || !groupLine) return undefined;
+
+  const groupHeaders = splitColumnGroups(groupLine);
+  const groupedColumns = splitColumnGroups(columnLine);
+
+  const groupIndex = groupHeaders.findIndex(col => col.includes(group));
+  if (groupIndex === -1) return undefined;
+
+  const columnsBefore = countColumnsBeforeGroup(groupedColumns, groupIndex);
+  const columnHeaders = splitColumns(columnLine);
+  return columnHeaders.findIndex(
+    (c, i) => c.includes(column) && i >= columnsBefore,
+  );
+}
+
+/** Count total columns in groups before the target group index. */
+function countColumnsBeforeGroup(
+  headers: string[],
+  groupIndex: number,
+): number {
+  const perGroup = headers.map(col => splitColumns(col).length);
+  return perGroup.slice(0, groupIndex).reduce((sum, n) => sum + n, 0);
+}
+
+/** Find a column's position index in a header line. */
+function getColumnIndex(
+  header: string | undefined,
+  column: string,
+): number | undefined {
+  if (!header) return undefined;
+
+  const columns = splitColumns(header);
+  const index = columns.findIndex(col => col.includes(column));
+  return index !== -1 ? index : undefined;
+}
+
+/** Extract and parse the numeric value from a cell at the given column index. */
+function parseCell(row: string, index: number): number | undefined {
+  const text = splitColumns(row)[index];
+  if (!text) return undefined;
+  const match = text.match(/[\d,]+\.?\d*/);
+  if (!match) return undefined;
+  const value = Number.parseFloat(match[0].replace(/,/g, ""));
+  return Number.isNaN(value) ? undefined : value;
+}
+
+/** split column groups along '│' borders */
+function splitColumnGroups(line: string): string[] {
+  return line.split("│").map(col => col.trim());
+}
+
+/** Split on 2+ whitespace or '│' borders, so single-space titles like "L1 miss" survive. */
+function splitColumns(line: string): string[] {
+  return line
+    .split(/(?:[\s│]{2,}|│)/)
+    .map(col => col.trim())
+    .filter(Boolean);
+}

package/src/test/AdaptiveRunner.test.ts

@@ -0,0 +1,185 @@
+import { expect, test } from "vitest";
+import type { BenchmarkSpec } from "../Benchmark.ts";
+import {
+  checkConvergence,
+  createAdaptiveWrapper,
+} from "../runners/AdaptiveWrapper.ts";
+import { BasicRunner } from "../runners/BasicRunner.ts";
+
+test(
+  "adaptive runner collects samples for minimum time",
+  { timeout: 10000 },
+  async () => {
+    const runner = new BasicRunner();
+    const adaptive = createAdaptiveWrapper(runner, {
+      minTime: 100,
+      maxTime: 300,
+    });
+
+    const benchmark: BenchmarkSpec = {
+      name: "test-min-time",
+      fn: () => {
+        let sum = 0;
+        for (let i = 0; i < 1000; i++) sum += i;
+        return sum;
+      },
+    };
+
+    const start = performance.now();
+    const results = await adaptive.runBench(benchmark, { minTime: 100 });
+    const elapsed = performance.now() - start;
+
+    expect(results).toHaveLength(1);
+    expect(results[0].samples.length).toBeGreaterThan(0);
+    expect(elapsed).toBeGreaterThanOrEqual(100);
+  },
+);
+
+test("adaptive runner respects max time limit", async () => {
+  const runner = new BasicRunner();
+  const adaptive = createAdaptiveWrapper(runner, {
+    minTime: 100,
+    maxTime: 2000,
+  });
+
+  const benchmark: BenchmarkSpec = {
+    name: "test-max-time",
+    fn: () => {
+      let sum = 0;
+      for (let i = 0; i < 10000; i++) sum += Math.sqrt(i);
+      return sum;
+    },
+  };
+
+  const results = await adaptive.runBench(benchmark, {
+    minTime: 250,
+    maxTime: 500,
+  });
+
+  expect(results).toHaveLength(1);
+  expect(results[0].totalTime).toBeGreaterThanOrEqual(0);
+  // 1s warmup overhead + 500ms maxTime + some tolerance
+  expect(results[0].totalTime).toBeLessThanOrEqual(2.0);
+});
+
+test("adaptive runner merges results correctly", async () => {
+  const runner = new BasicRunner();
+  const adaptive = createAdaptiveWrapper(runner, {
+    minTime: 100,
+    maxTime: 200,
+  });
+
+  const benchmark: BenchmarkSpec = {
+    name: "test-merge",
+    fn: () => {
+      let sum = 0;
+      for (let i = 0; i < 100; i++) sum += i;
+      return sum;
+    },
+  };
+
+  const results = await adaptive.runBench(benchmark, { minTime: 50 });
+
+  expect(results).toHaveLength(1);
+  const result = results[0];
+
+  expect(result.samples.length).toBeGreaterThan(0);
+  expect(result.time.min).toBeLessThanOrEqual(result.time.max);
+  expect(result.time.avg).toBeGreaterThan(0);
+  expect(result.time.p50).toBeDefined();
+  expect(result.time.p99).toBeDefined();
+
+  if (result.time.p25 !== undefined && result.time.p75 !== undefined) {
+    expect(result.time.p25).toBeLessThanOrEqual(result.time.p50);
+    expect(result.time.p50).toBeLessThanOrEqual(result.time.p75);
+  }
+  if (result.time.p99 !== undefined && result.time.p999 !== undefined) {
+    expect(result.time.p99).toBeLessThanOrEqual(result.time.p999);
+  }
+
+  expect(result.totalTime).toBeDefined();
+  expect(result.totalTime).toBeGreaterThan(0);
+}, 10000);
+
+test("convergence detection with stable benchmark", async () => {
+  const runner = new BasicRunner();
+  const adaptive = createAdaptiveWrapper(runner, {
+    minTime: 100,
+    maxTime: 2000,
+    targetConfidence: 95,
+  });
+
+  const benchmark: BenchmarkSpec = {
+    name: "stable-convergence-test",
+    fn: () => {
+      let sum = 0;
+      for (let i = 0; i < 100; i++) sum += i;
+      return sum;
+    },
+  };
+
+  const results = await adaptive.runBench(benchmark, { minTime: 50 });
+
+  expect(results).toHaveLength(1);
+  const result = results[0];
+
+  expect(result.convergence).toBeDefined();
+  expect(result.convergence?.confidence).toBeGreaterThanOrEqual(0);
+  expect(result.convergence?.confidence).toBeLessThanOrEqual(100);
+  expect(result.convergence?.reason).toBeDefined();
+});
+
+test("convergence detection with variable benchmark", async () => {
+  const runner = new BasicRunner();
+  const adaptive = createAdaptiveWrapper(runner, {
+    minTime: 100,
+    maxTime: 1000,
+  });
+
+  let callCount = 0;
+  const benchmark: BenchmarkSpec = {
+    name: "variable-convergence-test",
+    fn: () => {
+      // Variable operation - alternates between fast and slow
+      callCount++;
+      const iterations = callCount % 10 === 0 ? 1000 : 100;
+      let sum = 0;
+      for (let i = 0; i < iterations; i++) {
+        sum += i;
+      }
+      return sum;
+    },
+  };
+
+  const results = await adaptive.runBench(benchmark, { minTime: 100 });
+
+  expect(results).toHaveLength(1);
+  const result = results[0];
+
+  expect(result.convergence).toBeDefined();
+  // Pattern may be detected as stable if predictable
+  expect(result.convergence?.confidence).toBeGreaterThanOrEqual(0);
+  expect(result.convergence?.confidence).toBeLessThanOrEqual(100);
+});
+
+test("checkConvergence function basics", () => {
+  // Not enough samples
+  const fewSamples = [1e6, 1.1e6, 1e6];
+  const fewResult = checkConvergence(fewSamples);
+  expect(fewResult.converged).toBe(false);
+  expect(fewResult.reason).toContain("Collecting samples");
+
+  // Many stable samples
+  const stableSamples = Array(100).fill(1e6);
+  const stableResult = checkConvergence(stableSamples);
+  expect(stableResult.confidence).toBeGreaterThan(50);
+
+  // Variable samples - alternating pattern may be detected as stable
+  const variableSamples = Array.from({ length: 100 }, (_, i) =>
+    i % 2 === 0 ? 1e6 : 2e6,
+  );
+  const variableResult = checkConvergence(variableSamples);
+  // Just verify confidence is calculated, alternating may be seen as stable
+  expect(variableResult.confidence).toBeGreaterThanOrEqual(0);
+  expect(variableResult.confidence).toBeLessThanOrEqual(100);
+});

package/src/test/AdaptiveStatistics.integration.ts

@@ -0,0 +1,119 @@
+import { expect, test } from "vitest";
+import type { BenchSuite } from "../Benchmark.ts";
+import type { BenchmarkReport } from "../BenchmarkReport.ts";
+import { parseBenchArgs, runBenchmarks } from "../cli/RunBenchCLI.ts";
+
+const statisticalSuite: BenchSuite = {
+  name: "Statistical Test Suite",
+  groups: [
+    {
+      name: "Test Group",
+      benchmarks: [
+        {
+          name: "stable-benchmark",
+          fn: () => {
+            let sum = 0;
+            for (let i = 0; i < 100; i++) sum += i;
+            return sum;
+          },
+        },
+        {
+          name: "variable-benchmark",
+          fn: () => {
+            const iterations = Math.random() > 0.9 ? 1000 : 100;
+            let sum = 0;
+            for (let i = 0; i < iterations; i++) sum += i;
+            return sum;
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const gcSuite: BenchSuite = {
+  name: "GC Test Suite",
+  groups: [
+    {
+      name: "Memory Group",
+      benchmarks: [
+        {
+          name: "gc-heavy",
+          fn: () => {
+            const arrays = [];
+            for (let i = 0; i < 50; i++) {
+              arrays.push(Array.from({ length: 1000 }, () => Math.random()));
+            }
+            return arrays.length;
+          },
+        },
+      ],
+    },
+  ],
+};
+
+function parseAdaptiveArgs() {
+  return parseBenchArgs((yargs: any) =>
+    yargs
+      .option("adaptive", { type: "boolean", default: true })
+      .option("time", { type: "number", default: 0.1 })
+      .option("min-time", { type: "number", default: 0.1 }),
+  );
+}
+
+function verifyStatisticalMetrics(report: BenchmarkReport): void {
+  const { time, convergence } = report.measuredResults;
+  expect(time).toBeDefined();
+  expect(time?.p25).toBeDefined();
+  expect(time?.p50).toBeDefined();
+  expect(time?.p75).toBeDefined();
+  expect(time?.p95).toBeDefined();
+  expect(time?.cv).toBeGreaterThanOrEqual(0);
+  expect(time?.mad).toBeGreaterThanOrEqual(0);
+  expect(time?.outlierRate).toBeGreaterThanOrEqual(0);
+  expect(time?.outlierRate).toBeLessThanOrEqual(1);
+  expect(convergence?.confidence).toBeGreaterThanOrEqual(0);
+  expect(convergence?.confidence).toBeLessThanOrEqual(100);
+  expect(convergence?.reason).toBeDefined();
+}
+
+function verifyPercentileOrdering(report: BenchmarkReport): void {
+  const t = report.measuredResults.time;
+  if (t?.p25 && t?.p50 && t?.p75 && t?.p95) {
+    expect(t.p25).toBeLessThanOrEqual(t.p50);
+    expect(t.p50).toBeLessThanOrEqual(t.p75);
+    expect(t.p75).toBeLessThanOrEqual(t.p95);
+  }
+}
+
+test("adaptive mode reports statistical metrics correctly", async () => {
+  const results = await runBenchmarks(statisticalSuite, parseAdaptiveArgs());
+  expect(results).toHaveLength(1);
+  expect(results[0].reports).toHaveLength(2);
+
+  for (const report of results[0].reports) {
+    verifyStatisticalMetrics(report);
+    verifyPercentileOrdering(report);
+  }
+
+  const reports = results[0].reports;
+  const stableCV = reports.find(r => r.name === "stable-benchmark")
+    ?.measuredResults.time?.cv;
+  const variableCV = reports.find(r => r.name === "variable-benchmark")
+    ?.measuredResults.time?.cv;
+  if (stableCV && variableCV) {
+    expect(variableCV).toBeGreaterThanOrEqual(stableCV);
+  }
+}, 20000);
+
+test("adaptive mode handles GC-heavy workload", async () => {
+  const results = await runBenchmarks(gcSuite, parseAdaptiveArgs());
+  expect(results).toHaveLength(1);
+  expect(results[0].reports).toHaveLength(1);
+
+  const gcResult = results[0].reports[0].measuredResults;
+  expect(gcResult.convergence).toBeDefined();
+  expect(gcResult.time?.outlierRate).toBeDefined();
+  expect(gcResult.time?.cv).toBeDefined();
+  expect(gcResult.time?.mad).toBeGreaterThanOrEqual(0);
+}, 20000);

package/src/test/BenchmarkReport.test.ts

@@ -0,0 +1,82 @@
+import { expect, test } from "vitest";
+import {
+  type BenchmarkReport,
+  reportResults,
+  valuesForReports,
+} from "../BenchmarkReport.ts";
+import {
+  adaptiveSection,
+  gcSection,
+  timeSection,
+} from "../StandardSections.ts";
+import { createBenchmarkReport, createMeasuredResults } from "./TestUtils.ts";
+
+test("combines time and gc sections into report", () => {
+  const sections = [timeSection, gcSection] as const;
+  const report = createBenchmarkReport("test", [100, 150]);
+  const rows = valuesForReports([report], sections);
+
+  expect(rows[0].name).toBe("test");
+  expect(rows[0].mean).toBeCloseTo(report.measuredResults.time.avg, 1);
+  expect(rows[0].p50).toBeCloseTo(report.measuredResults.time.p50, 1);
+  expect(rows[0].p99).toBeCloseTo(report.measuredResults.time.p99, 1);
+  expect(rows[0].gc).toBeDefined();
+});
+
+test("generates diff columns for baseline comparison", () => {
+  const faster = createMeasuredResults([250, 300]);
+  const slower = createMeasuredResults([0, 50]);
+
+  const scale = (results: typeof faster, factor: number) => ({
+    ...results,
+    time: {
+      ...results.time,
+      avg: results.time.avg * factor,
+      p50: results.time.p50 * factor,
+      p99: results.time.p99 * factor,
+    },
+  });
+
+  const group1Reports: BenchmarkReport[] = [
+    { name: "version1", measuredResults: scale(faster, 0.8) },
+    { name: "version2", measuredResults: scale(slower, 1.2) },
+  ];
+
+  const baseline = createBenchmarkReport("baseVersion", [200, 250]);
+  const group2Reports = [
+    createBenchmarkReport("test3", [300, 350]),
+    createBenchmarkReport("test4", [350, 400]),
+  ];
+
+  const groups = [
+    { name: "group1", reports: group1Reports, baseline },
+    { name: "group2", reports: group2Reports },
+  ];
+
+  const table = reportResults(groups, [timeSection]);
+  const names = ["version1", "version2", "baseVersion", "test3", "test4"];
+  for (const name of names) expect(table).toContain(name);
+  expect(table).toContain("Δ%");
+});
+
+test("formats adaptive convergence statistics", () => {
+  const reports: BenchmarkReport[] = [
+    createBenchmarkReport("test-adaptive", [400, 500], {
+      convergence: { converged: true, confidence: 95, reason: "stable" },
+    }),
+    createBenchmarkReport("test-low-confidence", [0, 30], {
+      convergence: { converged: false, confidence: 65, reason: "unstable" },
+    }),
+  ];
+
+  const rows = valuesForReports(reports, [adaptiveSection]);
+  expect(rows[0].convergence).toBe(95);
+  expect(rows[1].convergence).toBe(65);
+
+  const table = reportResults(
+    [{ name: "adaptive", reports }],
+    [adaptiveSection],
+  );
+  expect(table).toContain("95%");
+  expect(table).toMatch(/65%/);
+});

package/src/test/BrowserBench.e2e.test.ts

@@ -0,0 +1,44 @@
+import path from "node:path";
+import { expect, test } from "vitest";
+import { profileBrowser } from "../browser/BrowserHeapSampler.ts";
+
+const examplesDir = path.resolve(import.meta.dirname!, "../../examples");
+
+test("bench function mode (window.__bench)", { timeout: 30000 }, async () => {
+  const url = `file://${examplesDir}/browser-bench/index.html`;
+  const result = await profileBrowser({ url, maxTime: 500, gcStats: true });
+
+  expect(result.samples).toBeDefined();
+  expect(result.samples!.length).toBeGreaterThan(5);
+  expect(result.wallTimeMs).toBeGreaterThan(0);
+  expect(result.gcStats).toBeDefined();
+  expect(result.gcStats!.scavenges).toBeGreaterThanOrEqual(0);
+  for (const s of result.samples!) {
+    expect(s).toBeGreaterThan(0);
+    expect(s).toBeLessThan(1000);
+  }
+});
+
+test("lap mode with N laps", { timeout: 30000 }, async () => {
+  const url = `file://${examplesDir}/browser-lap/index.html`;
+  const result = await profileBrowser({ url, gcStats: true });
+
+  expect(result.samples).toBeDefined();
+  expect(result.samples!).toHaveLength(100);
+  expect(result.wallTimeMs).toBeGreaterThan(0);
+  expect(result.gcStats).toBeDefined();
+  for (const s of result.samples!) {
+    expect(s).toBeGreaterThanOrEqual(0);
+  }
+});
+
+test("lap mode 0 laps with heap profiling", { timeout: 30000 }, async () => {
+  const url = `file://${examplesDir}/browser-heap/index.html`;
+  const result = await profileBrowser({ url, heapSample: true });
+
+  expect(result.samples).toBeDefined();
+  expect(result.samples!).toHaveLength(0);
+  expect(result.wallTimeMs).toBeGreaterThan(0);
+  expect(result.heapProfile).toBeDefined();
+  expect(result.heapProfile!.head).toBeDefined();
+});

package/src/test/BrowserBench.test.ts

@@ -0,0 +1,79 @@
+import { expect, test } from "vitest";
+import {
+  browserGcStats,
+  parseGcTraceEvents,
+  type TraceEvent,
+} from "../browser/BrowserGcStats.ts";
+
+test("parseGcTraceEvents parses MinorGC and MajorGC events", () => {
+  const events: TraceEvent[] = [
+    {
+      cat: "v8.gc",
+      name: "MinorGC",
+      ph: "X",
+      dur: 500,
+      args: { usedHeapSizeBefore: 10000, usedHeapSizeAfter: 8000 },
+    },
+    {
+      cat: "v8.gc",
+      name: "MajorGC",
+      ph: "X",
+      dur: 12000,
+      args: { usedHeapSizeBefore: 50000, usedHeapSizeAfter: 30000 },
+    },
+  ];
+  const parsed = parseGcTraceEvents(events);
+  expect(parsed).toHaveLength(2);
+  expect(parsed[0]).toEqual({
+    type: "scavenge",
+    pauseMs: 0.5,
+    collected: 2000,
+  });
+  expect(parsed[1]).toEqual({
+    type: "mark-compact",
+    pauseMs: 12,
+    collected: 20000,
+  });
+});
+
+test("parseGcTraceEvents ignores non-complete and non-GC events", () => {
+  const events: TraceEvent[] = [
+    { cat: "v8.gc", name: "MinorGC", ph: "B", dur: 500 }, // not complete
+    { cat: "v8", name: "V8.Execute", ph: "X", dur: 100 }, // not GC
+    { cat: "v8.gc", name: "MinorGC", ph: "X" }, // valid, missing dur/args
+  ];
+  const parsed = parseGcTraceEvents(events);
+  expect(parsed).toHaveLength(1);
+  expect(parsed[0]).toEqual({ type: "scavenge", pauseMs: 0, collected: 0 });
+});
+
+test("browserGcStats aggregates trace events into GcStats", () => {
+  const events: TraceEvent[] = [
+    {
+      cat: "v8.gc",
+      name: "MinorGC",
+      ph: "X",
+      dur: 300,
+      args: { usedHeapSizeBefore: 5000, usedHeapSizeAfter: 3000 },
+    },
+    {
+      cat: "v8.gc",
+      name: "MinorGC",
+      ph: "X",
+      dur: 200,
+      args: { usedHeapSizeBefore: 6000, usedHeapSizeAfter: 4000 },
+    },
+    {
+      cat: "v8.gc",
+      name: "MajorGC",
+      ph: "X",
+      dur: 8000,
+      args: { usedHeapSizeBefore: 40000, usedHeapSizeAfter: 20000 },
+    },
+  ];
+  const stats = browserGcStats(events);
+  expect(stats.scavenges).toBe(2);
+  expect(stats.markCompacts).toBe(1);
+  expect(stats.totalCollected).toBe(24000);
+  expect(stats.gcPauseTime).toBeCloseTo(8.5, 2);
+});

package/src/test/GcStats.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from "vitest";
+import { aggregateGcStats, parseGcLine } from "../runners/GcStats.ts";
+
+test("parseGcLine parses scavenge event from real V8 output", () => {
+  // Real V8 --trace-gc-nvp format
+  const line =
+    "[71753:0x83280c000:0] 9 ms: pause=0.5 mutator=0.1 gc=s allocated=293224 promoted=653480 new_space_survived=290176 start_object_size=4392688 end_object_size=4287840";
+  const event = parseGcLine(line);
+  expect(event).toMatchObject({
+    type: "scavenge",
+    pauseMs: 0.5,
+    allocated: 293224,
+    promoted: 653480,
+    survived: 290176,
+    collected: 4392688 - 4287840,
+  });
+});
+
+test("parseGcLine parses mark-sweep event", () => {
+  const line =
+    "[1234:0x12345:0] 100 ms: pause=12.3 gc=ms allocated=2097152 promoted=0 new_space_survived=0 start_object_size=5000000 end_object_size=3000000";
+  const event = parseGcLine(line);
+  expect(event).toMatchObject({
+    type: "mark-compact",
+    pauseMs: 12.3,
+    allocated: 2097152,
+    collected: 2000000,
+  });
+});
+
+test("parseGcLine returns undefined for non-GC lines", () => {
+  expect(parseGcLine("some random stderr output")).toBeUndefined();
+  expect(parseGcLine("")).toBeUndefined();
+  expect(parseGcLine("   ")).toBeUndefined();
+});
+
+test("parseGcLine handles missing fields", () => {
+  const line = "gc=s pause=1.0";
+  const event = parseGcLine(line);
+  expect(event).toMatchObject({
+    type: "scavenge",
+    pauseMs: 1.0,
+    allocated: 0,
+    collected: 0,
+    promoted: 0,
+    survived: 0,
+  });
+});
+
+test("aggregateGcStats aggregates multiple events", () => {
+  const scav = "scavenge" as const;
+  const mc = "mark-compact" as const;
+  const events = [
+    {
+      type: scav,
+      pauseMs: 0.5,
+      allocated: 1000,
+      collected: 500,
+      promoted: 100,
+      survived: 400,
+    },
+    {
+      type: scav,
+      pauseMs: 0.3,
+      allocated: 2000,
+      collected: 800,
+      promoted: 200,
+      survived: 1000,
+    },
+    {
+      type: mc,
+      pauseMs: 10.0,
+      allocated: 0,
+      collected: 5000,
+      promoted: 0,
+      survived: 0,
+    },
+  ];
+  const stats = aggregateGcStats(events);
+  expect(stats.scavenges).toBe(2);
+  expect(stats.markCompacts).toBe(1);
+  expect(stats.totalAllocated).toBe(3000);
+  expect(stats.totalCollected).toBe(6300);
+  expect(stats.totalPromoted).toBe(300);
+  expect(stats.totalSurvived).toBe(1400);
+  expect(stats.gcPauseTime).toBeCloseTo(10.8, 2);
+});
+
+test("aggregateGcStats handles empty events", () => {
+  const stats = aggregateGcStats([]);
+  expect(stats.scavenges).toBe(0);
+  expect(stats.markCompacts).toBe(0);
+  expect(stats.gcPauseTime).toBe(0);
+});