benchforge 0.1.9 → 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,9 +1,9 @@
-import { expect, test } from "vitest";
-import type { BenchSuite } from "../Benchmark.ts";
-import type { BenchmarkReport } from "../BenchmarkReport.ts";
-import { parseBenchArgs, runBenchmarks } from "../cli/RunBenchCLI.ts";
+import { expect } from "vitest";
+import { parseBenchArgs } from "../cli/RunBenchCLI.ts";
+import type { BenchmarkReport } from "../report/BenchmarkReport.ts";
+import type { BenchSuite } from "../runners/BenchmarkSpec.ts";
 
-const statisticalSuite: BenchSuite = {
+const _statisticalSuite: BenchSuite = {
   name: "Statistical Test Suite",
   groups: [
     {
@@ -31,7 +31,7 @@ const statisticalSuite: BenchSuite = {
   ],
 };
 
-const gcSuite: BenchSuite = {
+const _gcSuite: BenchSuite = {
   name: "GC Test Suite",
   groups: [
     {
@@ -52,7 +52,7 @@ const gcSuite: BenchSuite = {
   ],
 };
 
-function parseAdaptiveArgs() {
+function _parseAdaptiveArgs() {
   return parseBenchArgs((yargs: any) =>
     yargs
       .option("adaptive", { type: "boolean", default: true })
@@ -61,7 +61,7 @@ function parseAdaptiveArgs() {
   );
 }
 
-function verifyStatisticalMetrics(report: BenchmarkReport): void {
+function _verifyStatisticalMetrics(report: BenchmarkReport): void {
   const { time, convergence } = report.measuredResults;
   expect(time).toBeDefined();
   expect(time?.p25).toBeDefined();
@@ -77,7 +77,7 @@ function verifyStatisticalMetrics(report: BenchmarkReport): void {
   expect(convergence?.reason).toBeDefined();
 }
 
-function verifyPercentileOrdering(report: BenchmarkReport): void {
+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);
@@ -85,35 +85,3 @@ function verifyPercentileOrdering(report: BenchmarkReport): void {
     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/{tests → test}/BenchMatrix.test.ts

@@ -1,9 +1,24 @@
 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";
 
+const discoverUrl = `file://${import.meta.dirname}/fixtures/discover/`;
+
+const workerFixturesUrl = `file://${import.meta.dirname}/fixtures/worker/`;
+
+const casesFixturesUrl = `file://${import.meta.dirname}/fixtures/cases`;
+const casesModuleUrl = `${casesFixturesUrl}/cases.ts`;
+const asyncCasesUrl = `${casesFixturesUrl}/asyncCases.ts`;
+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",
@@ -15,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"]);
@@ -35,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);
@@ -53,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);
@@ -72,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);
 });
@@ -92,8 +107,6 @@ test("error when no variants provided", async () => {
   );
 });
 
-const discoverUrl = `file://${import.meta.dirname}/fixtures/discover/`;
-
 test("discoverVariants finds .ts files", async () => {
   const variants = await discoverVariants(discoverUrl);
   expect(variants.sort()).toEqual(["fast", "slow"]);
@@ -119,15 +132,13 @@ test("loadVariant throws when run is missing", async () => {
   );
 });
 
-const workerFixturesUrl = `file://${import.meta.dirname}/fixtures/worker/`;
-
 test("runMatrix with variantDir discovers and runs variants", async () => {
   const matrix: BenchMatrix = {
     name: "DirTest",
     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"]);
@@ -139,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);
@@ -147,11 +158,6 @@ test("runMatrix with variantDir runs each variant in isolated worker", async ()
   }
 });
 
-const casesFixturesUrl = `file://${import.meta.dirname}/fixtures/cases`;
-const casesModuleUrl = `${casesFixturesUrl}/cases.ts`;
-const asyncCasesUrl = `${casesFixturesUrl}/asyncCases.ts`;
-const casesVariantDirUrl = `${casesFixturesUrl}/variants/`;
-
 test("loadCasesModule loads cases array", async () => {
   const mod = await loadCasesModule(casesModuleUrl);
   expect(mod.cases).toEqual(["small", "large"]);
@@ -198,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;
@@ -215,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([
@@ -230,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");
@@ -271,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");
@@ -291,14 +297,11 @@ 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();
 });
 
-const variantsDirUrl = `file://${import.meta.dirname}/fixtures/variants/`;
-const baselineDirUrl = `file://${import.meta.dirname}/fixtures/baseline/`;
-
 test("baselineDir comparison", async () => {
   const matrix: BenchMatrix = {
     name: "BaselineDirTest",
@@ -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();
 });