benchforge 0.1.11 → 0.2.4

package/src/{tests → test}/AdaptiveSampling.test.ts

@@ -1,8 +1,8 @@
 import { test } from "vitest";
-import type { BenchmarkSpec } from "../Benchmark.ts";
-import type { MeasuredResults } from "../MeasuredResults.ts";
 import { createAdaptiveWrapper } from "../runners/AdaptiveWrapper.ts";
+import type { BenchmarkSpec } from "../runners/BenchmarkSpec.ts";
 import type { BenchRunner } from "../runners/BenchRunner.ts";
+import type { MeasuredResults } from "../runners/MeasuredResults.ts";
 import { bevy30SamplesMs } from "./fixtures/bevy30-samples.ts";
 
 /** Assert convergence data exists, return the result for further checks. */
@@ -41,7 +41,7 @@ function createMockRunner(samples: number[]): BenchRunner {
   };
 }
 
-test("adaptive wrapper stops early with stable samples", async () => {
+test.skip("adaptive wrapper stops early with stable samples", async () => {
   const stableSamples = Array.from(
     { length: 500 },
     () => 50 + Math.random() * 0.5,
@@ -74,7 +74,7 @@ test("adaptive wrapper stops early with stable samples", async () => {
   }
 });
 
-test("adaptive wrapper continues with unstable samples", async () => {
+test.skip("adaptive wrapper continues with unstable samples", async () => {
   const unstableSamples = Array.from(
     { length: 500 },
     () => 30 + Math.random() * 40,
@@ -99,7 +99,7 @@ test("adaptive wrapper continues with unstable samples", async () => {
   }
 });
 
-test("adaptive wrapper with real bevy30 data", async () => {
+test.skip("adaptive wrapper with real bevy30 data", async () => {
   const bench: BenchmarkSpec = { name: "bevy-test", fn: () => {} };
 
   const configs = [
@@ -123,7 +123,7 @@ test("adaptive wrapper with real bevy30 data", async () => {
   }
 });
 
-test("adaptive wrapper respects target confidence", async () => {
+test.skip("adaptive wrapper respects target confidence", async () => {
   const mockRunner = createMockRunner(bevy30SamplesMs);
 
   const wrapper = createAdaptiveWrapper(mockRunner, { convergence: 50 });
@@ -148,7 +148,7 @@ test("adaptive wrapper respects target confidence", async () => {
   }
 });
 
-test("adaptive wrapper handles warm-up period", async () => {
+test.skip("adaptive wrapper handles warm-up period", async () => {
   // Simulate warm-up: slow samples at start, then stable
   // Decreasing from 100ms to 60ms, then stable at ~50ms
   const warmup = Array.from({ length: 20 }, (_, i) => 100 - i * 2);
@@ -177,7 +177,7 @@ test("adaptive wrapper handles warm-up period", async () => {
   }
 });
 
-test("adaptive wrapper statistics calculation", async () => {
+test.skip("adaptive wrapper statistics calculation", async () => {
   const samples = bevy30SamplesMs.slice(100, 200);
   const mockRunner = createMockRunner(samples);
   const adaptiveRunner = createAdaptiveWrapper(mockRunner, {});
@@ -211,7 +211,7 @@ test("adaptive wrapper statistics calculation", async () => {
   );
 });
 
-test("adaptive wrapper total time tracking", async () => {
+test.skip("adaptive wrapper total time tracking", async () => {
   const mockRunner = createMockRunner(bevy30SamplesMs.slice(0, 100));
   const adaptiveRunner = createAdaptiveWrapper(mockRunner, {});
 

package/src/test/AdaptiveStatistics.integration.ts

@@ -1,7 +1,7 @@
 import { expect } from "vitest";
-import type { BenchSuite } from "../Benchmark.ts";
-import type { BenchmarkReport } from "../BenchmarkReport.ts";
 import { parseBenchArgs } from "../cli/RunBenchCLI.ts";
+import type { BenchmarkReport } from "../report/BenchmarkReport.ts";
+import type { BenchSuite } from "../runners/BenchmarkSpec.ts";
 
 const _statisticalSuite: BenchSuite = {
   name: "Statistical Test Suite",

package/src/{tests → test}/BenchMatrix.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "vitest";
-import type { BenchMatrix, StatefulVariant } from "../BenchMatrix.ts";
-import { isStatefulVariant, runMatrix } from "../BenchMatrix.ts";
+import type { BenchMatrix, StatefulVariant } from "../matrix/BenchMatrix.ts";
+import { isStatefulVariant, runMatrix } from "../matrix/BenchMatrix.ts";
 import { loadCaseData, loadCasesModule } from "../matrix/CaseLoader.ts";
 import { discoverVariants, loadVariant } from "../matrix/VariantLoader.ts";
 
@@ -16,6 +16,9 @@ const casesVariantDirUrl = `${casesFixturesUrl}/variants/`;
 const variantsDirUrl = `file://${import.meta.dirname}/fixtures/variants/`;
 const baselineDirUrl = `file://${import.meta.dirname}/fixtures/baseline/`;
 
+/** Skip V8 settle time and cap maxTime — tests verify correctness, not perf. */
+const fast = { maxTime: 100 } as const;
+
 test("inline variants, no cases", async () => {
   const matrix: BenchMatrix = {
     name: "Test",
@@ -27,7 +30,7 @@ test("inline variants, no cases", async () => {
       },
     },
   };
-  const results = await runMatrix(matrix, { iterations: 10 });
+  const results = await runMatrix(matrix, { iterations: 10, ...fast });
   expect(results.name).toBe("Test");
   expect(results.variants).toHaveLength(2);
   expect(results.variants.map(v => v.id).sort()).toEqual(["fast", "slow"]);
@@ -47,7 +50,7 @@ test("inline variants with cases", async () => {
     },
     cases: ["Hello", "World"],
   };
-  const results = await runMatrix(matrix, { iterations: 10 });
+  const results = await runMatrix(matrix, { iterations: 10, ...fast });
   expect(results.variants).toHaveLength(2);
   for (const variant of results.variants) {
     expect(variant.cases).toHaveLength(2);
@@ -65,7 +68,7 @@ test("stateful variant", async () => {
     variants: { stateful },
     cases: ["a", "b"],
   };
-  const results = await runMatrix(matrix, { iterations: 10 });
+  const results = await runMatrix(matrix, { iterations: 10, ...fast });
   expect(results.variants).toHaveLength(1);
   expect(results.variants[0].id).toBe("stateful");
   expect(results.variants[0].cases).toHaveLength(2);
@@ -84,7 +87,7 @@ test("async setup in stateful variant", async () => {
     variants: { asyncSetup },
     cases: ["1", "2"],
   };
-  const results = await runMatrix(matrix, { iterations: 10 });
+  const results = await runMatrix(matrix, { iterations: 10, ...fast });
   expect(results.variants).toHaveLength(1);
   expect(results.variants[0].cases).toHaveLength(2);
 });
@@ -135,7 +138,7 @@ test("runMatrix with variantDir discovers and runs variants", async () => {
     variantDir: workerFixturesUrl,
     cases: ["a"],
   };
-  const results = await runMatrix(matrix, { iterations: 5 });
+  const results = await runMatrix(matrix, { iterations: 5, ...fast });
   expect(results.name).toBe("DirTest");
   const variantIds = results.variants.map(v => v.id).sort();
   expect(variantIds).toEqual(["fast", "slow"]);
@@ -147,7 +150,7 @@ test("runMatrix with variantDir runs each variant in isolated worker", async ()
     variantDir: workerFixturesUrl,
     cases: ["test"],
   };
-  const results = await runMatrix(matrix, { iterations: 3 });
+  const results = await runMatrix(matrix, { iterations: 3, ...fast });
   expect(results.variants).toHaveLength(2);
   for (const variant of results.variants) {
     expect(variant.cases).toHaveLength(1);
@@ -201,7 +204,7 @@ test("inline variants with casesModule", async () => {
     },
     casesModule: casesModuleUrl,
   };
-  const results = await runMatrix(matrix, { iterations: 5 });
+  const results = await runMatrix(matrix, { iterations: 5, ...fast });
   expect(results.variants).toHaveLength(2);
   expect(results.variants[0].cases).toHaveLength(2);
   const cases = results.variants[0].cases;
@@ -218,7 +221,7 @@ test("inline variants with async casesModule", async () => {
     },
     casesModule: asyncCasesUrl,
   };
-  const results = await runMatrix(matrix, { iterations: 5 });
+  const results = await runMatrix(matrix, { iterations: 5, ...fast });
   expect(results.variants).toHaveLength(1);
   expect(results.variants[0].cases).toHaveLength(2);
   expect(results.variants[0].cases.map(c => c.caseId)).toEqual([
@@ -233,7 +236,7 @@ test("variantDir with casesModule in worker", async () => {
     variantDir: casesVariantDirUrl,
     casesModule: casesModuleUrl,
   };
-  const results = await runMatrix(matrix, { iterations: 5 });
+  const results = await runMatrix(matrix, { iterations: 5, ...fast });
   const variantIds = results.variants.map(v => v.id).sort();
   expect(variantIds).toEqual(["product", "sum"]);
   const sum = results.variants.find(v => v.id === "sum");
@@ -274,7 +277,7 @@ test("baselineVariant with inline variants", async () => {
     },
     baselineVariant: "fast",
   };
-  const results = await runMatrix(matrix, { iterations: 20 });
+  const results = await runMatrix(matrix, { iterations: 20, ...fast });
   expect(results.variants).toHaveLength(2);
 
   const fastVariant = results.variants.find(v => v.id === "fast");
@@ -294,7 +297,7 @@ test("baselineVariant skips when variant not found", async () => {
     variants: { fast: () => {} },
     baselineVariant: "nonexistent",
   };
-  const result = await runMatrix(matrix);
+  const result = await runMatrix(matrix, fast);
   // No deltaPercent since baseline variant wasn't found
   expect(result.variants[0].cases[0].deltaPercent).toBeUndefined();
 });
@@ -306,7 +309,7 @@ test("baselineDir comparison", async () => {
     baselineDir: baselineDirUrl,
     cases: ["a"],
   };
-  const results = await runMatrix(matrix, { iterations: 10 });
+  const results = await runMatrix(matrix, { iterations: 10, ...fast });
 
   expect(results.variants).toHaveLength(2); // impl and extra
   const implVariant = results.variants.find(v => v.id === "impl");
@@ -328,7 +331,7 @@ test("baselineDir only applies to matching variants", async () => {
     baselineDir: baselineDirUrl,
     cases: ["a"],
   };
-  const results = await runMatrix(matrix, { iterations: 10 });
+  const results = await runMatrix(matrix, { iterations: 10, ...fast });
 
   const variantIds = results.variants.map(v => v.id).sort();
   expect(variantIds).toEqual(["extra", "impl"]);
@@ -350,7 +353,7 @@ test("baselineVariant with variantDir", async () => {
     baselineVariant: "impl",
     cases: ["a"],
   };
-  const results = await runMatrix(matrix, { iterations: 10 });
+  const results = await runMatrix(matrix, { iterations: 10, ...fast });
 
   const variantIds = results.variants.map(v => v.id).sort();
   expect(variantIds).toEqual(["extra", "impl"]);

package/src/test/BenchmarkReport.test.ts

@@ -1,18 +1,18 @@
 import { expect, test } from "vitest";
-import {
-  type BenchmarkReport,
-  reportResults,
-  valuesForReports,
-} from "../BenchmarkReport.ts";
-import {
-  adaptiveSection,
-  gcSection,
-  timeSection,
-} from "../StandardSections.ts";
+import { parseCliArgs } from "../cli/CliArgs.ts";
+import { defaultReport } from "../cli/CliReport.ts";
+import type {
+  BenchmarkReport,
+  ReportSection,
+} from "../report/BenchmarkReport.ts";
+import { integer } from "../report/Formatters.ts";
+import { gcSection } from "../report/GcSections.ts";
+import { adaptiveSections, timeSection } from "../report/StandardSections.ts";
+import { reportResults, valuesForReports } from "../report/text/TextReport.ts";
 import { createBenchmarkReport, createMeasuredResults } from "./TestUtils.ts";
 
 test("combines time and gc sections into report", () => {
-  const sections = [timeSection, gcSection] as const;
+  const sections = [timeSection, gcSection];
   const report = createBenchmarkReport("test", [100, 150]);
   const rows = valuesForReports([report], sections);
 
@@ -59,6 +59,56 @@ test("generates diff columns for baseline comparison", () => {
   expect(table).toContain("Δ%");
 });
 
+test("defaultReport uses custom sections when provided", () => {
+  const locSection: ReportSection = {
+    title: "throughput",
+    columns: [
+      {
+        key: "locPerSec",
+        title: "lines/sec",
+        formatter: integer,
+        comparable: true,
+        higherIsBetter: true,
+        statKind: "mean",
+        toDisplay: (ms: number, meta?: Record<string, unknown>) => {
+          const lines = (meta?.linesOfCode ?? 0) as number;
+          return lines / (ms / 1000);
+        },
+      },
+      {
+        key: "lines",
+        title: "lines",
+        formatter: integer,
+        value: (_r, meta) => meta?.linesOfCode ?? 0,
+      },
+    ],
+  };
+
+  const report: BenchmarkReport = {
+    name: "parse",
+    measuredResults: createMeasuredResults([100, 150]),
+    metadata: { linesOfCode: 500 },
+  };
+  const groups = [{ name: "parser", reports: [report] }];
+  const args = parseCliArgs(["--duration", "0.1"]);
+
+  const output = defaultReport(groups, args, { sections: [locSection] });
+  expect(output).toContain("throughput");
+  expect(output).toContain("lines/sec");
+  expect(output).toContain("500");
+  // Custom sections replace defaults: the time section's "mean" header should not appear.
+  expect(output).not.toContain("| mean ");
+});
+
+test("defaultReport falls back to CLI defaults without opts", () => {
+  const report = createBenchmarkReport("plain", [100, 150]);
+  const groups = [{ name: "g", reports: [report] }];
+  const args = parseCliArgs(["--duration", "0.1"]);
+  const output = defaultReport(groups, args);
+  expect(output).toContain("mean");
+  expect(output).toContain("runs");
+});
+
 test("formats adaptive convergence statistics", () => {
   const reports: BenchmarkReport[] = [
     createBenchmarkReport("test-adaptive", [400, 500], {
@@ -69,13 +119,13 @@ test("formats adaptive convergence statistics", () => {
     }),
   ];
 
-  const rows = valuesForReports(reports, [adaptiveSection]);
+  const rows = valuesForReports(reports, adaptiveSections);
   expect(rows[0].convergence).toBe(95);
   expect(rows[1].convergence).toBe(65);
 
   const table = reportResults(
     [{ name: "adaptive", reports }],
-    [adaptiveSection],
+    adaptiveSections,
   );
   expect(table).toContain("95%");
   expect(table).toMatch(/65%/);

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

@@ -1,12 +1,24 @@
 import path from "node:path";
-import { expect, test } from "vitest";
-import { profileBrowser } from "../browser/BrowserHeapSampler.ts";
+import { afterAll, beforeAll, expect, test } from "vitest";
+import { profileBrowser } from "../profiling/browser/BrowserProfiler.ts";
+import type { ChromeInstance } from "../profiling/browser/ChromeLauncher.ts";
+import { launchChrome } from "../profiling/browser/ChromeLauncher.ts";
+import { runBatched } from "../runners/MergeBatches.ts";
+import { computeStats } from "../runners/SampleStats.ts";
 
 const examplesDir = path.resolve(import.meta.dirname!, "../../examples");
 
+let chrome: ChromeInstance;
+
 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 });
+  const result = await profileBrowser({
+    url,
+    maxTime: 500,
+    gcStats: true,
+    headless: true,
+    chrome,
+  });
 
   expect(result.samples).toBeDefined();
   expect(result.samples!.length).toBeGreaterThan(5);
@@ -19,26 +31,183 @@ test("bench function mode (window.__bench)", { timeout: 30000 }, async () => {
   }
 });
 
-test("lap mode with N laps", { timeout: 30000 }, async () => {
-  const url = `file://${examplesDir}/browser-lap/index.html`;
-  const result = await profileBrowser({ url, gcStats: true });
+test("bench function with heap profiling", { timeout: 30000 }, async () => {
+  const url = `file://${examplesDir}/browser-heap/index.html`;
+  const result = await profileBrowser({
+    url,
+    maxTime: 500,
+    alloc: true,
+    headless: true,
+    chrome,
+  });
 
   expect(result.samples).toBeDefined();
-  expect(result.samples!).toHaveLength(100);
+  expect(result.samples!.length).toBeGreaterThan(5);
   expect(result.wallTimeMs).toBeGreaterThan(0);
-  expect(result.gcStats).toBeDefined();
-  for (const s of result.samples!) {
-    expect(s).toBeGreaterThanOrEqual(0);
-  }
+  expect(result.heapProfile).toBeDefined();
+  expect(result.heapProfile!.head).toBeDefined();
 });
 
-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 });
+test("bench function mode with call counts", { timeout: 30000 }, async () => {
+  const url = `file://${examplesDir}/browser-bench/index.html`;
+  const result = await profileBrowser({
+    url,
+    maxTime: 500,
+    callCounts: true,
+    headless: true,
+    chrome,
+  });
 
-  expect(result.samples).toBeDefined();
-  expect(result.samples!).toHaveLength(0);
-  expect(result.wallTimeMs).toBeGreaterThan(0);
+  expect(result.coverage).toBeDefined();
+  expect(result.coverage!.scripts.length).toBeGreaterThan(0);
+
+  // Find the benchmark page script
+  const pageScript = result.coverage!.scripts.find(s =>
+    s.url.includes("browser-bench"),
+  );
+  expect(pageScript).toBeDefined();
+
+  // The example defines buildArray, sortArray, mapToObjects, filterAndReduce
+  const fnNames = pageScript!.functions.map(f => f.functionName);
+  expect(fnNames).toContain("buildArray");
+  expect(fnNames).toContain("sortArray");
+
+  // buildArray is called once per __bench iteration; count should match
+  const buildArray = pageScript!.functions.find(
+    f => f.functionName === "buildArray",
+  );
+  expect(buildArray!.ranges[0].count).toBe(result.samples!.length);
+});
+
+test("page-load mode with navTiming", { timeout: 30000 }, async () => {
+  const url = `file://${examplesDir}/browser-page-load/index.html`;
+  const result = await profileBrowser({
+    url,
+    pageLoad: true,
+    alloc: true,
+    headless: true,
+    chrome,
+  });
+
+  expect(result.navTiming).toBeDefined();
+  expect(result.navTiming!.domContentLoaded).toBeGreaterThan(0);
+  expect(result.navTiming!.loadEvent).toBeGreaterThan(0);
+  expect(result.wallTimeMs).toBe(result.navTiming!.loadEvent);
   expect(result.heapProfile).toBeDefined();
   expect(result.heapProfile!.head).toBeDefined();
+  // page-load mode doesn't produce iteration samples
+  expect(result.samples).toBeUndefined();
+});
+
+test("page-load mode with call counts", { timeout: 30000 }, async () => {
+  const url = `file://${examplesDir}/browser-page-load/index.html`;
+  const result = await profileBrowser({
+    url,
+    pageLoad: true,
+    callCounts: true,
+    headless: true,
+    chrome,
+  });
+
+  expect(result.navTiming).toBeDefined();
+  expect(result.coverage).toBeDefined();
+  expect(result.coverage!.scripts.length).toBeGreaterThan(0);
+
+  const pageScript = result.coverage!.scripts.find(s =>
+    s.url.includes("browser-page-load"),
+  );
+  expect(pageScript).toBeDefined();
+  const fnNames = pageScript!.functions.map(f => f.functionName);
+  expect(fnNames).toContain("buildItems");
+  expect(fnNames).toContain("renderItems");
+});
+
+test("page-load mode with gc stats", { timeout: 30000 }, async () => {
+  const url = `file://${examplesDir}/browser-page-load/index.html`;
+  const result = await profileBrowser({
+    url,
+    pageLoad: true,
+    gcStats: true,
+    headless: true,
+    chrome,
+  });
+
+  expect(result.navTiming).toBeDefined();
+  expect(result.gcStats).toBeDefined();
+  expect(result.gcStats!.scavenges).toBeGreaterThanOrEqual(0);
+});
+
+test("multi-page-load batching with auto-detect", {
+  timeout: 60000,
+}, async () => {
+  const url = `file://${examplesDir}/browser-page-load/index.html`;
+
+  // Simulate the probing approach: first call detects page-load, rest use multi-load
+  let detectedPageLoad = false;
+  const pageLoadIters = 3;
+
+  const runner = async () => {
+    if (detectedPageLoad) {
+      const raws = [];
+      for (let i = 0; i < pageLoadIters; i++)
+        raws.push(
+          await profileBrowser({ url, headless: true, chrome, pageLoad: true }),
+        );
+      const samples = raws.map(r => r.wallTimeMs ?? 0);
+      return { name: "page-load", samples, time: computeStats(samples) };
+    }
+    // Probe: first call without pageLoad flag, auto-detects
+    const raw = await profileBrowser({ url, headless: true, chrome });
+    if (!raw.samples?.length && raw.navTiming) detectedPageLoad = true;
+    return {
+      name: "page-load",
+      samples: [raw.wallTimeMs ?? 0],
+      time: computeStats([raw.wallTimeMs ?? 0]),
+    };
+  };
+
+  const {
+    results: [current],
+  } = await runBatched([runner], undefined, 3, false);
+
+  // 3 batches: batch 0 (probe, 1 sample, dropped), batch 1 (3 samples), batch 2 (3 samples)
+  expect(current.samples.length).toBe(6);
+  expect(current.batchOffsets).toEqual([0, 3]);
+  for (const s of current.samples) expect(s).toBeGreaterThan(0);
+});
+
+test("batched fresh tabs with baseline-url", { timeout: 60000 }, async () => {
+  const benchUrl = `file://${examplesDir}/browser-bench/index.html`;
+  const baselineUrl = `file://${examplesDir}/browser-bench/index.html`;
+  const params = { maxTime: 200, headless: true, chrome };
+
+  const toMeasured = (name: string) => async () => {
+    const raw = await profileBrowser({ ...params, url: name });
+    const samples = raw.samples?.length ? raw.samples : [raw.wallTimeMs ?? 0];
+    return { name, samples, time: computeStats(samples) };
+  };
+
+  const {
+    results: [current],
+    baseline,
+  } = await runBatched(
+    [toMeasured(benchUrl)],
+    toMeasured(baselineUrl),
+    2,
+    false,
+  );
+
+  // warmup batch dropped: 2 batches - 1 warmup = 1 batch each
+  expect(current.samples.length).toBeGreaterThan(0);
+  expect(current.batchOffsets).toEqual([0]); // single batch after warmup drop
+  expect(baseline).toBeDefined();
+  expect(baseline!.samples.length).toBeGreaterThan(0);
+});
+
+beforeAll(async () => {
+  chrome = await launchChrome({ headless: true });
+}, 30_000);
+
+afterAll(async () => {
+  await chrome?.close();
 });

package/src/test/BrowserBench.test.ts

@@ -2,8 +2,8 @@ import { expect, test } from "vitest";
 import {
   browserGcStats,
   parseGcTraceEvents,
-  type TraceEvent,
-} from "../browser/BrowserGcStats.ts";
+} from "../profiling/browser/BrowserGcStats.ts";
+import type { TraceEvent } from "../profiling/browser/ChromeTraceEvent.ts";
 
 test("parseGcTraceEvents parses MinorGC and MajorGC events", () => {
   const events: TraceEvent[] = [
@@ -11,6 +11,7 @@ test("parseGcTraceEvents parses MinorGC and MajorGC events", () => {
       cat: "v8.gc",
       name: "MinorGC",
       ph: "X",
+      ts: 0,
       dur: 500,
       args: { usedHeapSizeBefore: 10000, usedHeapSizeAfter: 8000 },
     },
@@ -18,6 +19,7 @@ test("parseGcTraceEvents parses MinorGC and MajorGC events", () => {
       cat: "v8.gc",
       name: "MajorGC",
       ph: "X",
+      ts: 0,
       dur: 12000,
       args: { usedHeapSizeBefore: 50000, usedHeapSizeAfter: 30000 },
     },
@@ -38,9 +40,9 @@ test("parseGcTraceEvents parses MinorGC and MajorGC events", () => {
 
 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
+    { cat: "v8.gc", name: "MinorGC", ph: "B", ts: 0, dur: 500 }, // not complete
+    { cat: "v8", name: "V8.Execute", ph: "X", ts: 0, dur: 100 }, // not GC
+    { cat: "v8.gc", name: "MinorGC", ph: "X", ts: 0 }, // valid, missing dur/args
   ];
   const parsed = parseGcTraceEvents(events);
   expect(parsed).toHaveLength(1);
@@ -53,6 +55,7 @@ test("browserGcStats aggregates trace events into GcStats", () => {
       cat: "v8.gc",
       name: "MinorGC",
       ph: "X",
+      ts: 0,
       dur: 300,
       args: { usedHeapSizeBefore: 5000, usedHeapSizeAfter: 3000 },
     },
@@ -60,6 +63,7 @@ test("browserGcStats aggregates trace events into GcStats", () => {
       cat: "v8.gc",
       name: "MinorGC",
       ph: "X",
+      ts: 0,
       dur: 200,
       args: { usedHeapSizeBefore: 6000, usedHeapSizeAfter: 4000 },
     },
@@ -67,6 +71,7 @@ test("browserGcStats aggregates trace events into GcStats", () => {
       cat: "v8.gc",
       name: "MajorGC",
       ph: "X",
+      ts: 0,
       dur: 8000,
       args: { usedHeapSizeBefore: 40000, usedHeapSizeAfter: 20000 },
     },