benchforge 0.1.8 → 0.1.11

package/src/table-util/Formatters.ts

@@ -74,23 +74,6 @@ export function diffPercentBenchmark(main: unknown, base: unknown): string {
   return coloredPercent(diff, base, false); // negative is good for benchmarks
 }
 
-/** Format fraction as colored +/- percentage */
-function coloredPercent(
-  numerator: number,
-  denominator: number,
-  positiveIsGreen = true,
-): string {
-  const fraction = numerator / denominator;
-  if (Number.isNaN(fraction) || !Number.isFinite(fraction)) {
-    return " ";
-  }
-  const positive = fraction >= 0;
-  const sign = positive ? "+" : "-";
-  const percentStr = `${sign}${percent(fraction)}`;
-  const isGood = positive === positiveIsGreen;
-  return isGood ? green(percentStr) : red(percentStr);
-}
-
 /** Format memory size in KB with appropriate units */
 export function memoryKB(kb: unknown): string | null {
   if (typeof kb !== "number") return null;
@@ -98,14 +81,19 @@ export function memoryKB(kb: unknown): string | null {
   return `${(kb / 1024).toFixed(1)}MB`;
 }
 
-/** Format bytes with appropriate units (B, KB, MB, GB) */
-export function formatBytes(bytes: unknown): string | null {
+/** Format bytes with appropriate units (B, KB, MB, GB).
+ *  Use `space: true` for human-readable console output (`1.5 KB`). */
+export function formatBytes(
+  bytes: unknown,
+  opts?: { space?: boolean },
+): string | null {
   if (typeof bytes !== "number") return null;
-  if (bytes < 1024) return `${bytes.toFixed(0)}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  const s = opts?.space ? " " : "";
+  if (bytes < 1024) return `${bytes.toFixed(0)}${s}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}${s}KB`;
   if (bytes < 1024 * 1024 * 1024)
-    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
-  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}GB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)}${s}MB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}${s}GB`;
 }
 
 /** Format percentage difference with confidence interval */
@@ -123,9 +111,31 @@ export function formatDiffWithCIHigherIsBetter(value: unknown): string | null {
   return colorByDirection(diffCIText(-percent, [-ci[1], -ci[0]]), direction);
 }
 
-/** @return formatted "pct [lo, hi]" text for a diff with CI */
-function diffCIText(pct: number, ci: [number, number]): string {
-  return `${formatBound(pct)} [${formatBound(ci[0])}, ${formatBound(ci[1])}]`;
+/** @return truncated string with ellipsis if over maxLen */
+export function truncate(str: string, maxLen = 30): string {
+  return str.length > maxLen ? str.slice(0, maxLen - 3) + "..." : str;
+}
+
+/** Format fraction as colored +/- percentage */
+function coloredPercent(
+  numerator: number,
+  denominator: number,
+  positiveIsGreen = true,
+): string {
+  const fraction = numerator / denominator;
+  if (Number.isNaN(fraction) || !Number.isFinite(fraction)) {
+    return " ";
+  }
+  const positive = fraction >= 0;
+  const sign = positive ? "+" : "-";
+  const percentStr = `${sign}${percent(fraction)}`;
+  const isGood = positive === positiveIsGreen;
+  return isGood ? green(percentStr) : red(percentStr);
+}
+
+/** @return true if value is a DifferenceCI object */
+function isDifferenceCI(x: unknown): x is DifferenceCI {
+  return typeof x === "object" && x !== null && "ci" in x && "direction" in x;
 }
 
 /** @return text colored green for faster, red for slower */
@@ -135,18 +145,13 @@ function colorByDirection(text: string, direction: CIDirection): string {
   return text;
 }
 
+/** @return formatted "pct [lo, hi]" text for a diff with CI */
+function diffCIText(pct: number, ci: [number, number]): string {
+  return `${formatBound(pct)} [${formatBound(ci[0])}, ${formatBound(ci[1])}]`;
+}
+
 /** @return signed percentage string (e.g. "+1.2%", "-3.4%") */
 function formatBound(v: number): string {
   const sign = v >= 0 ? "+" : "";
   return `${sign}${v.toFixed(1)}%`;
 }
-
-/** @return true if value is a DifferenceCI object */
-function isDifferenceCI(x: unknown): x is DifferenceCI {
-  return typeof x === "object" && x !== null && "ci" in x && "direction" in x;
-}
-
-/** @return truncated string with ellipsis if over maxLen */
-export function truncate(str: string, maxLen = 30): string {
-  return str.length > maxLen ? str.slice(0, maxLen - 3) + "..." : str;
-}

package/src/table-util/TableReport.ts

@@ -3,9 +3,6 @@ import type { Alignment, SpanningCellConfig, TableUserConfig } from "table";
 import { table } from "table";
 import { diffPercent } from "./Formatters.ts";
 
-const isTest = process.env.NODE_ENV === "test" || process.env.VITEST === "true";
-const { bold } = isTest ? { bold: (str: string) => str } : pico;
-
 /** Related table columns */
 export interface ColumnGroup<T> {
   groupTitle?: string;
@@ -20,6 +17,19 @@ export interface Column<T> extends ColumnFormat<T> {
   diffKey?: undefined;
 }
 
+/** Table headers and configuration */
+export interface TableSetup {
+  headerRows: string[][];
+  config: TableUserConfig;
+}
+
+/** Data rows with optional baseline */
+export interface ResultGroup<T extends Record<string, any>> {
+  results: T[];
+
+  baseline?: T;
+}
+
 /** Comparison column against baseline */
 interface DiffColumn<T> extends ColumnFormat<T> {
   diffFormatter?: (value: unknown, baseline: unknown) => string | null;
@@ -38,18 +48,19 @@ interface ColumnFormat<T> {
   width?: number;
 }
 
-/** Table headers and configuration */
-export interface TableSetup {
-  headerRows: string[][];
-  config: TableUserConfig;
+interface Lines {
+  drawHorizontalLine: (index: number, size: number) => boolean;
+  drawVerticalLine: (index: number, size: number) => boolean;
 }
 
-/** Data rows with optional baseline */
-export interface ResultGroup<T extends Record<string, any>> {
-  results: T[];
+const isTest = process.env.NODE_ENV === "test" || process.env.VITEST === "true";
+const { bold } = isTest ? { bold: (str: string) => str } : pico;
 
-  baseline?: T;
-}
+// Regex to strip ANSI escape codes (ESC [ ... m sequences)
+const ansiEscapeRegex = new RegExp(
+  String.fromCharCode(27) + "\\[[0-9;]*m",
+  "g",
+);
 
 /** Build formatted table with column groups and baselines */
 export function buildTable<T extends Record<string, any>>(
@@ -61,73 +72,6 @@ export function buildTable<T extends Record<string, any>>(
   return createTable(columnGroups, allRecords);
 }
 
-/** Convert columns and records to formatted table */
-function createTable<T extends Record<string, any>>(
-  groups: ColumnGroup<T>[],
-  records: T[],
-): string {
-  const dataRows = toRows(records, groups);
-  const { headerRows, config } = setup(groups, dataRows);
-  const allRows = [...headerRows, ...dataRows];
-  return table(allRows, config);
-}
-
-/** Create header rows with group titles */
-function createGroupHeaders<T>(
-  groups: ColumnGroup<T>[],
-  numColumns: number,
-): string[][] {
-  if (!groups.some(g => g.groupTitle)) return [];
-
-  const sectionRow = groups.flatMap(g => {
-    const title = g.groupTitle ? [bold(g.groupTitle)] : [];
-    return padWithBlanks(title, g.columns.length);
-  });
-  const blankRow = padWithBlanks([], numColumns);
-  return [sectionRow, blankRow];
-}
-
-interface Lines {
-  drawHorizontalLine: (index: number, size: number) => boolean;
-  drawVerticalLine: (index: number, size: number) => boolean;
-}
-
-/** @return draw functions for horizontal/vertical table borders */
-function createLines<T>(groups: ColumnGroup<T>[]): Lines {
-  const { sectionBorders, headerBottom } = calcBorders(groups);
-
-  function drawVerticalLine(index: number, size: number): boolean {
-    return index === 0 || index === size || sectionBorders.includes(index);
-  }
-  function drawHorizontalLine(index: number, size: number): boolean {
-    return index === 0 || index === size || index === headerBottom;
-  }
-  return { drawHorizontalLine, drawVerticalLine };
-}
-
-/** @return spanning cell configs for group title headers */
-function createSectionSpans<T>(groups: ColumnGroup<T>[]): SpanningCellConfig[] {
-  let col = 0;
-  const alignment: Alignment = "center";
-  return groups.map(g => {
-    const colSpan = g.columns.length;
-    const span = { row: 0, col, colSpan, alignment };
-    col += colSpan;
-    return span;
-  });
-}
-
-/** @return bolded column title strings */
-function getTitles<T>(groups: ColumnGroup<T>[]): string[] {
-  return groups.flatMap(g => g.columns.map(c => bold(c.title || " ")));
-}
-
-/** @return array padded with blank strings to the given length */
-function padWithBlanks(arr: string[], length: number): string[] {
-  if (arr.length >= length) return arr;
-  return [...arr, ...Array(length - arr.length).fill(" ")];
-}
-
 /** Convert records to string arrays for table */
 export function toRows<T extends Record<string, any>>(
   records: T[],
@@ -145,28 +89,6 @@ export function toRows<T extends Record<string, any>>(
   return rawRows.map(row => row.map(cell => cell ?? " "));
 }
 
-/** Add comparison values for diff columns */
-function addComparisons<T extends Record<string, any>>(
-  groups: ColumnGroup<T>[],
-  mainRecord: T,
-  baselineRecord: T,
-): T {
-  const diffColumns = groups.flatMap(g => g.columns).filter(col => col.diffKey);
-  const updatedMain = { ...mainRecord };
-
-  for (const col of diffColumns) {
-    const dcol = col as DiffColumn<T>;
-    const diffKey = dcol.diffKey;
-    const mainValue = mainRecord[diffKey];
-    const baselineValue = baselineRecord[diffKey];
-    const diffFormat = dcol.diffFormatter ?? diffPercent;
-    const diffStr = diffFormat(mainValue, baselineValue);
-    (updatedMain as any)[col.key] = diffStr;
-  }
-
-  return updatedMain;
-}
-
 /** Flatten groups with spacing */
 function flattenGroups<T extends Record<string, any>>(
   columnGroups: ColumnGroup<T>[],
@@ -181,6 +103,17 @@ function flattenGroups<T extends Record<string, any>>(
   });
 }
 
+/** Convert columns and records to formatted table */
+function createTable<T extends Record<string, any>>(
+  groups: ColumnGroup<T>[],
+  records: T[],
+): string {
+  const dataRows = toRows(records, groups);
+  const { headerRows, config } = setup(groups, dataRows);
+  const allRows = [...headerRows, ...dataRows];
+  return table(allRows, config);
+}
+
 /** Process results with baseline comparisons */
 function addBaseline<T extends Record<string, any>>(
   columnGroups: ColumnGroup<T>[],
@@ -203,22 +136,6 @@ function addBaseline<T extends Record<string, any>>(
   return [...diffResults, markedBaseline];
 }
 
-/** Calculate vertical lines between sections and header bottom position */
-function calcBorders<T>(groups: ColumnGroup<T>[]): {
-  sectionBorders: number[];
-  headerBottom: number;
-} {
-  if (groups.length === 0) return { sectionBorders: [], headerBottom: 1 };
-
-  const sectionBorders: number[] = [];
-  let border = 0;
-  for (const g of groups) {
-    border += g.columns.length;
-    sectionBorders.push(border);
-  }
-  return { sectionBorders, headerBottom: 3 };
-}
-
 /** Create headers and table configuration */
 function setup<T>(groups: ColumnGroup<T>[], dataRows: string[][]): TableSetup {
   const titles = getTitles(groups);
@@ -237,6 +154,60 @@ function setup<T>(groups: ColumnGroup<T>[], dataRows: string[][]): TableSetup {
   return { headerRows, config };
 }
 
+/** Add comparison values for diff columns */
+function addComparisons<T extends Record<string, any>>(
+  groups: ColumnGroup<T>[],
+  mainRecord: T,
+  baselineRecord: T,
+): T {
+  const diffColumns = groups.flatMap(g => g.columns).filter(col => col.diffKey);
+  const updatedMain = { ...mainRecord };
+
+  for (const col of diffColumns) {
+    const dcol = col as DiffColumn<T>;
+    const diffKey = dcol.diffKey;
+    const mainValue = mainRecord[diffKey];
+    const baselineValue = baselineRecord[diffKey];
+    const diffFormat = dcol.diffFormatter ?? diffPercent;
+    const diffStr = diffFormat(mainValue, baselineValue);
+    (updatedMain as any)[col.key] = diffStr;
+  }
+
+  return updatedMain;
+}
+
+/** @return bolded column title strings */
+function getTitles<T>(groups: ColumnGroup<T>[]): string[] {
+  return groups.flatMap(g => g.columns.map(c => bold(c.title || " ")));
+}
+
+/** Create header rows with group titles */
+function createGroupHeaders<T>(
+  groups: ColumnGroup<T>[],
+  numColumns: number,
+): string[][] {
+  if (!groups.some(g => g.groupTitle)) return [];
+
+  const sectionRow = groups.flatMap(g => {
+    const title = g.groupTitle ? [bold(g.groupTitle)] : [];
+    return padWithBlanks(title, g.columns.length);
+  });
+  const blankRow = padWithBlanks([], numColumns);
+  return [sectionRow, blankRow];
+}
+
+/** @return spanning cell configs for group title headers */
+function createSectionSpans<T>(groups: ColumnGroup<T>[]): SpanningCellConfig[] {
+  let col = 0;
+  const alignment: Alignment = "center";
+  return groups.map(g => {
+    const colSpan = g.columns.length;
+    const span = { row: 0, col, colSpan, alignment };
+    col += colSpan;
+    return span;
+  });
+}
+
 /** Calculate column widths based on content, including group titles */
 function calcColumnWidths<T>(
   groups: ColumnGroup<T>[],
@@ -279,11 +250,24 @@ function calcColumnWidths<T>(
   );
 }
 
-// Regex to strip ANSI escape codes (ESC [ ... m sequences)
-const ansiEscapeRegex = new RegExp(
-  String.fromCharCode(27) + "\\[[0-9;]*m",
-  "g",
-);
+/** @return draw functions for horizontal/vertical table borders */
+function createLines<T>(groups: ColumnGroup<T>[]): Lines {
+  const { sectionBorders, headerBottom } = calcBorders(groups);
+
+  function drawVerticalLine(index: number, size: number): boolean {
+    return index === 0 || index === size || sectionBorders.includes(index);
+  }
+  function drawHorizontalLine(index: number, size: number): boolean {
+    return index === 0 || index === size || index === headerBottom;
+  }
+  return { drawHorizontalLine, drawVerticalLine };
+}
+
+/** @return array padded with blank strings to the given length */
+function padWithBlanks(arr: string[], length: number): string[] {
+  if (arr.length >= length) return arr;
+  return [...arr, ...Array(length - arr.length).fill(" ")];
+}
 
 /** Get visible length of a cell value (strips ANSI escape codes) */
 function cellWidth(value: unknown): number {
@@ -291,3 +275,19 @@ function cellWidth(value: unknown): number {
   const str = String(value);
   return str.replace(ansiEscapeRegex, "").length;
 }
+
+/** Calculate vertical lines between sections and header bottom position */
+function calcBorders<T>(groups: ColumnGroup<T>[]): {
+  sectionBorders: number[];
+  headerBottom: number;
+} {
+  if (groups.length === 0) return { sectionBorders: [], headerBottom: 1 };
+
+  const sectionBorders: number[] = [];
+  let border = 0;
+  for (const g of groups) {
+    border += g.columns.length;
+    sectionBorders.push(border);
+  }
+  return { sectionBorders, headerBottom: 3 };
+}

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

@@ -55,15 +55,6 @@ function getGroupColumnIndex(
   );
 }
 
-/** 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,
@@ -91,6 +82,15 @@ function splitColumnGroups(line: string): string[] {
   return line.split("│").map(col => col.trim());
 }
 
+/** 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);
+}
+
 /** Split on 2+ whitespace or '│' borders, so single-space titles like "L1 miss" survive. */
 function splitColumns(line: string): string[] {
   return line

package/src/test/AdaptiveStatistics.integration.ts

@@ -1,9 +1,9 @@
-import { expect, test } from "vitest";
+import { expect } from "vitest";
 import type { BenchSuite } from "../Benchmark.ts";
 import type { BenchmarkReport } from "../BenchmarkReport.ts";
-import { parseBenchArgs, runBenchmarks } from "../cli/RunBenchCLI.ts";
+import { parseBenchArgs } from "../cli/RunBenchCLI.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/test/HeapAttribution.test.ts

@@ -0,0 +1,51 @@
+import { expect, test } from "vitest";
+import {
+  aggregateSites,
+  type HeapSite,
+} from "../heap-sample/HeapSampleReport.ts";
+
+test("unknown column does not merge distinct functions on same line", () => {
+  const sites: HeapSite[] = [
+    { fn: "Foo", url: "test.ts", line: 10, col: undefined, bytes: 100 },
+    { fn: "Bar", url: "test.ts", line: 10, col: undefined, bytes: 200 },
+  ];
+  const aggregated = aggregateSites(sites);
+  expect(aggregated).toHaveLength(2);
+});
+
+test("same column merges regardless of function name", () => {
+  const sites: HeapSite[] = [
+    { fn: "Foo", url: "test.ts", line: 10, col: 5, bytes: 100 },
+    { fn: "Foo", url: "test.ts", line: 10, col: 5, bytes: 200 },
+  ];
+  const aggregated = aggregateSites(sites);
+  expect(aggregated).toHaveLength(1);
+  expect(aggregated[0].bytes).toBe(300);
+});
+
+test("aggregation preserves distinct caller stacks", () => {
+  const stackA = [
+    { fn: "root", url: "a.ts", line: 1, col: 0 },
+    { fn: "foo", url: "a.ts", line: 10, col: 0 },
+    { fn: "alloc", url: "a.ts", line: 20, col: 5 },
+  ];
+  const stackB = [
+    { fn: "root", url: "a.ts", line: 1, col: 0 },
+    { fn: "bar", url: "a.ts", line: 15, col: 0 },
+    { fn: "alloc", url: "a.ts", line: 20, col: 5 },
+  ];
+  const sites: HeapSite[] = [
+    { fn: "alloc", url: "a.ts", line: 20, col: 5, bytes: 800, stack: stackA },
+    { fn: "alloc", url: "a.ts", line: 20, col: 5, bytes: 200, stack: stackB },
+  ];
+  const aggregated = aggregateSites(sites);
+
+  expect(aggregated).toHaveLength(1);
+  expect(aggregated[0].bytes).toBe(1000);
+  expect(aggregated[0].callers).toHaveLength(2);
+  // Primary stack should be the highest-bytes path (foo)
+  expect(aggregated[0].stack![1].fn).toBe("foo");
+  // Callers sorted by bytes descending
+  expect(aggregated[0].callers![0].bytes).toBe(800);
+  expect(aggregated[0].callers![1].bytes).toBe(200);
+});

package/src/test/RunBenchCLI.test.ts

@@ -49,6 +49,24 @@ const suiteWithSetup: BenchSuite = {
   ],
 };
 
+/** Execute test fixture script and return output */
+function executeTestScript(args = ""): string {
+  const script = path.join(
+    import.meta.dirname!,
+    "fixtures/test-bench-script.ts",
+  );
+  return execSync(`node --expose-gc --allow-natives-syntax ${script} ${args}`, {
+    encoding: "utf8",
+  });
+}
+
+/** Run a fixture file via bin/benchforge and return output */
+function executeBenchforgeFile(file: string, args = ""): string {
+  const bin = path.join(import.meta.dirname!, "../../bin/benchforge");
+  const fixture = path.join(import.meta.dirname!, "fixtures", file);
+  return execSync(`${bin} ${fixture} ${args}`, { encoding: "utf8" });
+}
+
 test("runs all benchmarks", { timeout: 30000 }, async () => {
   const output = await runBenchCLITest(testSuite, "--time 0.1");
 
@@ -87,17 +105,6 @@ test("filter preserves suite structure", () => {
   expect(filtered.groups[1].benchmarks).toHaveLength(0);
 });
 
-/** Execute test fixture script and return output */
-function executeTestScript(args = ""): string {
-  const script = path.join(
-    import.meta.dirname!,
-    "fixtures/test-bench-script.ts",
-  );
-  return execSync(`node --expose-gc --allow-natives-syntax ${script} ${args}`, {
-    encoding: "utf8",
-  });
-}
-
 test("e2e: runs user script", { timeout: 30000 }, () => {
   const output = executeTestScript("--time 0.1");
 
@@ -164,3 +171,21 @@ test(
     expect(output).toContain("mean");
   },
 );
+
+test("file mode: BenchSuite export", { timeout: 30000 }, () => {
+  const output = executeBenchforgeFile(
+    "suite-export-bench.ts",
+    "--iterations 5",
+  );
+
+  expect(output).toContain("plus");
+  expect(output).toContain("multiply");
+  expect(output).toContain("runs");
+});
+
+test("file mode: function export", { timeout: 30000 }, () => {
+  const output = executeBenchforgeFile("fn-export-bench.ts", "--iterations 5");
+
+  expect(output).toContain("fn-export-bench");
+  expect(output).toContain("runs");
+});