benchforge 0.1.8 → 0.1.11

package/dist/{src-HfimYuW_.mjs → src-B-DDaCa9.mjs}

@@ -1,14 +1,15 @@
-import { a as createAdaptiveWrapper, c as BasicRunner, i as createRunner, l as computeStats, n as getElapsed, o as average, r as getPerfNow, s as bootstrapDifferenceCI, t as debugWorkerTiming, u as discoverVariants } from "./TimingUtils-ClclVQ7E.mjs";
-import { n as parseGcLine, t as aggregateGcStats } from "./GcStats-ByEovUi1.mjs";
+import { a as createAdaptiveWrapper, c as BasicRunner, i as createRunner, l as computeStats, n as getElapsed, o as average, r as getPerfNow, s as bootstrapDifferenceCI, t as debugWorkerTiming, u as discoverVariants } from "./TimingUtils-DwOwkc8G.mjs";
+import { n as parseGcLine, t as aggregateGcStats } from "./GcStats-wX7Xyblu.mjs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { execSync, fork, spawn } from "node:child_process";
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import path, { dirname, extname, join, resolve } from "node:path";
+import path, { basename, dirname, extname, join, resolve } from "node:path";
 import pico from "picocolors";
 import { table } from "table";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
+import { tmpdir } from "node:os";
 import { createServer } from "node:http";
 import open from "open";
 
@@ -50,6 +51,25 @@ async function runBenchmark({ spec, runner, options, useWorker = false, params }
 		params
 	});
 }
+/** Run a matrix variant benchmark in isolated worker process */
+async function runMatrixVariant(params) {
+	const { variantDir, variantId, caseId, caseData, casesModule, runner, options } = params;
+	const name = `${variantId}/${caseId}`;
+	return runWorkerWithMessage(name, options, {
+		type: "run",
+		spec: {
+			name,
+			fn: () => {}
+		},
+		runnerName: runner,
+		options,
+		variantDir,
+		variantId,
+		caseId,
+		caseData,
+		casesModule
+	});
+}
 /** Resolve modulePath/exportName to a real function for non-worker mode */
 async function resolveModuleSpec(spec, params) {
 	const module = await import(spec.modulePath);
@@ -81,6 +101,34 @@ async function runInWorker(workerParams) {
 	const msg = createRunMessage(spec, runner, options, params);
 	return runWorkerWithMessage(spec.name, options, msg);
 }
+/** Spawn worker, wire handlers, send message, return results */
+function runWorkerWithMessage(name, options, message) {
+	const startTime = getPerfNow();
+	const collectGcStats = options.gcStats ?? false;
+	logTiming(`Starting worker for ${name}`);
+	return new Promise((resolve, reject) => {
+		const { worker, createTime, gcEvents } = createWorkerWithTiming(collectGcStats);
+		setupWorkerHandlers(worker, name, createWorkerHandlers(name, startTime, gcEvents, resolve, reject));
+		sendWorkerMessage(worker, message, createTime);
+	});
+}
+/** Create message for worker execution */
+function createRunMessage(spec, runnerName, options, params) {
+	const { fn, ...rest } = spec;
+	const message = {
+		type: "run",
+		spec: rest,
+		runnerName,
+		options,
+		params
+	};
+	if (spec.modulePath) {
+		message.modulePath = spec.modulePath;
+		message.exportName = spec.exportName;
+		if (spec.setupExportName) message.setupExportName = spec.setupExportName;
+	} else message.fnCode = fn.toString();
+	return message;
+}
 /** Create worker process with timing logs */
 function createWorkerWithTiming(gcStats) {
 	const workerStart = getPerfNow();
@@ -95,6 +143,49 @@ function createWorkerWithTiming(gcStats) {
 		gcEvents
 	};
 }
+/** @return handlers that attach GC stats and heap profile to results */
+function createWorkerHandlers(specName, startTime, gcEvents, resolve, reject) {
+	return {
+		resolve: (results, heapProfile) => {
+			logTiming(`Total worker time for ${specName}: ${getElapsed(startTime).toFixed(1)}ms`);
+			if (gcEvents?.length) {
+				const gcStats = aggregateGcStats(gcEvents);
+				for (const r of results) r.gcStats = gcStats;
+			}
+			if (heapProfile) for (const r of results) r.heapProfile = heapProfile;
+			resolve(results);
+		},
+		reject
+	};
+}
+/** Setup worker event handlers with cleanup */
+function setupWorkerHandlers(worker, specName, handlers) {
+	const { resolve, reject } = handlers;
+	const cleanup = createCleanup(worker, specName, reject);
+	worker.on("message", createMessageHandler(specName, cleanup, resolve, reject));
+	worker.on("error", createErrorHandler(specName, cleanup, reject));
+	worker.on("exit", createExitHandler(specName, cleanup, reject));
+}
+/** Send message to worker with timing log */
+function sendWorkerMessage(worker, message, createTime) {
+	const messageTime = getPerfNow();
+	worker.send(message);
+	logTiming(`Message sent to worker in ${getElapsed(createTime, messageTime).toFixed(1)}ms`);
+}
+/** Create worker process with configuration */
+function createWorkerProcess(gcStats) {
+	const workerPath = resolveWorkerPath();
+	const execArgv = ["--expose-gc", "--allow-natives-syntax"];
+	if (gcStats) execArgv.push("--trace-gc-nvp");
+	return fork(workerPath, [], {
+		execArgv,
+		silent: gcStats,
+		env: {
+			...process.env,
+			NODE_OPTIONS: ""
+		}
+	});
+}
 /** Capture and parse GC lines from stdout (V8's --trace-gc-nvp outputs to stdout) */
 function setupGcCapture(worker, gcEvents) {
 	let buffer = "";
@@ -109,30 +200,17 @@ function setupGcCapture(worker, gcEvents) {
 		}
 	});
 }
-/** Spawn worker, wire handlers, send message, return results */
-function runWorkerWithMessage(name, options, message) {
-	const startTime = getPerfNow();
-	const collectGcStats = options.gcStats ?? false;
-	logTiming(`Starting worker for ${name}`);
-	return new Promise((resolve, reject) => {
-		const { worker, createTime, gcEvents } = createWorkerWithTiming(collectGcStats);
-		setupWorkerHandlers(worker, name, createWorkerHandlers(name, startTime, gcEvents, resolve, reject));
-		sendWorkerMessage(worker, message, createTime);
-	});
-}
-/** Send message to worker with timing log */
-function sendWorkerMessage(worker, message, createTime) {
-	const messageTime = getPerfNow();
-	worker.send(message);
-	logTiming(`Message sent to worker in ${getElapsed(createTime, messageTime).toFixed(1)}ms`);
-}
-/** Setup worker event handlers with cleanup */
-function setupWorkerHandlers(worker, specName, handlers) {
-	const { resolve, reject } = handlers;
-	const cleanup = createCleanup(worker, specName, reject);
-	worker.on("message", createMessageHandler(specName, cleanup, resolve, reject));
-	worker.on("error", createErrorHandler(specName, cleanup, reject));
-	worker.on("exit", createExitHandler(specName, cleanup, reject));
+/** Create cleanup for timeout and termination */
+function createCleanup(worker, specName, reject) {
+	const timeoutId = setTimeout(() => {
+		cleanup();
+		reject(/* @__PURE__ */ new Error(`Benchmark "${specName}" timed out after 60 seconds`));
+	}, 6e4);
+	const cleanup = () => {
+		clearTimeout(timeoutId);
+		if (!worker.killed) worker.kill("SIGTERM");
+	};
+	return cleanup;
 }
 /** Handle worker messages (results or errors) */
 function createMessageHandler(specName, cleanup, resolve, reject) {
@@ -163,32 +241,6 @@ function createExitHandler(specName, cleanup, reject) {
 		}
 	};
 }
-/** Create cleanup for timeout and termination */
-function createCleanup(worker, specName, reject) {
-	const timeoutId = setTimeout(() => {
-		cleanup();
-		reject(/* @__PURE__ */ new Error(`Benchmark "${specName}" timed out after 60 seconds`));
-	}, 6e4);
-	const cleanup = () => {
-		clearTimeout(timeoutId);
-		if (!worker.killed) worker.kill("SIGTERM");
-	};
-	return cleanup;
-}
-/** Create worker process with configuration */
-function createWorkerProcess(gcStats) {
-	const workerPath = resolveWorkerPath();
-	const execArgv = ["--expose-gc", "--allow-natives-syntax"];
-	if (gcStats) execArgv.push("--trace-gc-nvp");
-	return fork(workerPath, [], {
-		execArgv,
-		silent: gcStats,
-		env: {
-			...process.env,
-			NODE_OPTIONS: ""
-		}
-	});
-}
 /** Resolve WorkerScript path for dev (.ts) or dist (.mjs) */
 function resolveWorkerPath() {
 	const dir = import.meta.dirname;
@@ -196,57 +248,6 @@ function resolveWorkerPath() {
 	if (existsSync(tsPath)) return tsPath;
 	return path.join(dir, "runners", "WorkerScript.mjs");
 }
-/** @return handlers that attach GC stats and heap profile to results */
-function createWorkerHandlers(specName, startTime, gcEvents, resolve, reject) {
-	return {
-		resolve: (results, heapProfile) => {
-			logTiming(`Total worker time for ${specName}: ${getElapsed(startTime).toFixed(1)}ms`);
-			if (gcEvents?.length) {
-				const gcStats = aggregateGcStats(gcEvents);
-				for (const r of results) r.gcStats = gcStats;
-			}
-			if (heapProfile) for (const r of results) r.heapProfile = heapProfile;
-			resolve(results);
-		},
-		reject
-	};
-}
-/** Create message for worker execution */
-function createRunMessage(spec, runnerName, options, params) {
-	const { fn, ...rest } = spec;
-	const message = {
-		type: "run",
-		spec: rest,
-		runnerName,
-		options,
-		params
-	};
-	if (spec.modulePath) {
-		message.modulePath = spec.modulePath;
-		message.exportName = spec.exportName;
-		if (spec.setupExportName) message.setupExportName = spec.setupExportName;
-	} else message.fnCode = fn.toString();
-	return message;
-}
-/** Run a matrix variant benchmark in isolated worker process */
-async function runMatrixVariant(params) {
-	const { variantDir, variantId, caseId, caseData, casesModule, runner, options } = params;
-	const name = `${variantId}/${caseId}`;
-	return runWorkerWithMessage(name, options, {
-		type: "run",
-		spec: {
-			name,
-			fn: () => {}
-		},
-		runnerName: runner,
-		options,
-		variantDir,
-		variantId,
-		caseId,
-		caseData,
-		casesModule
-	});
-}
 
 //#endregion
 //#region src/BenchMatrix.ts
@@ -270,31 +271,15 @@ function validateBaseline(matrix) {
 	const msg = "BenchMatrix cannot have both 'baselineDir' and 'baselineVariant'";
 	if (matrix.baselineDir && matrix.baselineVariant) throw new Error(msg);
 }
-function buildRunnerOptions(options) {
-	return {
-		maxIterations: options.iterations,
-		maxTime: options.maxTime ?? 1e3,
-		warmup: options.warmup ?? 0,
-		collect: options.collect,
-		cpuCounters: options.cpuCounters,
-		traceOpt: options.traceOpt,
-		noSettle: options.noSettle,
-		pauseFirst: options.pauseFirst,
-		pauseInterval: options.pauseInterval,
-		pauseDuration: options.pauseDuration,
-		gcStats: options.gcStats,
-		heapSample: options.heapSample,
-		heapInterval: options.heapInterval,
-		heapDepth: options.heapDepth
-	};
-}
-/** Load cases module and resolve filtered case IDs */
-async function resolveCases(matrix, options) {
-	const casesModule = matrix.casesModule ? await loadCasesModule(matrix.casesModule) : void 0;
-	const allCaseIds = casesModule?.cases ?? matrix.cases ?? ["default"];
+/** Run matrix with variantDir (worker mode for memory isolation) */
+async function runMatrixWithDir(matrix, options) {
+	const allVariantIds = await discoverVariants(matrix.variantDir);
+	if (allVariantIds.length === 0) throw new Error(`No variants found in ${matrix.variantDir}`);
+	const variants = await runDirVariants(options.filteredVariants ?? allVariantIds, await createDirContext(matrix, options));
+	if (matrix.baselineVariant) applyBaselineVariant(variants, matrix.baselineVariant);
 	return {
-		casesModule,
-		caseIds: options.filteredCases ?? allCaseIds
+		name: matrix.name,
+		variants
 	};
 }
 /** Run matrix with inline variants (non-worker mode) */
@@ -328,17 +313,6 @@ async function runMatrixInline(matrix, options) {
 		variants
 	};
 }
-/** Run matrix with variantDir (worker mode for memory isolation) */
-async function runMatrixWithDir(matrix, options) {
-	const allVariantIds = await discoverVariants(matrix.variantDir);
-	if (allVariantIds.length === 0) throw new Error(`No variants found in ${matrix.variantDir}`);
-	const variants = await runDirVariants(options.filteredVariants ?? allVariantIds, await createDirContext(matrix, options));
-	if (matrix.baselineVariant) applyBaselineVariant(variants, matrix.baselineVariant);
-	return {
-		name: matrix.name,
-		variants
-	};
-}
 /** Create context for directory-based matrix execution */
 async function createDirContext(matrix, options) {
 	const baselineIds = matrix.baselineDir ? await discoverVariants(matrix.baselineDir) : [];
@@ -363,56 +337,6 @@ async function runDirVariants(variantIds, ctx) {
 	}
 	return variants;
 }
-/** Run all cases for a single variant */
-async function runDirVariantCases(variantId, ctx) {
-	const { matrix, casesModule, caseIds, runnerOpts } = ctx;
-	const cases = [];
-	for (const caseId of caseIds) {
-		const caseData = !matrix.casesModule && matrix.cases ? caseId : void 0;
-		const [measured] = await runMatrixVariant({
-			variantDir: matrix.variantDir,
-			variantId,
-			caseId,
-			caseData,
-			casesModule: matrix.casesModule,
-			runner: "basic",
-			options: runnerOpts
-		});
-		const loaded = await loadCaseData(casesModule, caseId);
-		const baseline = await runBaselineIfExists(variantId, caseId, caseData, ctx);
-		const deltaPercent = baseline ? computeDeltaPercent(baseline, measured) : void 0;
-		const metadata = loaded.metadata;
-		cases.push({
-			caseId,
-			measured,
-			metadata,
-			baseline,
-			deltaPercent
-		});
-	}
-	return cases;
-}
-/** Run baseline variant if it exists in baselineDir */
-async function runBaselineIfExists(variantId, caseId, caseData, ctx) {
-	const { matrix, baselineIds, runnerOpts } = ctx;
-	if (!matrix.baselineDir || !baselineIds.includes(variantId)) return void 0;
-	const [measured] = await runMatrixVariant({
-		variantDir: matrix.baselineDir,
-		variantId,
-		caseId,
-		caseData,
-		casesModule: matrix.casesModule,
-		runner: "basic",
-		options: runnerOpts
-	});
-	return measured;
-}
-/** Compute delta percentage: (current - baseline) / baseline * 100 */
-function computeDeltaPercent(baseline, current) {
-	const baseAvg = average(baseline.samples);
-	if (baseAvg === 0) return 0;
-	return (average(current.samples) - baseAvg) / baseAvg * 100;
-}
 /** Apply baselineVariant comparison - one variant is the reference for all others */
 function applyBaselineVariant(variants, baselineVariantId) {
 	const baselineVariant = variants.find((v) => v.id === baselineVariantId);
@@ -430,6 +354,33 @@ function applyBaselineVariant(variants, baselineVariantId) {
 		}
 	}
 }
+/** Load cases module and resolve filtered case IDs */
+async function resolveCases(matrix, options) {
+	const casesModule = matrix.casesModule ? await loadCasesModule(matrix.casesModule) : void 0;
+	const allCaseIds = casesModule?.cases ?? matrix.cases ?? ["default"];
+	return {
+		casesModule,
+		caseIds: options.filteredCases ?? allCaseIds
+	};
+}
+function buildRunnerOptions(options) {
+	return {
+		maxIterations: options.iterations,
+		maxTime: options.maxTime ?? 1e3,
+		warmup: options.warmup ?? 0,
+		collect: options.collect,
+		cpuCounters: options.cpuCounters,
+		traceOpt: options.traceOpt,
+		noSettle: options.noSettle,
+		pauseFirst: options.pauseFirst,
+		pauseInterval: options.pauseInterval,
+		pauseDuration: options.pauseDuration,
+		gcStats: options.gcStats,
+		heapSample: options.heapSample,
+		heapInterval: options.heapInterval,
+		heapDepth: options.heapDepth
+	};
+}
 /** Run a single variant with case data */
 async function runVariant(variant, caseData, name, runner, options) {
 	if (isStatefulVariant(variant)) {
@@ -446,6 +397,56 @@ async function runVariant(variant, caseData, name, runner, options) {
 	}, options);
 	return result;
 }
+/** Run all cases for a single variant */
+async function runDirVariantCases(variantId, ctx) {
+	const { matrix, casesModule, caseIds, runnerOpts } = ctx;
+	const cases = [];
+	for (const caseId of caseIds) {
+		const caseData = !matrix.casesModule && matrix.cases ? caseId : void 0;
+		const [measured] = await runMatrixVariant({
+			variantDir: matrix.variantDir,
+			variantId,
+			caseId,
+			caseData,
+			casesModule: matrix.casesModule,
+			runner: "basic",
+			options: runnerOpts
+		});
+		const loaded = await loadCaseData(casesModule, caseId);
+		const baseline = await runBaselineIfExists(variantId, caseId, caseData, ctx);
+		const deltaPercent = baseline ? computeDeltaPercent(baseline, measured) : void 0;
+		const metadata = loaded.metadata;
+		cases.push({
+			caseId,
+			measured,
+			metadata,
+			baseline,
+			deltaPercent
+		});
+	}
+	return cases;
+}
+/** Compute delta percentage: (current - baseline) / baseline * 100 */
+function computeDeltaPercent(baseline, current) {
+	const baseAvg = average(baseline.samples);
+	if (baseAvg === 0) return 0;
+	return (average(current.samples) - baseAvg) / baseAvg * 100;
+}
+/** Run baseline variant if it exists in baselineDir */
+async function runBaselineIfExists(variantId, caseId, caseData, ctx) {
+	const { matrix, baselineIds, runnerOpts } = ctx;
+	if (!matrix.baselineDir || !baselineIds.includes(variantId)) return void 0;
+	const [measured] = await runMatrixVariant({
+		variantDir: matrix.baselineDir,
+		variantId,
+		caseId,
+		caseData,
+		casesModule: matrix.casesModule,
+		runner: "basic",
+		options: runnerOpts
+	});
+	return measured;
+}
 
 //#endregion
 //#region src/table-util/Formatters.ts
@@ -491,21 +492,15 @@ function diffPercent(main, base) {
 	if (typeof main !== "number" || typeof base !== "number") return " ";
 	return coloredPercent(main - base, base);
 }
-/** Format fraction as colored +/- percentage */
-function coloredPercent(numerator, denominator, positiveIsGreen = true) {
-	const fraction = numerator / denominator;
-	if (Number.isNaN(fraction) || !Number.isFinite(fraction)) return " ";
-	const positive = fraction >= 0;
-	const percentStr = `${positive ? "+" : "-"}${percent(fraction)}`;
-	return positive === positiveIsGreen ? green(percentStr) : red$1(percentStr);
-}
-/** Format bytes with appropriate units (B, KB, MB, GB) */
-function formatBytes(bytes) {
+/** Format bytes with appropriate units (B, KB, MB, GB).
+*  Use `space: true` for human-readable console output (`1.5 KB`). */
+function formatBytes(bytes, opts) {
 	if (typeof bytes !== "number") return null;
-	if (bytes < 1024) return `${bytes.toFixed(0)}B`;
-	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-	if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
-	return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}GB`;
+	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)}${s}MB`;
+	return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}${s}GB`;
 }
 /** Format percentage difference with confidence interval */
 function formatDiffWithCI(value) {
@@ -519,9 +514,21 @@ function formatDiffWithCIHigherIsBetter(value) {
 	const { percent, ci, direction } = value;
 	return colorByDirection(diffCIText(-percent, [-ci[1], -ci[0]]), direction);
 }
-/** @return formatted "pct [lo, hi]" text for a diff with CI */
-function diffCIText(pct, ci) {
-	return `${formatBound(pct)} [${formatBound(ci[0])}, ${formatBound(ci[1])}]`;
+/** @return truncated string with ellipsis if over maxLen */
+function truncate(str, maxLen = 30) {
+	return str.length > maxLen ? str.slice(0, maxLen - 3) + "..." : str;
+}
+/** Format fraction as colored +/- percentage */
+function coloredPercent(numerator, denominator, positiveIsGreen = true) {
+	const fraction = numerator / denominator;
+	if (Number.isNaN(fraction) || !Number.isFinite(fraction)) return " ";
+	const positive = fraction >= 0;
+	const percentStr = `${positive ? "+" : "-"}${percent(fraction)}`;
+	return positive === positiveIsGreen ? green(percentStr) : red$1(percentStr);
+}
+/** @return true if value is a DifferenceCI object */
+function isDifferenceCI(x) {
+	return typeof x === "object" && x !== null && "ci" in x && "direction" in x;
 }
 /** @return text colored green for faster, red for slower */
 function colorByDirection(text, direction) {
@@ -529,78 +536,23 @@ function colorByDirection(text, direction) {
 	if (direction === "slower") return red$1(text);
 	return text;
 }
+/** @return formatted "pct [lo, hi]" text for a diff with CI */
+function diffCIText(pct, ci) {
+	return `${formatBound(pct)} [${formatBound(ci[0])}, ${formatBound(ci[1])}]`;
+}
 /** @return signed percentage string (e.g. "+1.2%", "-3.4%") */
 function formatBound(v) {
 	return `${v >= 0 ? "+" : ""}${v.toFixed(1)}%`;
 }
-/** @return true if value is a DifferenceCI object */
-function isDifferenceCI(x) {
-	return typeof x === "object" && x !== null && "ci" in x && "direction" in x;
-}
-/** @return truncated string with ellipsis if over maxLen */
-function truncate(str, maxLen = 30) {
-	return str.length > maxLen ? str.slice(0, maxLen - 3) + "..." : str;
-}
 
 //#endregion
 //#region src/table-util/TableReport.ts
 const { bold } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? { bold: (str) => str } : pico;
+const ansiEscapeRegex = new RegExp(String.fromCharCode(27) + "\\[[0-9;]*m", "g");
 /** Build formatted table with column groups and baselines */
 function buildTable(columnGroups, resultGroups, nameKey = "name") {
 	return createTable(columnGroups, flattenGroups(columnGroups, resultGroups, nameKey));
 }
-/** Convert columns and records to formatted table */
-function createTable(groups, records) {
-	const dataRows = toRows(records, groups);
-	const { headerRows, config } = setup(groups, dataRows);
-	return table([...headerRows, ...dataRows], config);
-}
-/** Create header rows with group titles */
-function createGroupHeaders(groups, numColumns) {
-	if (!groups.some((g) => g.groupTitle)) return [];
-	return [groups.flatMap((g) => {
-		return padWithBlanks(g.groupTitle ? [bold(g.groupTitle)] : [], g.columns.length);
-	}), padWithBlanks([], numColumns)];
-}
-/** @return draw functions for horizontal/vertical table borders */
-function createLines(groups) {
-	const { sectionBorders, headerBottom } = calcBorders(groups);
-	function drawVerticalLine(index, size) {
-		return index === 0 || index === size || sectionBorders.includes(index);
-	}
-	function drawHorizontalLine(index, size) {
-		return index === 0 || index === size || index === headerBottom;
-	}
-	return {
-		drawHorizontalLine,
-		drawVerticalLine
-	};
-}
-/** @return spanning cell configs for group title headers */
-function createSectionSpans(groups) {
-	let col = 0;
-	const 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(groups) {
-	return groups.flatMap((g) => g.columns.map((c) => bold(c.title || " ")));
-}
-/** @return array padded with blank strings to the given length */
-function padWithBlanks(arr, length) {
-	if (arr.length >= length) return arr;
-	return [...arr, ...Array(length - arr.length).fill(" ")];
-}
 /** Convert records to string arrays for table */
 function toRows(records, groups) {
 	const allColumns = groups.flatMap((group) => group.columns);
@@ -609,20 +561,6 @@ function toRows(records, groups) {
 		return col.formatter ? col.formatter(value) : value;
 	})).map((row) => row.map((cell) => cell ?? " "));
 }
-/** Add comparison values for diff columns */
-function addComparisons(groups, mainRecord, baselineRecord) {
-	const diffColumns = groups.flatMap((g) => g.columns).filter((col) => col.diffKey);
-	const updatedMain = { ...mainRecord };
-	for (const col of diffColumns) {
-		const dcol = col;
-		const diffKey = dcol.diffKey;
-		const mainValue = mainRecord[diffKey];
-		const baselineValue = baselineRecord[diffKey];
-		const diffStr = (dcol.diffFormatter ?? diffPercent)(mainValue, baselineValue);
-		updatedMain[col.key] = diffStr;
-	}
-	return updatedMain;
-}
 /** Flatten groups with spacing */
 function flattenGroups(columnGroups, resultGroups, nameKey) {
 	return resultGroups.flatMap((group, i) => {
@@ -630,6 +568,12 @@ function flattenGroups(columnGroups, resultGroups, nameKey) {
 		return i === resultGroups.length - 1 ? groupRecords : [...groupRecords, {}];
 	});
 }
+/** Convert columns and records to formatted table */
+function createTable(groups, records) {
+	const dataRows = toRows(records, groups);
+	const { headerRows, config } = setup(groups, dataRows);
+	return table([...headerRows, ...dataRows], config);
+}
 /** Process results with baseline comparisons */
 function addBaseline(columnGroups, group, nameKey) {
 	const { results, baseline } = group;
@@ -641,23 +585,6 @@ function addBaseline(columnGroups, group, nameKey) {
 	};
 	return [...diffResults, markedBaseline];
 }
-/** Calculate vertical lines between sections and header bottom position */
-function calcBorders(groups) {
-	if (groups.length === 0) return {
-		sectionBorders: [],
-		headerBottom: 1
-	};
-	const sectionBorders = [];
-	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(groups, dataRows) {
 	const titles = getTitles(groups);
@@ -671,18 +598,59 @@ function setup(groups, dataRows) {
 		}
 	};
 }
-/** Calculate column widths based on content, including group titles */
-function calcColumnWidths(groups, titles, dataRows) {
-	const widths = [];
-	for (let i = 0; i < titles.length; i++) {
-		const titleW = cellWidth(titles[i]);
-		const maxDataW = dataRows.reduce((max, row) => Math.max(max, cellWidth(row[i])), 0);
-		widths.push(Math.max(titleW, maxDataW));
-	}
-	let colIndex = 0;
-	for (const group of groups) {
-		const groupW = cellWidth(group.groupTitle);
-		if (groupW > 0) {
+/** Add comparison values for diff columns */
+function addComparisons(groups, mainRecord, baselineRecord) {
+	const diffColumns = groups.flatMap((g) => g.columns).filter((col) => col.diffKey);
+	const updatedMain = { ...mainRecord };
+	for (const col of diffColumns) {
+		const dcol = col;
+		const diffKey = dcol.diffKey;
+		const mainValue = mainRecord[diffKey];
+		const baselineValue = baselineRecord[diffKey];
+		const diffStr = (dcol.diffFormatter ?? diffPercent)(mainValue, baselineValue);
+		updatedMain[col.key] = diffStr;
+	}
+	return updatedMain;
+}
+/** @return bolded column title strings */
+function getTitles(groups) {
+	return groups.flatMap((g) => g.columns.map((c) => bold(c.title || " ")));
+}
+/** Create header rows with group titles */
+function createGroupHeaders(groups, numColumns) {
+	if (!groups.some((g) => g.groupTitle)) return [];
+	return [groups.flatMap((g) => {
+		return padWithBlanks(g.groupTitle ? [bold(g.groupTitle)] : [], g.columns.length);
+	}), padWithBlanks([], numColumns)];
+}
+/** @return spanning cell configs for group title headers */
+function createSectionSpans(groups) {
+	let col = 0;
+	const 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(groups, titles, dataRows) {
+	const widths = [];
+	for (let i = 0; i < titles.length; i++) {
+		const titleW = cellWidth(titles[i]);
+		const maxDataW = dataRows.reduce((max, row) => Math.max(max, cellWidth(row[i])), 0);
+		widths.push(Math.max(titleW, maxDataW));
+	}
+	let colIndex = 0;
+	for (const group of groups) {
+		const groupW = cellWidth(group.groupTitle);
+		if (groupW > 0) {
 			const numCols = group.columns.length;
 			const separatorWidth = (numCols - 1) * 3;
 			const needed = groupW - widths.slice(colIndex, colIndex + numCols).reduce((a, b) => a + b, 0) - separatorWidth;
@@ -695,20 +663,84 @@ function calcColumnWidths(groups, titles, dataRows) {
 		wrapWord: false
 	}]));
 }
-const ansiEscapeRegex = new RegExp(String.fromCharCode(27) + "\\[[0-9;]*m", "g");
+/** @return draw functions for horizontal/vertical table borders */
+function createLines(groups) {
+	const { sectionBorders, headerBottom } = calcBorders(groups);
+	function drawVerticalLine(index, size) {
+		return index === 0 || index === size || sectionBorders.includes(index);
+	}
+	function drawHorizontalLine(index, size) {
+		return index === 0 || index === size || index === headerBottom;
+	}
+	return {
+		drawHorizontalLine,
+		drawVerticalLine
+	};
+}
+/** @return array padded with blank strings to the given length */
+function padWithBlanks(arr, length) {
+	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) {
 	if (value == null) return 0;
 	return String(value).replace(ansiEscapeRegex, "").length;
 }
+/** Calculate vertical lines between sections and header bottom position */
+function calcBorders(groups) {
+	if (groups.length === 0) return {
+		sectionBorders: [],
+		headerBottom: 1
+	};
+	const sectionBorders = [];
+	let border = 0;
+	for (const g of groups) {
+		border += g.columns.length;
+		sectionBorders.push(border);
+	}
+	return {
+		sectionBorders,
+		headerBottom: 3
+	};
+}
 
 //#endregion
 //#region src/BenchmarkReport.ts
+/** All reports in a group, including the baseline if present */
+function groupReports(group) {
+	return group.baseline ? [...group.reports, group.baseline] : group.reports;
+}
 /** @return formatted table report with optional baseline comparisons */
 function reportResults(groups, sections) {
 	const results = groups.map((group) => resultGroupValues(group, sections));
 	return buildTable(createColumnGroups(sections, results.some((g) => g.baseline)), results);
 }
+/** @return rows with stats from sections */
+function valuesForReports(reports, sections) {
+	return reports.map((report) => ({
+		name: truncate(report.name),
+		...extractReportValues(report, sections)
+	}));
+}
+/** @return groups with single CI column after first comparable field */
+function injectDiffColumns(reportGroups) {
+	let ciAdded = false;
+	return reportGroups.map((group) => ({
+		groupTitle: group.groupTitle,
+		columns: group.columns.flatMap((col) => {
+			if (col.comparable && !ciAdded) {
+				ciAdded = true;
+				return [col, {
+					title: "Δ% CI",
+					key: "diffCI",
+					formatter: col.higherIsBetter ? formatDiffWithCIHigherIsBetter : formatDiffWithCI
+				}];
+			}
+			return [col];
+		})
+	}));
+}
 /** @return values for report group */
 function resultGroupValues(group, sections) {
 	const { reports, baseline } = group;
@@ -725,19 +757,6 @@ function resultGroupValues(group, sections) {
 		baseline: baseline && valuesForReports([baseline], sections)[0]
 	};
 }
-/** @return rows with stats from sections */
-function valuesForReports(reports, sections) {
-	return reports.map((report) => ({
-		name: truncate(report.name),
-		...extractReportValues(report, sections)
-	}));
-}
-/** @return merged statistics from all sections */
-function extractReportValues(report, sections) {
-	const { measuredResults, metadata } = report;
-	const entries = sections.flatMap((s) => Object.entries(s.extract(measuredResults, metadata)));
-	return Object.fromEntries(entries);
-}
 /** @return column groups with diff columns if baseline exists */
 function createColumnGroups(sections, hasBaseline) {
 	const nameColumn = { columns: [{
@@ -747,23 +766,11 @@ function createColumnGroups(sections, hasBaseline) {
 	const groups = sections.flatMap((section) => section.columns());
 	return [nameColumn, ...hasBaseline ? injectDiffColumns(groups) : groups];
 }
-/** @return groups with single CI column after first comparable field */
-function injectDiffColumns(reportGroups) {
-	let ciAdded = false;
-	return reportGroups.map((group) => ({
-		groupTitle: group.groupTitle,
-		columns: group.columns.flatMap((col) => {
-			if (col.comparable && !ciAdded) {
-				ciAdded = true;
-				return [col, {
-					title: "Δ% CI",
-					key: "diffCI",
-					formatter: col.higherIsBetter ? formatDiffWithCIHigherIsBetter : formatDiffWithCI
-				}];
-			}
-			return [col];
-		})
-	}));
+/** @return merged statistics from all sections */
+function extractReportValues(report, sections) {
+	const { measuredResults, metadata } = report;
+	const entries = sections.flatMap((s) => Object.entries(s.extract(measuredResults, metadata)));
+	return Object.fromEntries(entries);
 }
 
 //#endregion
@@ -846,11 +853,21 @@ const cliOptions = {
 		requiresArg: true,
 		describe: "export benchmark data to JSON file"
 	},
-	perfetto: {
+	"export-perfetto": {
 		type: "string",
 		requiresArg: true,
 		describe: "export Perfetto trace file (view at ui.perfetto.dev)"
 	},
+	speedscope: {
+		type: "boolean",
+		default: false,
+		describe: "open heap profile in speedscope (via npx)"
+	},
+	"export-speedscope": {
+		type: "string",
+		requiresArg: true,
+		describe: "export heap profile as speedscope JSON"
+	},
 	"trace-opt": {
 		type: "boolean",
 		default: false,
@@ -915,6 +932,11 @@ const cliOptions = {
 		default: false,
 		describe: "verbose output with file:// paths and line numbers"
 	},
+	"heap-raw": {
+		type: "boolean",
+		default: false,
+		describe: "dump every raw heap sample (ordinal, size, stack)"
+	},
 	"heap-user-only": {
 		type: "boolean",
 		default: false,
@@ -944,7 +966,12 @@ const cliOptions = {
 };
 /** @return yargs with standard benchmark options */
 function defaultCliArgs(yargsInstance) {
-	return yargsInstance.options(cliOptions).help().strict();
+	return yargsInstance.command("$0 [file]", "run benchmarks", (y) => {
+		y.positional("file", {
+			type: "string",
+			describe: "benchmark file to run"
+		});
+	}).options(cliOptions).help().strict();
 }
 /** @return parsed command line arguments */
 function parseCliArgs(args, configure = defaultCliArgs) {
@@ -978,6 +1005,12 @@ function prepareJsonData(groups, args, suiteName) {
 		}]
 	};
 }
+/** Clean CLI args for JSON export (remove undefined values) */
+function cleanCliArgs(args) {
+	const toCamel = (k) => k.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+	const entries = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => [toCamel(k), v]);
+	return Object.fromEntries(entries);
+}
 /** Convert a report group, mapping each report to the JSON result format */
 function convertGroup(group) {
 	return {
@@ -1021,12 +1054,6 @@ function convertReport(report) {
 		}
 	};
 }
-/** Clean CLI args for JSON export (remove undefined values) */
-function cleanCliArgs(args) {
-	const toCamel = (k) => k.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
-	const entries = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => [toCamel(k), v]);
-	return Object.fromEntries(entries);
-}
 
 //#endregion
 //#region src/export/PerfettoExport.ts
@@ -1060,60 +1087,6 @@ function buildTraceEvents(groups, args) {
 	}
 	return events;
 }
-function instant(ts, name, args) {
-	return {
-		ph: "i",
-		ts,
-		pid,
-		tid,
-		cat: "bench",
-		name,
-		s: "t",
-		args
-	};
-}
-function counter(ts, name, args) {
-	return {
-		ph: "C",
-		ts,
-		pid,
-		tid,
-		cat: "bench",
-		name,
-		args
-	};
-}
-/** Build events for a single benchmark run */
-function buildBenchmarkEvents(results) {
-	const { samples, heapSamples, timestamps, pausePoints } = results;
-	if (!timestamps?.length) return [];
-	const events = [];
-	for (let i = 0; i < samples.length; i++) {
-		const ts = timestamps[i];
-		const ms = Math.round(samples[i] * 100) / 100;
-		events.push(instant(ts, results.name, {
-			n: i,
-			ms
-		}));
-		events.push(counter(ts, "duration", { ms }));
-		if (heapSamples?.[i] !== void 0) {
-			const MB = Math.round(heapSamples[i] / 1024 / 1024 * 10) / 10;
-			events.push(counter(ts, "heap", { MB }));
-		}
-	}
-	for (const pause of pausePoints ?? []) {
-		const ts = timestamps[pause.sampleIndex];
-		if (ts) events.push(instant(ts, "pause", { ms: pause.durationMs }));
-	}
-	return events;
-}
-/** Normalize timestamps so events start at 0 */
-function normalizeTimestamps(events) {
-	const times = events.filter((e) => e.ts > 0).map((e) => e.ts);
-	if (times.length === 0) return;
-	const minTs = Math.min(...times);
-	for (const e of events) if (e.ts > 0) e.ts -= minTs;
-}
 /** Merge V8 trace events from a previous run, aligning timestamps */
 function mergeV8Trace(customEvents) {
 	const v8Events = loadV8Events(readdirSync(".").filter((f) => f.startsWith("node_trace.") && f.endsWith(".log"))[0]);
@@ -1122,29 +1095,11 @@ function mergeV8Trace(customEvents) {
 	normalizeTimestamps(v8Events);
 	return [...v8Events, ...customEvents];
 }
-/** Load V8 trace events from file, or undefined if unavailable */
-function loadV8Events(v8TracePath) {
-	if (!v8TracePath) return void 0;
-	try {
-		const v8Data = JSON.parse(readFileSync(v8TracePath, "utf-8"));
-		console.log(`Merged ${v8Data.traceEvents.length} V8 events from ${v8TracePath}`);
-		return v8Data.traceEvents;
-	} catch {
-		console.warn(`Could not parse V8 trace file: ${v8TracePath}`);
-		return;
-	}
-}
 /** Write trace events to JSON file */
 function writeTraceFile(outputPath, events) {
 	const traceFile = { traceEvents: events };
 	writeFileSync(outputPath, JSON.stringify(traceFile));
 }
-/** Clean CLI args for metadata */
-function cleanArgs(args) {
-	const skip = new Set(["_", "$0"]);
-	const entries = Object.entries(args).filter(([k, v]) => v !== void 0 && !skip.has(k));
-	return Object.fromEntries(entries);
-}
 /** Spawn a detached child to merge V8 trace after process exit */
 function scheduleDeferredMerge(outputPath) {
 	const cwd = process.cwd();
@@ -1177,25 +1132,234 @@ function scheduleDeferredMerge(outputPath) {
 		}).unref();
 	});
 }
-
-//#endregion
-//#region src/HtmlDataPrep.ts
-/** Find higherIsBetter from first comparable column in sections */
-function findHigherIsBetter(sections) {
-	return (sections?.flatMap((s) => s.columns().flatMap((g) => g.columns)))?.find((c) => c.comparable)?.higherIsBetter ?? false;
+/** Clean CLI args for metadata */
+function cleanArgs(args) {
+	const skip = new Set(["_", "$0"]);
+	const entries = Object.entries(args).filter(([k, v]) => v !== void 0 && !skip.has(k));
+	return Object.fromEntries(entries);
 }
-/** Flip CI percent for metrics where higher is better (e.g., lines/sec) */
-function flipCI(ci) {
+/** Build events for a single benchmark run */
+function buildBenchmarkEvents(results) {
+	const { samples, heapSamples, timestamps, pausePoints } = results;
+	if (!timestamps?.length) return [];
+	const events = [];
+	for (let i = 0; i < samples.length; i++) {
+		const ts = timestamps[i];
+		const ms = Math.round(samples[i] * 100) / 100;
+		events.push(instant(ts, results.name, {
+			n: i,
+			ms
+		}));
+		events.push(counter(ts, "duration", { ms }));
+		if (heapSamples?.[i] !== void 0) {
+			const MB = Math.round(heapSamples[i] / 1024 / 1024 * 10) / 10;
+			events.push(counter(ts, "heap", { MB }));
+		}
+	}
+	for (const pause of pausePoints ?? []) {
+		const ts = timestamps[pause.sampleIndex];
+		if (ts) events.push(instant(ts, "pause", { ms: pause.durationMs }));
+	}
+	return events;
+}
+/** Load V8 trace events from file, or undefined if unavailable */
+function loadV8Events(v8TracePath) {
+	if (!v8TracePath) return void 0;
+	try {
+		const v8Data = JSON.parse(readFileSync(v8TracePath, "utf-8"));
+		console.log(`Merged ${v8Data.traceEvents.length} V8 events from ${v8TracePath}`);
+		return v8Data.traceEvents;
+	} catch {
+		console.warn(`Could not parse V8 trace file: ${v8TracePath}`);
+		return;
+	}
+}
+/** Normalize timestamps so events start at 0 */
+function normalizeTimestamps(events) {
+	const times = events.filter((e) => e.ts > 0).map((e) => e.ts);
+	if (times.length === 0) return;
+	const minTs = Math.min(...times);
+	for (const e of events) if (e.ts > 0) e.ts -= minTs;
+}
+function instant(ts, name, args) {
 	return {
-		percent: -ci.percent,
-		ci: [-ci.ci[1], -ci.ci[0]],
-		direction: ci.direction,
-		histogram: ci.histogram?.map((bin) => ({
-			x: -bin.x,
-			count: bin.count
-		}))
+		ph: "i",
+		ts,
+		pid,
+		tid,
+		cat: "bench",
+		name,
+		s: "t",
+		args
+	};
+}
+function counter(ts, name, args) {
+	return {
+		ph: "C",
+		ts,
+		pid,
+		tid,
+		cat: "bench",
+		name,
+		args
+	};
+}
+
+//#endregion
+//#region src/heap-sample/ResolvedProfile.ts
+/** Walk a HeapProfile tree once, producing a fully resolved intermediate form */
+function resolveProfile(profile) {
+	const nodes = [];
+	const nodeMap = /* @__PURE__ */ new Map();
+	let totalBytes = 0;
+	function walk(node, parentStack) {
+		const { functionName, url, lineNumber, columnNumber } = node.callFrame;
+		const frame = {
+			name: functionName || "(anonymous)",
+			url: url || "",
+			line: lineNumber + 1,
+			col: columnNumber != null ? columnNumber + 1 : void 0
+		};
+		const stack = [...parentStack, frame];
+		const resolved = {
+			frame,
+			stack,
+			selfSize: node.selfSize,
+			nodeId: node.id
+		};
+		nodes.push(resolved);
+		nodeMap.set(node.id, resolved);
+		totalBytes += node.selfSize;
+		for (const child of node.children || []) walk(child, stack);
+	}
+	walk(profile.head, []);
+	return {
+		nodes,
+		nodeMap,
+		allocationNodes: nodes.filter((n) => n.selfSize > 0).sort((a, b) => b.selfSize - a.selfSize),
+		sortedSamples: profile.samples ? [...profile.samples].sort((a, b) => a.ordinal - b.ordinal) : void 0,
+		totalBytes
+	};
+}
+
+//#endregion
+//#region src/export/SpeedscopeExport.ts
+/** Export heap profiles from benchmark results to speedscope JSON format.
+*  Creates one speedscope profile per benchmark that has a heapProfile.
+*  @returns resolved output path, or undefined if no profiles were found */
+function exportSpeedscope(groups, outputPath) {
+	const frames = [];
+	const frameIndex = /* @__PURE__ */ new Map();
+	const profiles = [];
+	for (const group of groups) for (const report of groupReports(group)) {
+		const { heapProfile } = report.measuredResults;
+		if (!heapProfile) continue;
+		const resolved = resolveProfile(heapProfile);
+		profiles.push(buildProfile(report.name, resolved, frames, frameIndex));
+	}
+	if (profiles.length === 0) {
+		console.log("No heap profiles to export.");
+		return;
+	}
+	const file = {
+		$schema: "https://www.speedscope.app/file-format-schema.json",
+		shared: { frames },
+		profiles,
+		exporter: "benchforge"
+	};
+	const absPath = resolve(outputPath);
+	writeFileSync(absPath, JSON.stringify(file));
+	console.log(`Speedscope profile exported to: ${outputPath}`);
+	return absPath;
+}
+/** Export to a temp file and open in speedscope via npx */
+function exportAndLaunchSpeedscope(groups) {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+	const absPath = exportSpeedscope(groups, join(tmpdir(), `benchforge-${timestamp}.speedscope.json`));
+	if (absPath) launchSpeedscope(absPath);
+}
+/** Launch speedscope viewer on a file via npx */
+function launchSpeedscope(filePath) {
+	console.log("Opening speedscope...");
+	const child = spawn("npx", ["speedscope", filePath], {
+		detached: true,
+		stdio: "ignore"
+	});
+	child.unref();
+	child.on("error", () => {
+		console.error(`Failed to launch speedscope. Run manually:\n  npx speedscope ${filePath}`);
+	});
+}
+/** Convert a single HeapProfile to speedscope format (for standalone use) */
+function heapProfileToSpeedscope(name, profile) {
+	const frames = [];
+	const frameIndex = /* @__PURE__ */ new Map();
+	const p = buildProfile(name, resolveProfile(profile), frames, frameIndex);
+	return {
+		$schema: "https://www.speedscope.app/file-format-schema.json",
+		shared: { frames },
+		profiles: [p],
+		exporter: "benchforge"
+	};
+}
+/** Build a single speedscope profile from a resolved heap profile */
+function buildProfile(name, resolved, sharedFrames, frameIndex) {
+	const nodeStacks = /* @__PURE__ */ new Map();
+	for (const node of resolved.nodes) {
+		const stack = node.stack.map((f) => internFrame(f, sharedFrames, frameIndex));
+		nodeStacks.set(node.nodeId, stack);
+	}
+	const samples = [];
+	const weights = [];
+	if (!resolved.sortedSamples || resolved.sortedSamples.length === 0) {
+		console.error(`Speedscope export: no samples in heap profile for "${name}", skipping`);
+		return {
+			type: "sampled",
+			name,
+			unit: "bytes",
+			startValue: 0,
+			endValue: 0,
+			samples,
+			weights
+		};
+	}
+	for (const sample of resolved.sortedSamples) {
+		const stack = nodeStacks.get(sample.nodeId);
+		if (stack) {
+			samples.push(stack);
+			weights.push(sample.size);
+		}
+	}
+	return {
+		type: "sampled",
+		name,
+		unit: "bytes",
+		startValue: 0,
+		endValue: weights.reduce((sum, w) => sum + w, 0),
+		samples,
+		weights
 	};
 }
+/** Intern a call frame, returning its index in the shared frames array */
+function internFrame(frame, sharedFrames, frameIndex) {
+	const { name, url, line, col } = frame;
+	const key = `${name}\0${url}\0${line}\0${col}`;
+	let idx = frameIndex.get(key);
+	if (idx === void 0) {
+		idx = sharedFrames.length;
+		const shortFile = url ? url.split("/").pop() : void 0;
+		const entry = { name: name !== "(anonymous)" ? name : shortFile ? `(anonymous ${shortFile}:${line})` : "(anonymous)" };
+		if (url) entry.file = url;
+		if (line > 0) entry.line = line;
+		if (col != null) entry.col = col;
+		sharedFrames.push(entry);
+		frameIndex.set(key, idx);
+	}
+	return idx;
+}
+
+//#endregion
+//#region src/HtmlDataPrep.ts
 /** Prepare ReportData from benchmark results for HTML rendering */
 function prepareHtmlData(groups, options) {
 	const { cliArgs, sections, currentVersion, baselineVersion } = options;
@@ -1212,6 +1376,10 @@ function prepareHtmlData(groups, options) {
 		}
 	};
 }
+/** Find higherIsBetter from first comparable column in sections */
+function findHigherIsBetter(sections) {
+	return (sections?.flatMap((s) => s.columns().flatMap((g) => g.columns)))?.find((c) => c.comparable)?.higherIsBetter ?? false;
+}
 /** @return group data with bootstrap CI comparisons against baseline */
 function prepareGroupData(group, sections, higherIsBetter) {
 	const baselineSamples = group.baseline?.measuredResults.samples;
@@ -1246,6 +1414,18 @@ function prepareBenchmarkData(report, sections) {
 		sectionStats: sections ? extractSectionStats(report, sections) : void 0
 	};
 }
+/** Flip CI percent for metrics where higher is better (e.g., lines/sec) */
+function flipCI(ci) {
+	return {
+		percent: -ci.percent,
+		ci: [-ci.ci[1], -ci.ci[0]],
+		direction: ci.direction,
+		histogram: ci.histogram?.map((bin) => ({
+			x: -bin.x,
+			count: bin.count
+		}))
+	};
+}
 /** @return formatted stats from all sections for tooltip display */
 function extractSectionStats(report, sections) {
 	return sections.flatMap((section) => {
@@ -1274,36 +1454,34 @@ function formatColumnStat(values, col, groupTitle) {
 //#region src/heap-sample/HeapSampleReport.ts
 /** Sum selfSize across all nodes in profile (before any filtering) */
 function totalProfileBytes(profile) {
-	let total = 0;
-	function walk(node) {
-		total += node.selfSize;
-		for (const child of node.children || []) walk(child);
-	}
-	walk(profile.head);
-	return total;
+	return resolveProfile(profile).totalBytes;
 }
-/** Flatten profile tree into sorted list of allocation sites with call stacks */
-function flattenProfile(profile) {
+/** Flatten resolved profile into sorted list of allocation sites with call stacks.
+*  When raw samples are available, attaches them to corresponding sites. */
+function flattenProfile(resolved) {
 	const sites = [];
-	function walk(node, stack) {
-		const { functionName, url, lineNumber, columnNumber } = node.callFrame;
-		const fn = functionName || "(anonymous)";
-		const col = columnNumber ?? 0;
-		const frame = {
-			fn,
-			url: url || "",
-			line: lineNumber + 1,
-			col
-		};
-		const newStack = [...stack, frame];
-		if (node.selfSize > 0) sites.push({
+	const nodeIdToSites = /* @__PURE__ */ new Map();
+	for (const node of resolved.allocationNodes) {
+		const frame = toCallFrame(node.frame);
+		const stack = node.stack.map(toCallFrame);
+		const site = {
 			...frame,
 			bytes: node.selfSize,
-			stack: newStack
-		});
-		for (const child of node.children || []) walk(child, newStack);
+			stack
+		};
+		sites.push(site);
+		const existing = nodeIdToSites.get(node.nodeId);
+		if (existing) existing.push(site);
+		else nodeIdToSites.set(node.nodeId, [site]);
+	}
+	for (const sample of resolved.sortedSamples ?? []) {
+		const matchingSites = nodeIdToSites.get(sample.nodeId);
+		if (!matchingSites) continue;
+		for (const site of matchingSites) {
+			if (!site.samples) site.samples = [];
+			site.samples.push(sample);
+		}
 	}
-	walk(profile.head, []);
 	return sites.sort((a, b) => b.bytes - a.bytes);
 }
 /** Check if site is user code (not node internals) */
@@ -1326,22 +1504,31 @@ function isBrowserUserCode(site) {
 function filterSites(sites, isUser = isNodeUserCode) {
 	return sites.filter(isUser);
 }
-/** Aggregate sites by location (combine same file:line:col) */
+/** Aggregate sites by location (combine same file:line:col).
+*  Tracks distinct caller stacks with byte weights when merging. */
 function aggregateSites(sites) {
 	const byLocation = /* @__PURE__ */ new Map();
 	for (const site of sites) {
-		const key = `${site.url}:${site.line}:${site.col}`;
+		const key = site.col != null ? `${site.url}:${site.line}:${site.col}` : `${site.url}:${site.line}:?:${site.fn}`;
 		const existing = byLocation.get(key);
-		if (existing) existing.bytes += site.bytes;
-		else byLocation.set(key, { ...site });
+		if (existing) {
+			existing.bytes += site.bytes;
+			addCaller(existing, site);
+		} else {
+			const entry = { ...site };
+			if (site.stack) entry.callers = [{
+				stack: site.stack,
+				bytes: site.bytes
+			}];
+			byLocation.set(key, entry);
+		}
+	}
+	for (const site of byLocation.values()) if (site.callers && site.callers.length > 1) {
+		site.callers.sort((a, b) => b.bytes - a.bytes);
+		site.stack = site.callers[0].stack;
 	}
 	return [...byLocation.values()].sort((a, b) => b.bytes - a.bytes);
 }
-function fmtBytes(bytes) {
-	if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
-	if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-	return `${bytes} B`;
-}
 /** Format heap report for console output */
 function formatHeapReport(sites, options) {
 	const { topN, stackDepth = 3, verbose = false } = options;
@@ -1357,34 +1544,79 @@ function formatHeapReport(sites, options) {
 	if (sampleCount !== void 0) lines.push(`Samples: ${sampleCount.toLocaleString()}`);
 	return lines.join("\n");
 }
-/** Compact single-line format: `49 MB  fn1 <- fn2 <- fn3` */
-function formatCompactSite(lines, site, stackDepth, isUser) {
+/** Format every raw sample as one line, ordered by ordinal (time).
+*  Output is tab-separated for easy piping/grep/diff. */
+function formatRawSamples(resolved) {
+	if (!resolved.sortedSamples || resolved.sortedSamples.length === 0) return "No raw samples available.";
+	const lines = ["ordinal	size	function	location"];
+	for (const s of resolved.sortedSamples) {
+		const node = resolved.nodeMap.get(s.nodeId);
+		const fn = node?.frame.name || "(unknown)";
+		const url = node?.frame.url || "";
+		const loc = url ? fmtLoc(url, node.frame.line, node.frame.col) : "(unknown)";
+		lines.push(`${s.ordinal}\t${s.size}\t${fn}\t${loc}`);
+	}
+	return lines.join("\n");
+}
+function toCallFrame(f) {
+	return {
+		fn: f.name,
+		url: f.url,
+		line: f.line,
+		col: f.col
+	};
+}
+/** Add a caller stack to an aggregated site, merging if the same path exists */
+function addCaller(existing, site) {
+	if (!site.stack) return;
+	if (!existing.callers) existing.callers = [];
+	const key = callerKey(site.stack);
+	const match = existing.callers.find((c) => callerKey(c.stack) === key);
+	if (match) match.bytes += site.bytes;
+	else existing.callers.push({
+		stack: site.stack,
+		bytes: site.bytes
+	});
+}
+/** Verbose multi-line format with file:// paths and line numbers */
+function formatVerboseSite(lines, site, stackDepth, isUser) {
 	const bytes = fmtBytes(site.bytes).padStart(10);
-	const fns = [site.fn];
+	const loc = site.url ? fmtLoc(site.url, site.line, site.col) : "(unknown)";
+	const dimFn = isUser(site) ? (s) => s : pico.dim;
+	lines.push(dimFn(`${bytes}  ${site.fn}  ${loc}`));
 	if (site.stack && site.stack.length > 1) {
 		const callers = site.stack.slice(0, -1).reverse().slice(0, stackDepth);
 		for (const frame of callers) {
 			if (!frame.url || !isUser(frame)) continue;
-			fns.push(frame.fn);
+			const callerLoc = fmtLoc(frame.url, frame.line, frame.col);
+			lines.push(dimFn(`            <- ${frame.fn}  ${callerLoc}`));
 		}
 	}
-	const line = `${bytes}  ${fns.join(" <- ")}`;
-	lines.push(isUser(site) ? line : pico.dim(line));
 }
-/** Verbose multi-line format with file:// paths and line numbers */
-function formatVerboseSite(lines, site, stackDepth, isUser) {
+/** Compact single-line format: `49 MB  fn1 <- fn2 <- fn3` */
+function formatCompactSite(lines, site, stackDepth, isUser) {
 	const bytes = fmtBytes(site.bytes).padStart(10);
-	const loc = site.url ? `${site.url}:${site.line}:${site.col}` : "(unknown)";
-	const dimFn = isUser(site) ? (s) => s : pico.dim;
-	lines.push(dimFn(`${bytes}  ${site.fn}  ${loc}`));
+	const fns = [site.fn];
 	if (site.stack && site.stack.length > 1) {
 		const callers = site.stack.slice(0, -1).reverse().slice(0, stackDepth);
 		for (const frame of callers) {
 			if (!frame.url || !isUser(frame)) continue;
-			const callerLoc = `${frame.url}:${frame.line}:${frame.col}`;
-			lines.push(dimFn(`            <- ${frame.fn}  ${callerLoc}`));
+			fns.push(frame.fn);
 		}
 	}
+	const line = `${bytes}  ${fns.join(" <- ")}`;
+	lines.push(isUser(site) ? line : pico.dim(line));
+}
+function fmtBytes(bytes) {
+	return formatBytes(bytes, { space: true }) ?? `${bytes} B`;
+}
+/** Format location, omitting column when unknown */
+function fmtLoc(url, line, col) {
+	return col != null ? `${url}:${line}:${col}` : `${url}:${line}`;
+}
+/** Serialize a call stack for dedup comparison */
+function callerKey(stack) {
+	return stack.map((f) => `${f.url}:${f.line}:${f.col}`).join("|");
 }
 
 //#endregion
@@ -1395,6 +1627,18 @@ const skipArgs = new Set([
 	"html",
 	"export-html"
 ]);
+const badgeLabels = {
+	faster: "Faster",
+	slower: "Slower",
+	uncertain: "Inconclusive"
+};
+const defaultArgs = {
+	worker: true,
+	time: 5,
+	warmup: 500,
+	"pause-interval": 0,
+	"pause-duration": 100
+};
 /** Format ISO date as local time with UTC: "Jan 9, 2026, 3:45 PM (2026-01-09T23:45:00Z)" */
 function formatDateWithTimezone(isoDate) {
 	const date = new Date(isoDate);
@@ -1423,62 +1667,6 @@ function formatRelativeTime(isoDate) {
 		day: "numeric"
 	});
 }
-/** Format git version for display: "abc1234* (5m ago)" */
-function formatVersion(version) {
-	if (!version || version.hash === "unknown") return "unknown";
-	const hashDisplay = version.dirty ? `${version.hash}*` : version.hash;
-	const timeDisplay = version.date ? formatRelativeTime(version.date) : "";
-	return timeDisplay ? `${hashDisplay} (${timeDisplay})` : hashDisplay;
-}
-/** Render current/baseline version info as an HTML div */
-function versionInfoHtml(data) {
-	const { currentVersion, baselineVersion } = data.metadata;
-	if (!currentVersion && !baselineVersion) return "";
-	const parts = [];
-	if (currentVersion) parts.push(`Current: ${formatVersion(currentVersion)}`);
-	if (baselineVersion) parts.push(`Baseline: ${formatVersion(baselineVersion)}`);
-	return `<div class="version-info">${parts.join(" | ")}</div>`;
-}
-const badgeLabels = {
-	faster: "Faster",
-	slower: "Slower",
-	uncertain: "Inconclusive"
-};
-/** Render faster/slower/uncertain badge with CI plot container */
-function comparisonBadge(group, groupIndex) {
-	const ci = group.benchmarks[0]?.comparisonCI;
-	if (!ci) return "";
-	const label = badgeLabels[ci.direction];
-	return `
-    <span class="badge badge-${ci.direction}">${label}</span>
-    <div id="ci-plot-${groupIndex}" class="ci-plot-container"></div>
-  `;
-}
-const defaultArgs = {
-	worker: true,
-	time: 5,
-	warmup: 500,
-	"pause-interval": 0,
-	"pause-duration": 100
-};
-/** @return true if this CLI arg should be hidden from the report header */
-function shouldSkipArg(key, value, adaptive) {
-	if (skipArgs.has(key) || value === void 0 || value === false) return true;
-	if (defaultArgs[key] === value) return true;
-	if (!key.includes("-") && key !== key.toLowerCase()) return true;
-	if (key === "convergence" && !adaptive) return true;
-	return false;
-}
-/** Reconstruct the CLI invocation string, omitting default/internal args */
-function formatCliArgs(args) {
-	if (!args) return "bb bench";
-	const parts = ["bb bench"];
-	for (const [key, value] of Object.entries(args)) {
-		if (shouldSkipArg(key, value, args.adaptive)) continue;
-		parts.push(value === true ? `--${key}` : `--${key} ${value}`);
-	}
-	return parts.join(" ");
-}
 /** Generate complete HTML document with embedded data and visualizations */
 function generateHtmlDocument(data) {
 	return `<!DOCTYPE html>
@@ -1653,14 +1841,58 @@ function generateHtmlDocument(data) {
 </body>
 </html>`;
 }
-
-//#endregion
-//#region src/html/HtmlReport.ts
-/** Generate HTML report from prepared data and optionally open in browser */
-async function generateHtmlReport(data, options) {
-	const html = generateHtmlDocument(data);
-	const reportDir = options.outputPath || await createReportDir();
-	await mkdir(reportDir, { recursive: true });
+/** Reconstruct the CLI invocation string, omitting default/internal args */
+function formatCliArgs(args) {
+	if (!args) return "bb bench";
+	const parts = ["bb bench"];
+	for (const [key, value] of Object.entries(args)) {
+		if (shouldSkipArg(key, value, args.adaptive)) continue;
+		parts.push(value === true ? `--${key}` : `--${key} ${value}`);
+	}
+	return parts.join(" ");
+}
+/** Render current/baseline version info as an HTML div */
+function versionInfoHtml(data) {
+	const { currentVersion, baselineVersion } = data.metadata;
+	if (!currentVersion && !baselineVersion) return "";
+	const parts = [];
+	if (currentVersion) parts.push(`Current: ${formatVersion(currentVersion)}`);
+	if (baselineVersion) parts.push(`Baseline: ${formatVersion(baselineVersion)}`);
+	return `<div class="version-info">${parts.join(" | ")}</div>`;
+}
+/** Render faster/slower/uncertain badge with CI plot container */
+function comparisonBadge(group, groupIndex) {
+	const ci = group.benchmarks[0]?.comparisonCI;
+	if (!ci) return "";
+	const label = badgeLabels[ci.direction];
+	return `
+    <span class="badge badge-${ci.direction}">${label}</span>
+    <div id="ci-plot-${groupIndex}" class="ci-plot-container"></div>
+  `;
+}
+/** @return true if this CLI arg should be hidden from the report header */
+function shouldSkipArg(key, value, adaptive) {
+	if (skipArgs.has(key) || value === void 0 || value === false) return true;
+	if (defaultArgs[key] === value) return true;
+	if (!key.includes("-") && key !== key.toLowerCase()) return true;
+	if (key === "convergence" && !adaptive) return true;
+	return false;
+}
+/** Format git version for display: "abc1234* (5m ago)" */
+function formatVersion(version) {
+	if (!version || version.hash === "unknown") return "unknown";
+	const hashDisplay = version.dirty ? `${version.hash}*` : version.hash;
+	const timeDisplay = version.date ? formatRelativeTime(version.date) : "";
+	return timeDisplay ? `${hashDisplay} (${timeDisplay})` : hashDisplay;
+}
+
+//#endregion
+//#region src/html/HtmlReport.ts
+/** Generate HTML report from prepared data and optionally open in browser */
+async function generateHtmlReport(data, options) {
+	const html = generateHtmlDocument(data);
+	const reportDir = options.outputPath || await createReportDir();
+	await mkdir(reportDir, { recursive: true });
 	await writeFile(join(reportDir, "index.html"), html, "utf-8");
 	const plots = await loadPlotsBundle();
 	await writeFile(join(reportDir, "plots.js"), plots, "utf-8");
@@ -1683,6 +1915,35 @@ async function generateHtmlReport(data, options) {
 		closeServer
 	};
 }
+/** Create a timestamped report directory under ./bench-report/ */
+async function createReportDir() {
+	const base = "./bench-report";
+	await mkdir(base, { recursive: true });
+	return join(base, `report-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}`);
+}
+/** Read the pre-built browser plots bundle from dist/ */
+async function loadPlotsBundle() {
+	const thisDir = dirname(fileURLToPath(import.meta.url));
+	const builtPath = join(thisDir, "browser/index.js");
+	const devPath = join(thisDir, "../../dist/browser/index.js");
+	try {
+		return await readFile(builtPath, "utf-8");
+	} catch {}
+	return readFile(devPath, "utf-8");
+}
+/** Write an index.html in the parent dir that redirects to this report */
+async function writeLatestRedirect(reportDir) {
+	const baseDir = dirname(reportDir);
+	const reportName = reportDir.split("/").pop();
+	const html = `<!DOCTYPE html>
+<html><head>
+  <meta http-equiv="refresh" content="0; url=./${reportName}/">
+  <script>location.href = "./${reportName}/";<\/script>
+</head><body>
+  <a href="./${reportName}/">Latest report</a>
+</body></html>`;
+	await writeFile(join(baseDir, "index.html"), html, "utf-8");
+}
 /** Start HTTP server for report directory, trying fallback ports if needed */
 async function startReportServer(baseDir, ...ports) {
 	const mimeTypes = {
@@ -1723,35 +1984,6 @@ function tryListen(server, port) {
 		});
 	});
 }
-/** Create a timestamped report directory under ./bench-report/ */
-async function createReportDir() {
-	const base = "./bench-report";
-	await mkdir(base, { recursive: true });
-	return join(base, `report-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}`);
-}
-/** Read the pre-built browser plots bundle from dist/ */
-async function loadPlotsBundle() {
-	const thisDir = dirname(fileURLToPath(import.meta.url));
-	const builtPath = join(thisDir, "browser/index.js");
-	const devPath = join(thisDir, "../../dist/browser/index.js");
-	try {
-		return await readFile(builtPath, "utf-8");
-	} catch {}
-	return readFile(devPath, "utf-8");
-}
-/** Write an index.html in the parent dir that redirects to this report */
-async function writeLatestRedirect(reportDir) {
-	const baseDir = dirname(reportDir);
-	const reportName = reportDir.split("/").pop();
-	const html = `<!DOCTYPE html>
-<html><head>
-  <meta http-equiv="refresh" content="0; url=./${reportName}/">
-  <script>location.href = "./${reportName}/";<\/script>
-</head><body>
-  <a href="./${reportName}/">Latest report</a>
-</body></html>`;
-	await writeFile(join(baseDir, "index.html"), html, "utf-8");
-}
 
 //#endregion
 //#region src/matrix/MatrixFilter.ts
@@ -2029,13 +2261,6 @@ const adaptiveSection = {
 		formatter: formatConvergence
 	}] }]
 };
-/** Build generic sections based on CLI flags */
-function buildGenericSections(args) {
-	const sections = [];
-	if (args["gc-stats"]) sections.push(gcStatsSection);
-	sections.push(runsSection);
-	return sections;
-}
 /** Section: V8 optimization tier distribution and deopt count */
 const optSection = {
 	extract: (results) => {
@@ -2060,14 +2285,52 @@ const optSection = {
 		}]
 	}]
 };
+/** Build generic sections based on CLI flags */
+function buildGenericSections(args) {
+	const sections = [];
+	if (args["gc-stats"]) sections.push(gcStatsSection);
+	sections.push(runsSection);
+	return sections;
+}
 
 //#endregion
 //#region src/matrix/MatrixReport.ts
+/** GC statistics columns - derived from gcStatsSection for consistency */
+const gcStatsColumns = gcStatsSection.columns()[0].columns.map((col) => ({
+	key: col.key,
+	title: col.title,
+	groupTitle: "GC",
+	extract: (r) => gcStatsSection.extract(r.measured)[col.key],
+	formatter: (v) => col.formatter?.(v) ?? "-"
+}));
+/** GC pause time column */
+const gcPauseColumn = {
+	key: "gcPause",
+	title: "pause",
+	groupTitle: "GC",
+	extract: (r) => r.measured.gcStats?.gcPauseTime,
+	formatter: (v) => v != null ? `${v.toFixed(1)}ms` : "-"
+};
+/** Heap sampling total bytes column */
+const heapTotalColumn = {
+	key: "heapTotal",
+	title: "heap",
+	extract: (r) => {
+		const profile = r.measured.heapProfile;
+		if (!profile?.head) return void 0;
+		return totalProfileBytes(profile);
+	},
+	formatter: formatBytesOrDash
+};
 /** Format matrix results as one table per case */
 function reportMatrixResults(results, options) {
 	const tables = buildCaseTables(results, options);
 	return [`Matrix: ${results.name}`, ...tables].join("\n\n");
 }
+/** Format bytes with fallback to "-" for missing values */
+function formatBytesOrDash(value) {
+	return formatBytes(value) ?? "-";
+}
 /** Build one table for each case showing all variants */
 function buildCaseTables(results, options) {
 	if (results.variants.length === 0) return [];
@@ -2080,6 +2343,12 @@ function buildCaseTable(results, caseId, options) {
 	const rows = buildCaseRows(results, caseId, options?.extraColumns);
 	return `${caseTitle}\n${buildTable(buildColumns(rows.some((r) => r.diffCI), options), [{ results: rows }])}`;
 }
+/** Format case title with metadata if available */
+function formatCaseTitle(results, caseId) {
+	const metadata = (results.variants[0]?.cases.find((c) => c.caseId === caseId))?.metadata;
+	if (metadata && Object.keys(metadata).length > 0) return `${caseId} (${Object.entries(metadata).map(([k, v]) => `${v} ${k}`).join(", ")})`;
+	return caseId;
+}
 /** Build table using ResultsMapper sections */
 function buildSectionTable(results, caseId, options, caseTitle) {
 	const sections = options.sections;
@@ -2100,15 +2369,6 @@ function buildSectionTable(results, caseId, options, caseTitle) {
 	}
 	return `${caseTitle}\n${buildTable(buildSectionColumns(sections, variantTitle, hasBaseline), [{ results: rows }])}`;
 }
-/** Build column groups from ResultsMapper sections */
-function buildSectionColumns(sections, variantTitle, hasBaseline) {
-	const nameCol = { columns: [{
-		key: "name",
-		title: variantTitle
-	}] };
-	const sectionColumns = sections.flatMap((s) => s.columns());
-	return [nameCol, ...hasBaseline ? injectDiffColumns(sectionColumns) : sectionColumns];
-}
 /** Build rows for all variants for a given case */
 function buildCaseRows(results, caseId, extraColumns) {
 	return results.variants.flatMap((variant) => {
@@ -2116,20 +2376,6 @@ function buildCaseRows(results, caseId, extraColumns) {
 		return caseResult ? [buildRow(variant.id, caseResult, extraColumns)] : [];
 	});
 }
-/** Build a single row from case result */
-function buildRow(variantId, caseResult, extraColumns) {
-	const { measured, baseline } = caseResult;
-	const samples = measured.samples;
-	const time = measured.time?.avg ?? average(samples);
-	const row = {
-		name: truncate(variantId, 25),
-		time,
-		samples: samples.length
-	};
-	if (baseline) row.diffCI = bootstrapDifferenceCI(baseline.samples, samples);
-	if (extraColumns) for (const col of extraColumns) row[col.key] = col.extract(caseResult);
-	return row;
-}
 /** Build column configuration */
 function buildColumns(hasBaseline, options) {
 	const groups = [{ columns: [{
@@ -2163,48 +2409,34 @@ function buildColumns(hasBaseline, options) {
 	}
 	return groups;
 }
+/** Build column groups from ResultsMapper sections */
+function buildSectionColumns(sections, variantTitle, hasBaseline) {
+	const nameCol = { columns: [{
+		key: "name",
+		title: variantTitle
+	}] };
+	const sectionColumns = sections.flatMap((s) => s.columns());
+	return [nameCol, ...hasBaseline ? injectDiffColumns(sectionColumns) : sectionColumns];
+}
+/** Build a single row from case result */
+function buildRow(variantId, caseResult, extraColumns) {
+	const { measured, baseline } = caseResult;
+	const samples = measured.samples;
+	const time = measured.time?.avg ?? average(samples);
+	const row = {
+		name: truncate(variantId, 25),
+		time,
+		samples: samples.length
+	};
+	if (baseline) row.diffCI = bootstrapDifferenceCI(baseline.samples, samples);
+	if (extraColumns) for (const col of extraColumns) row[col.key] = col.extract(caseResult);
+	return row;
+}
 /** Format diff with CI, or "baseline" marker */
 function formatDiff(value) {
 	if (!value) return null;
 	return formatDiffWithCI(value);
 }
-/** Format case title with metadata if available */
-function formatCaseTitle(results, caseId) {
-	const metadata = (results.variants[0]?.cases.find((c) => c.caseId === caseId))?.metadata;
-	if (metadata && Object.keys(metadata).length > 0) return `${caseId} (${Object.entries(metadata).map(([k, v]) => `${v} ${k}`).join(", ")})`;
-	return caseId;
-}
-/** GC statistics columns - derived from gcStatsSection for consistency */
-const gcStatsColumns = gcStatsSection.columns()[0].columns.map((col) => ({
-	key: col.key,
-	title: col.title,
-	groupTitle: "GC",
-	extract: (r) => gcStatsSection.extract(r.measured)[col.key],
-	formatter: (v) => col.formatter?.(v) ?? "-"
-}));
-/** Format bytes with fallback to "-" for missing values */
-function formatBytesOrDash(value) {
-	return formatBytes(value) ?? "-";
-}
-/** GC pause time column */
-const gcPauseColumn = {
-	key: "gcPause",
-	title: "pause",
-	groupTitle: "GC",
-	extract: (r) => r.measured.gcStats?.gcPauseTime,
-	formatter: (v) => v != null ? `${v.toFixed(1)}ms` : "-"
-};
-/** Heap sampling total bytes column */
-const heapTotalColumn = {
-	key: "heapTotal",
-	title: "heap",
-	extract: (r) => {
-		const profile = r.measured.heapProfile;
-		if (!profile?.head) return void 0;
-		return totalProfileBytes(profile);
-	},
-	formatter: formatBytesOrDash
-};
 
 //#endregion
 //#region src/cli/FilterBenchmarks.ts
@@ -2239,32 +2471,21 @@ function createFilterRegex(filter) {
 function stripCaseSuffix(name) {
 	return name.replace(/ \[.*?\]$/, "");
 }
-/** Escape regex special characters */
-function escapeRegex(str) {
-	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 /** Ensure at least one benchmark matches filter */
 function validateFilteredSuite(groups, filter) {
 	if (groups.every((g) => g.benchmarks.length === 0)) throw new Error(`No benchmarks match filter: "${filter}"`);
 }
+/** Escape regex special characters */
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 //#endregion
 //#region src/cli/RunBenchCLI.ts
-/** Validate CLI argument combinations */
-function validateArgs(args) {
-	if (args["gc-stats"] && !args.worker && !args.url) throw new Error("--gc-stats requires worker mode (the default). Remove --no-worker flag.");
-}
-/** Warn about Node-only flags that are ignored in browser mode. */
-function warnBrowserFlags(args) {
-	const ignored = [];
-	if (!args.worker) ignored.push("--no-worker");
-	if (args.cpu) ignored.push("--cpu");
-	if (args["trace-opt"]) ignored.push("--trace-opt");
-	if (args.collect) ignored.push("--collect");
-	if (args.adaptive) ignored.push("--adaptive");
-	if (args.batches > 1) ignored.push("--batches");
-	if (ignored.length) console.warn(yellow(`Ignored in browser mode: ${ignored.join(", ")}`));
-}
+const { yellow, dim } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? {
+	yellow: (s) => s,
+	dim: (s) => s
+} : pico;
 /** Parse CLI with custom configuration */
 function parseBenchArgs(configureArgs) {
 	return parseCliArgs(hideBin(process.argv), configureArgs);
@@ -2282,144 +2503,6 @@ async function runBenchmarks(suite, args) {
 		batches
 	});
 }
-/** Execute all groups in suite */
-async function runSuite(params) {
-	const { suite, runner, options, useWorker, batches } = params;
-	const results = [];
-	for (const group of suite.groups) results.push(await runGroup(group, runner, options, useWorker, batches));
-	return results;
-}
-/** Execute group with shared setup, optionally batching to reduce ordering bias */
-async function runGroup(group, runner, options, useWorker, batches = 1) {
-	const { name, benchmarks, baseline, setup, metadata } = group;
-	const setupParams = await setup?.();
-	validateBenchmarkParameters(group);
-	const runParams = {
-		runner,
-		options,
-		useWorker,
-		params: setupParams,
-		metadata
-	};
-	if (batches === 1) return runSingleBatch(name, benchmarks, baseline, runParams);
-	return runMultipleBatches(name, benchmarks, baseline, runParams, batches);
-}
-/** Run benchmarks in a single batch */
-async function runSingleBatch(name, benchmarks, baseline, runParams) {
-	const baselineReport = baseline ? await runSingleBenchmark(baseline, runParams) : void 0;
-	return {
-		name,
-		reports: await serialMap(benchmarks, (b) => runSingleBenchmark(b, runParams)),
-		baseline: baselineReport
-	};
-}
-/** Run benchmarks in multiple batches, alternating order to reduce bias */
-async function runMultipleBatches(name, benchmarks, baseline, runParams, batches) {
-	const timePerBatch = (runParams.options.maxTime || 5e3) / batches;
-	const batchParams = {
-		...runParams,
-		options: {
-			...runParams.options,
-			maxTime: timePerBatch
-		}
-	};
-	const baselineBatches = [];
-	const benchmarkBatches = /* @__PURE__ */ new Map();
-	for (let i = 0; i < batches; i++) await runBatchIteration(benchmarks, baseline, batchParams, i % 2 === 1, baselineBatches, benchmarkBatches);
-	const meta = runParams.metadata;
-	return mergeBatchResults(name, benchmarks, baseline, baselineBatches, benchmarkBatches, meta);
-}
-/** Run one batch iteration in either order */
-async function runBatchIteration(benchmarks, baseline, runParams, reverseOrder, baselineBatches, benchmarkBatches) {
-	const runBaseline = async () => {
-		if (baseline) {
-			const r = await runSingleBenchmark(baseline, runParams);
-			baselineBatches.push(r.measuredResults);
-		}
-	};
-	const runBenches = async () => {
-		for (const b of benchmarks) {
-			const r = await runSingleBenchmark(b, runParams);
-			appendToMap(benchmarkBatches, b.name, r.measuredResults);
-		}
-	};
-	if (reverseOrder) {
-		await runBenches();
-		await runBaseline();
-	} else {
-		await runBaseline();
-		await runBenches();
-	}
-}
-/** Merge batch results into final ReportGroup */
-function mergeBatchResults(name, benchmarks, baseline, baselineBatches, benchmarkBatches, metadata) {
-	const mergedBaseline = baseline ? {
-		name: baseline.name,
-		measuredResults: mergeResults(baselineBatches),
-		metadata
-	} : void 0;
-	return {
-		name,
-		reports: benchmarks.map((b) => ({
-			name: b.name,
-			measuredResults: mergeResults(benchmarkBatches.get(b.name) || []),
-			metadata
-		})),
-		baseline: mergedBaseline
-	};
-}
-/** Run single benchmark and create report */
-async function runSingleBenchmark(spec, runParams) {
-	const { runner, options, useWorker, params, metadata } = runParams;
-	const [result] = await runBenchmark({
-		spec,
-		runner,
-		options,
-		useWorker,
-		params
-	});
-	return {
-		name: spec.name,
-		measuredResults: result,
-		metadata
-	};
-}
-/** Warn if parameterized benchmarks lack setup */
-function validateBenchmarkParameters(group) {
-	const { name, setup, benchmarks, baseline } = group;
-	if (setup) return;
-	const allBenchmarks = baseline ? [...benchmarks, baseline] : benchmarks;
-	for (const benchmark of allBenchmarks) if (benchmark.fn.length > 0) console.warn(`Benchmark "${benchmark.name}" in group "${name}" expects parameters but no setup() provided.`);
-}
-/** Merge multiple batch results into a single MeasuredResults */
-function mergeResults(results) {
-	if (results.length === 0) throw new Error("Cannot merge empty results array");
-	if (results.length === 1) return results[0];
-	const allSamples = results.flatMap((r) => r.samples);
-	const allWarmup = results.flatMap((r) => r.warmupSamples || []);
-	const time = computeStats(allSamples);
-	let offset = 0;
-	const allPausePoints = results.flatMap((r) => {
-		const pts = (r.pausePoints ?? []).map((p) => ({
-			sampleIndex: p.sampleIndex + offset,
-			durationMs: p.durationMs
-		}));
-		offset += r.samples.length;
-		return pts;
-	});
-	return {
-		name: results[0].name,
-		samples: allSamples,
-		warmupSamples: allWarmup.length ? allWarmup : void 0,
-		time,
-		totalTime: results.reduce((sum, r) => sum + (r.totalTime || 0), 0),
-		pausePoints: allPausePoints.length ? allPausePoints : void 0
-	};
-}
-function appendToMap(map, key, value) {
-	if (!map.has(key)) map.set(key, []);
-	map.get(key).push(value);
-}
 /** Generate table with standard sections */
 function defaultReport(groups, args) {
 	const { adaptive, "gc-stats": gcStats, "trace-opt": traceOpt } = args;
@@ -2427,15 +2510,6 @@ function defaultReport(groups, args) {
 	const hasOpt = hasField(groups, "optStatus");
 	return reportResults(groups, buildReportSections(adaptive, gcStats, hasCpu, traceOpt && hasOpt));
 }
-/** Build report sections based on CLI options */
-function buildReportSections(adaptive, gcStats, hasCpuData, hasOptData) {
-	const sections = adaptive ? [adaptiveSection, totalTimeSection] : [timeSection];
-	if (gcStats) sections.push(gcStatsSection);
-	if (hasCpuData) sections.push(cpuSection);
-	if (hasOptData) sections.push(optSection);
-	sections.push(runsSection);
-	return sections;
-}
 /** Run benchmarks, display table, and optionally generate HTML report */
 async function benchExports(suite, args) {
 	const results = await runBenchmarks(suite, args);
@@ -2448,7 +2522,7 @@ async function browserBenchExports(args) {
 	warnBrowserFlags(args);
 	let profileBrowser;
 	try {
-		({profileBrowser} = await import("./BrowserHeapSampler-DCeL42RE.mjs"));
+		({profileBrowser} = await import("./BrowserHeapSampler-B6asLKWQ.mjs"));
 	} catch {
 		throw new Error("playwright is required for browser benchmarking (--url).\n\nQuick start:  npx benchforge-browser --url <your-url>\n\nOr install manually:\n  npm install playwright\n  npx playwright install chromium");
 	}
@@ -2456,7 +2530,7 @@ async function browserBenchExports(args) {
 	const { iterations, time } = args;
 	const result = await profileBrowser({
 		url,
-		heapSample: args["heap-sample"],
+		heapSample: needsHeapSample(args),
 		heapOptions: {
 			samplingInterval: args["heap-interval"],
 			stackDepth: args["heap-depth"]
@@ -2475,82 +2549,29 @@ async function browserBenchExports(args) {
 		args
 	});
 }
-/** Print browser benchmark tables and heap reports */
-function printBrowserReport(result, results, args) {
-	const hasSamples = result.samples && result.samples.length > 0;
-	const sections = [];
-	if (hasSamples || result.wallTimeMs != null) sections.push(timeSection);
-	if (result.gcStats) sections.push(browserGcStatsSection);
-	if (hasSamples || result.wallTimeMs != null) sections.push(runsSection);
-	if (sections.length > 0) console.log(reportResults(results, sections));
-	if (result.heapProfile) printHeapReports(results, {
-		...cliHeapReportOptions(args),
-		isUserCode: isBrowserUserCode
-	});
-}
-/** Wrap browser profile result as ReportGroup[] for the standard pipeline */
-function browserResultGroups(name, result) {
-	const { gcStats, heapProfile } = result;
-	let measured;
-	if (result.samples && result.samples.length > 0) {
-		const { samples } = result;
-		const totalTime = result.wallTimeMs ? result.wallTimeMs / 1e3 : void 0;
-		measured = {
-			name,
-			samples,
-			time: computeStats(samples),
-			totalTime,
-			gcStats,
-			heapProfile
-		};
-	} else {
-		const wallMs = result.wallTimeMs ?? 0;
-		measured = {
-			name,
-			samples: [wallMs],
-			time: {
-				min: wallMs,
-				max: wallMs,
-				avg: wallMs,
-				p50: wallMs,
-				p75: wallMs,
-				p99: wallMs,
-				p999: wallMs
-			},
-			gcStats,
-			heapProfile
-		};
-	}
-	return [{
-		name,
-		reports: [{
-			name,
-			measuredResults: measured
-		}]
-	}];
-}
 /** Print heap allocation reports for benchmarks with heap profiles */
 function printHeapReports(groups, options) {
-	for (const group of groups) {
-		const allReports = group.baseline ? [...group.reports, group.baseline] : group.reports;
-		for (const report of allReports) {
-			const { heapProfile } = report.measuredResults;
-			if (!heapProfile) continue;
-			console.log(dim(`\n─── Heap profile: ${report.name} ───`));
-			const totalAll = totalProfileBytes(heapProfile);
-			const sites = flattenProfile(heapProfile);
-			const userSites = filterSites(sites, options.isUserCode);
-			const totalUserCode = userSites.reduce((sum, s) => sum + s.bytes, 0);
-			const aggregated = aggregateSites(options.userOnly ? userSites : sites);
-			const extra = {
-				totalAll,
-				totalUserCode,
-				sampleCount: heapProfile.samples?.length
-			};
-			console.log(formatHeapReport(aggregated, {
-				...options,
-				...extra
-			}));
+	for (const group of groups) for (const report of groupReports(group)) {
+		const { heapProfile } = report.measuredResults;
+		if (!heapProfile) continue;
+		console.log(dim(`\n─── Heap profile: ${report.name} ───`));
+		const resolved = resolveProfile(heapProfile);
+		const sites = flattenProfile(resolved);
+		const userSites = filterSites(sites, options.isUserCode);
+		const totalUserCode = userSites.reduce((sum, s) => sum + s.bytes, 0);
+		const aggregated = aggregateSites(options.userOnly ? userSites : sites);
+		const extra = {
+			totalAll: resolved.totalBytes,
+			totalUserCode,
+			sampleCount: resolved.sortedSamples?.length
+		};
+		console.log(formatHeapReport(aggregated, {
+			...options,
+			...extra
+		}));
+		if (options.raw) {
+			console.log(dim(`\n─── Raw samples: ${report.name} ───`));
+			console.log(formatRawSamples(resolved));
 		}
 	}
 }
@@ -2559,7 +2580,8 @@ async function runDefaultBench(suite, configureArgs) {
 	const args = parseBenchArgs(configureArgs);
 	if (args.url) await browserBenchExports(args);
 	else if (suite) await benchExports(suite, args);
-	else throw new Error("Either --url or a BenchSuite is required.");
+	else if (args.file) await fileBenchExports(args.file, args);
+	else throw new Error("Provide a benchmark file, --url for browser mode, or pass a BenchSuite directly.");
 }
 /** Convert CLI args to runner options */
 function cliToRunnerOptions(args) {
@@ -2576,77 +2598,28 @@ function cliToRunnerOptions(args) {
 		...cliCommonOptions(args)
 	};
 }
-/** Create options for adaptive mode */
-function createAdaptiveOptions(args) {
-	return {
-		minTime: (args["min-time"] ?? 1) * 1e3,
-		maxTime: defaultAdaptiveMaxTime * 1e3,
-		targetConfidence: args.convergence,
-		adaptive: true,
-		...cliCommonOptions(args)
-	};
-}
-/** Runner/matrix options shared across all CLI modes */
-function cliCommonOptions(args) {
-	const { collect, cpu, warmup } = args;
-	const { "trace-opt": traceOpt, "skip-settle": noSettle } = args;
-	const { "pause-first": pauseFirst, "pause-interval": pauseInterval } = args;
-	const { "pause-duration": pauseDuration, "gc-stats": gcStats } = args;
-	const { "heap-sample": heapSample, "heap-interval": heapInterval } = args;
-	const { "heap-depth": heapDepth } = args;
-	return {
-		collect,
-		cpuCounters: cpu,
-		warmup,
-		traceOpt,
-		noSettle,
-		pauseFirst,
-		pauseInterval,
-		pauseDuration,
-		gcStats,
-		heapSample,
-		heapInterval,
-		heapDepth
-	};
-}
-const { yellow, dim } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? {
-	yellow: (s) => s,
-	dim: (s) => s
-} : pico;
-/** Log V8 optimization tier distribution and deoptimizations */
-function reportOptStatus(groups) {
-	const optData = groups.flatMap(({ reports, baseline }) => {
-		return (baseline ? [...reports, baseline] : reports).filter((r) => r.measuredResults.optStatus).map((r) => ({
-			name: r.name,
-			opt: r.measuredResults.optStatus,
-			samples: r.measuredResults.samples.length
-		}));
-	});
-	if (optData.length === 0) return;
-	console.log(dim("\nV8 optimization:"));
-	for (const { name, opt, samples } of optData) {
-		const total = Object.values(opt.byTier).reduce((s, t) => s + t.count, 0);
-		const tierParts = Object.entries(opt.byTier).sort((a, b) => b[1].count - a[1].count).map(([tier, info]) => `${tier} ${(info.count / total * 100).toFixed(0)}%`).join(", ");
-		console.log(`  ${name}: ${tierParts} ${dim(`(${samples} samples)`)}`);
-	}
-	const totalDeopts = optData.reduce((s, d) => s + d.opt.deoptCount, 0);
-	if (totalDeopts > 0) console.log(yellow(`  ⚠ ${totalDeopts} deoptimization${totalDeopts > 1 ? "s" : ""} detected`));
+/** Log V8 optimization tier distribution and deoptimizations */
+function reportOptStatus(groups) {
+	const optData = groups.flatMap((group) => {
+		return groupReports(group).filter((r) => r.measuredResults.optStatus).map((r) => ({
+			name: r.name,
+			opt: r.measuredResults.optStatus,
+			samples: r.measuredResults.samples.length
+		}));
+	});
+	if (optData.length === 0) return;
+	console.log(dim("\nV8 optimization:"));
+	for (const { name, opt, samples } of optData) {
+		const total = Object.values(opt.byTier).reduce((s, t) => s + t.count, 0);
+		const tierParts = Object.entries(opt.byTier).sort((a, b) => b[1].count - a[1].count).map(([tier, info]) => `${tier} ${(info.count / total * 100).toFixed(0)}%`).join(", ");
+		console.log(`  ${name}: ${tierParts} ${dim(`(${samples} samples)`)}`);
+	}
+	const totalDeopts = optData.reduce((s, d) => s + d.opt.deoptCount, 0);
+	if (totalDeopts > 0) console.log(yellow(`  ⚠ ${totalDeopts} deoptimization${totalDeopts > 1 ? "s" : ""} detected`));
 }
 /** @return true if any result has the specified field with a defined value */
 function hasField(results, field) {
-	return results.some(({ reports, baseline }) => {
-		return (baseline ? [...reports, baseline] : reports).some(({ measuredResults }) => measuredResults[field] !== void 0);
-	});
-}
-/** Print heap reports (if enabled) and export results */
-async function finishReports(results, args, suiteName, exportOptions) {
-	if (args["heap-sample"]) printHeapReports(results, cliHeapReportOptions(args));
-	await exportReports({
-		results,
-		args,
-		suiteName,
-		...exportOptions
-	});
+	return results.some((group) => groupReports(group).some(({ measuredResults }) => measuredResults[field] !== void 0));
 }
 /** Export reports (HTML, JSON, Perfetto) based on CLI args */
 async function exportReports(options) {
@@ -2664,22 +2637,14 @@ async function exportReports(options) {
 		outputPath: args["export-html"]
 	})).closeServer;
 	if (args.json) await exportBenchmarkJson(results, args.json, args, suiteName);
-	if (args.perfetto) exportPerfettoTrace(results, args.perfetto, args);
+	if (args["export-perfetto"]) exportPerfettoTrace(results, args["export-perfetto"], args);
+	if (args["export-speedscope"]) exportSpeedscope(results, args["export-speedscope"]);
+	if (args.speedscope) exportAndLaunchSpeedscope(results);
 	if (openInBrowser) {
 		await waitForCtrlC();
 		closeServer?.();
 	}
 }
-/** Wait for Ctrl+C before exiting */
-function waitForCtrlC() {
-	return new Promise((resolve) => {
-		console.log(dim("\nPress Ctrl+C to exit"));
-		process.on("SIGINT", () => {
-			console.log();
-			resolve();
-		});
-	});
-}
 /** Run matrix suite with CLI arguments.
 *  no options ==> defaultCases/defaultVariants, --filter ==> subset of defaults,
 *  --all --filter ==> subset of all, --all ==> all cases/variants */
@@ -2721,24 +2686,6 @@ function defaultMatrixReport(results, reportOptions, args) {
 	const options = args ? mergeMatrixDefaults(reportOptions, args, results) : reportOptions;
 	return results.map((r) => reportMatrixResults(r, options)).join("\n\n");
 }
-/** @return HeapReportOptions from CLI args */
-function cliHeapReportOptions(args) {
-	return {
-		topN: args["heap-rows"],
-		stackDepth: args["heap-stack"],
-		verbose: args["heap-verbose"],
-		userOnly: args["heap-user-only"]
-	};
-}
-/** Apply default sections and extra columns for matrix reports */
-function mergeMatrixDefaults(reportOptions, args, results) {
-	const result = { ...reportOptions };
-	if (!result.sections?.length) {
-		const groups = matrixToReportGroups(results);
-		result.sections = buildReportSections(args.adaptive, args["gc-stats"], hasField(groups, "cpu"), args["trace-opt"] && hasField(groups, "optStatus"));
-	}
-	return result;
-}
 /** Run matrix suite with full CLI handling (parse, run, report, export) */
 async function runDefaultMatrixBench(suite, configureArgs, reportOptions) {
 	await matrixBenchExports(suite, parseBenchArgs(configureArgs), reportOptions);
@@ -2764,6 +2711,58 @@ function matrixToReportGroups(results) {
 		};
 	})));
 }
+/** Run matrix benchmarks, display table, and generate exports */
+async function matrixBenchExports(suite, args, reportOptions, exportOptions) {
+	const results = await runMatrixSuite(suite, args);
+	const report = defaultMatrixReport(results, reportOptions, args);
+	console.log(report);
+	await finishReports(matrixToReportGroups(results), args, suite.name, exportOptions);
+}
+/** Validate CLI argument combinations */
+function validateArgs(args) {
+	if (args["gc-stats"] && !args.worker && !args.url) throw new Error("--gc-stats requires worker mode (the default). Remove --no-worker flag.");
+}
+/** Execute all groups in suite */
+async function runSuite(params) {
+	const { suite, runner, options, useWorker, batches } = params;
+	const results = [];
+	for (const group of suite.groups) results.push(await runGroup(group, runner, options, useWorker, batches));
+	return results;
+}
+/** Build report sections based on CLI options */
+function buildReportSections(adaptive, gcStats, hasCpuData, hasOptData) {
+	const sections = adaptive ? [adaptiveSection, totalTimeSection] : [timeSection];
+	if (gcStats) sections.push(gcStatsSection);
+	if (hasCpuData) sections.push(cpuSection);
+	if (hasOptData) sections.push(optSection);
+	sections.push(runsSection);
+	return sections;
+}
+/** Print heap reports (if enabled) and export results */
+async function finishReports(results, args, suiteName, exportOptions) {
+	if (needsHeapSample(args)) printHeapReports(results, cliHeapReportOptions(args));
+	await exportReports({
+		results,
+		args,
+		suiteName,
+		...exportOptions
+	});
+}
+/** Warn about Node-only flags that are ignored in browser mode. */
+function warnBrowserFlags(args) {
+	const ignored = [];
+	if (!args.worker) ignored.push("--no-worker");
+	if (args.cpu) ignored.push("--cpu");
+	if (args["trace-opt"]) ignored.push("--trace-opt");
+	if (args.collect) ignored.push("--collect");
+	if (args.adaptive) ignored.push("--adaptive");
+	if (args.batches > 1) ignored.push("--batches");
+	if (ignored.length) console.warn(yellow(`Ignored in browser mode: ${ignored.join(", ")}`));
+}
+/** @return true if any heap-related flag implies heap sampling */
+function needsHeapSample(args) {
+	return args["heap-sample"] || args.speedscope || !!args["export-speedscope"] || args["heap-raw"] || args["heap-verbose"] || args["heap-user-only"];
+}
 /** Strip surrounding quotes from a chrome arg token.
 *
 * (Needed because --chrome-args values pass through yargs and spawn() without
@@ -2772,18 +2771,278 @@ function matrixToReportGroups(results) {
 function stripQuotes(s) {
 	return s.replace(/^(['"])(.*)\1$/s, "$2").replace(/^(-[^=]+=)(['"])(.*)\2$/s, "$1$3");
 }
+/** Wrap browser profile result as ReportGroup[] for the standard pipeline */
+function browserResultGroups(name, result) {
+	const { gcStats, heapProfile } = result;
+	let measured;
+	if (result.samples && result.samples.length > 0) {
+		const { samples } = result;
+		const totalTime = result.wallTimeMs ? result.wallTimeMs / 1e3 : void 0;
+		measured = {
+			name,
+			samples,
+			time: computeStats(samples),
+			totalTime,
+			gcStats,
+			heapProfile
+		};
+	} else {
+		const wallMs = result.wallTimeMs ?? 0;
+		measured = {
+			name,
+			samples: [wallMs],
+			time: {
+				min: wallMs,
+				max: wallMs,
+				avg: wallMs,
+				p50: wallMs,
+				p75: wallMs,
+				p99: wallMs,
+				p999: wallMs
+			},
+			gcStats,
+			heapProfile
+		};
+	}
+	return [{
+		name,
+		reports: [{
+			name,
+			measuredResults: measured
+		}]
+	}];
+}
+/** Print browser benchmark tables and heap reports */
+function printBrowserReport(result, results, args) {
+	const hasSamples = result.samples && result.samples.length > 0;
+	const sections = [];
+	if (hasSamples || result.wallTimeMs != null) sections.push(timeSection);
+	if (result.gcStats) sections.push(browserGcStatsSection);
+	if (hasSamples || result.wallTimeMs != null) sections.push(runsSection);
+	if (sections.length > 0) console.log(reportResults(results, sections));
+	if (result.heapProfile) printHeapReports(results, {
+		...cliHeapReportOptions(args),
+		isUserCode: isBrowserUserCode
+	});
+}
+/** Import a file and run it as a benchmark based on what it exports */
+async function fileBenchExports(filePath, args) {
+	const candidate = (await import(pathToFileURL(resolve(filePath)).href)).default;
+	if (candidate && Array.isArray(candidate.matrices)) await matrixBenchExports(candidate, args);
+	else if (candidate && Array.isArray(candidate.groups)) await benchExports(candidate, args);
+	else if (typeof candidate === "function") {
+		const name = basename(filePath).replace(/\.[^.]+$/, "");
+		await benchExports({
+			name,
+			groups: [{
+				name,
+				benchmarks: [{
+					name,
+					fn: candidate
+				}]
+			}]
+		}, args);
+	}
+}
+/** Create options for adaptive mode */
+function createAdaptiveOptions(args) {
+	return {
+		minTime: (args["min-time"] ?? 1) * 1e3,
+		maxTime: defaultAdaptiveMaxTime * 1e3,
+		targetConfidence: args.convergence,
+		adaptive: true,
+		...cliCommonOptions(args)
+	};
+}
+/** Runner/matrix options shared across all CLI modes */
+function cliCommonOptions(args) {
+	const { collect, cpu, warmup } = args;
+	const { "trace-opt": traceOpt, "skip-settle": noSettle } = args;
+	const { "pause-first": pauseFirst, "pause-interval": pauseInterval } = args;
+	const { "pause-duration": pauseDuration, "gc-stats": gcStats } = args;
+	const heapSample = needsHeapSample(args);
+	const { "heap-interval": heapInterval } = args;
+	const { "heap-depth": heapDepth } = args;
+	return {
+		collect,
+		cpuCounters: cpu,
+		warmup,
+		traceOpt,
+		noSettle,
+		pauseFirst,
+		pauseInterval,
+		pauseDuration,
+		gcStats,
+		heapSample,
+		heapInterval,
+		heapDepth
+	};
+}
+/** Wait for Ctrl+C before exiting */
+function waitForCtrlC() {
+	return new Promise((resolve) => {
+		console.log(dim("\nPress Ctrl+C to exit"));
+		process.on("SIGINT", () => {
+			console.log();
+			resolve();
+		});
+	});
+}
+/** Apply default sections and extra columns for matrix reports */
+function mergeMatrixDefaults(reportOptions, args, results) {
+	const result = { ...reportOptions };
+	if (!result.sections?.length) {
+		const groups = matrixToReportGroups(results);
+		result.sections = buildReportSections(args.adaptive, args["gc-stats"], hasField(groups, "cpu"), args["trace-opt"] && hasField(groups, "optStatus"));
+	}
+	return result;
+}
+/** Execute group with shared setup, optionally batching to reduce ordering bias */
+async function runGroup(group, runner, options, useWorker, batches = 1) {
+	const { name, benchmarks, baseline, setup, metadata } = group;
+	const setupParams = await setup?.();
+	validateBenchmarkParameters(group);
+	const runParams = {
+		runner,
+		options,
+		useWorker,
+		params: setupParams,
+		metadata
+	};
+	if (batches === 1) return runSingleBatch(name, benchmarks, baseline, runParams);
+	return runMultipleBatches(name, benchmarks, baseline, runParams, batches);
+}
+/** @return HeapReportOptions from CLI args */
+function cliHeapReportOptions(args) {
+	return {
+		topN: args["heap-rows"],
+		stackDepth: args["heap-stack"],
+		verbose: args["heap-verbose"],
+		raw: args["heap-raw"],
+		userOnly: args["heap-user-only"]
+	};
+}
+/** Warn if parameterized benchmarks lack setup */
+function validateBenchmarkParameters(group) {
+	const { name, setup, benchmarks, baseline } = group;
+	if (setup) return;
+	const allBenchmarks = baseline ? [...benchmarks, baseline] : benchmarks;
+	for (const benchmark of allBenchmarks) if (benchmark.fn.length > 0) console.warn(`Benchmark "${benchmark.name}" in group "${name}" expects parameters but no setup() provided.`);
+}
+/** Run benchmarks in a single batch */
+async function runSingleBatch(name, benchmarks, baseline, runParams) {
+	const baselineReport = baseline ? await runSingleBenchmark(baseline, runParams) : void 0;
+	return {
+		name,
+		reports: await serialMap(benchmarks, (b) => runSingleBenchmark(b, runParams)),
+		baseline: baselineReport
+	};
+}
+/** Run benchmarks in multiple batches, alternating order to reduce bias */
+async function runMultipleBatches(name, benchmarks, baseline, runParams, batches) {
+	const timePerBatch = (runParams.options.maxTime || 5e3) / batches;
+	const batchParams = {
+		...runParams,
+		options: {
+			...runParams.options,
+			maxTime: timePerBatch
+		}
+	};
+	const baselineBatches = [];
+	const benchmarkBatches = /* @__PURE__ */ new Map();
+	for (let i = 0; i < batches; i++) await runBatchIteration(benchmarks, baseline, batchParams, i % 2 === 1, baselineBatches, benchmarkBatches);
+	const meta = runParams.metadata;
+	return mergeBatchResults(name, benchmarks, baseline, baselineBatches, benchmarkBatches, meta);
+}
+/** Run single benchmark and create report */
+async function runSingleBenchmark(spec, runParams) {
+	const { runner, options, useWorker, params, metadata } = runParams;
+	const [result] = await runBenchmark({
+		spec,
+		runner,
+		options,
+		useWorker,
+		params
+	});
+	return {
+		name: spec.name,
+		measuredResults: result,
+		metadata
+	};
+}
 /** Sequential map - like Promise.all(arr.map(fn)) but runs one at a time */
 async function serialMap(arr, fn) {
 	const results = [];
 	for (const item of arr) results.push(await fn(item));
 	return results;
 }
-/** Run matrix benchmarks, display table, and generate exports */
-async function matrixBenchExports(suite, args, reportOptions, exportOptions) {
-	const results = await runMatrixSuite(suite, args);
-	const report = defaultMatrixReport(results, reportOptions, args);
-	console.log(report);
-	await finishReports(matrixToReportGroups(results), args, suite.name, exportOptions);
+/** Run one batch iteration in either order */
+async function runBatchIteration(benchmarks, baseline, runParams, reverseOrder, baselineBatches, benchmarkBatches) {
+	const runBaseline = async () => {
+		if (baseline) {
+			const r = await runSingleBenchmark(baseline, runParams);
+			baselineBatches.push(r.measuredResults);
+		}
+	};
+	const runBenches = async () => {
+		for (const b of benchmarks) {
+			const r = await runSingleBenchmark(b, runParams);
+			appendToMap(benchmarkBatches, b.name, r.measuredResults);
+		}
+	};
+	if (reverseOrder) {
+		await runBenches();
+		await runBaseline();
+	} else {
+		await runBaseline();
+		await runBenches();
+	}
+}
+/** Merge batch results into final ReportGroup */
+function mergeBatchResults(name, benchmarks, baseline, baselineBatches, benchmarkBatches, metadata) {
+	const mergedBaseline = baseline ? {
+		name: baseline.name,
+		measuredResults: mergeResults(baselineBatches),
+		metadata
+	} : void 0;
+	return {
+		name,
+		reports: benchmarks.map((b) => ({
+			name: b.name,
+			measuredResults: mergeResults(benchmarkBatches.get(b.name) || []),
+			metadata
+		})),
+		baseline: mergedBaseline
+	};
+}
+function appendToMap(map, key, value) {
+	if (!map.has(key)) map.set(key, []);
+	map.get(key).push(value);
+}
+/** Merge multiple batch results into a single MeasuredResults */
+function mergeResults(results) {
+	if (results.length === 0) throw new Error("Cannot merge empty results array");
+	if (results.length === 1) return results[0];
+	const allSamples = results.flatMap((r) => r.samples);
+	const allWarmup = results.flatMap((r) => r.warmupSamples || []);
+	const time = computeStats(allSamples);
+	let offset = 0;
+	const allPausePoints = results.flatMap((r) => {
+		const pts = (r.pausePoints ?? []).map((p) => ({
+			sampleIndex: p.sampleIndex + offset,
+			durationMs: p.durationMs
+		}));
+		offset += r.samples.length;
+		return pts;
+	});
+	return {
+		name: results[0].name,
+		samples: allSamples,
+		warmupSamples: allWarmup.length ? allWarmup : void 0,
+		time,
+		totalTime: results.reduce((sum, r) => sum + (r.totalTime || 0), 0),
+		pausePoints: allPausePoints.length ? allPausePoints : void 0
+	};
 }
 
 //#endregion
@@ -2845,5 +3104,5 @@ function getMostRecentModifiedDate(dir) {
 }
 
 //#endregion
-export { timeSection as A, parseCliArgs as B, adaptiveSection as C, gcStatsSection as D, gcSection as E, generateHtmlReport as F, truncate as G, formatBytes as H, formatDateWithTimezone as I, loadCaseData as J, isStatefulVariant as K, prepareHtmlData as L, formatConvergence as M, filterMatrix as N, optSection as O, parseMatrixFilter as P, exportPerfettoTrace as R, reportMatrixResults as S, cpuSection as T, integer as U, reportResults as V, timeMs as W, loadCasesModule as Y, runDefaultMatrixBench as _, cliToMatrixOptions as a, gcStatsColumns as b, exportReports as c, matrixToReportGroups as d, parseBenchArgs as f, runDefaultBench as g, runBenchmarks as h, benchExports as i, totalTimeSection as j, runsSection as k, hasField as l, reportOptStatus as m, getBaselineVersion as n, defaultMatrixReport as o, printHeapReports as p, runMatrix as q, getCurrentGitVersion as r, defaultReport as s, formatGitVersion as t, matrixBenchExports as u, runMatrixSuite as v, buildGenericSections as w, heapTotalColumn as x, gcPauseColumn as y, defaultCliArgs as z };
-//# sourceMappingURL=src-HfimYuW_.mjs.map
+export { loadCasesModule as $, timeSection as A, heapProfileToSpeedscope as B, adaptiveSection as C, gcStatsSection as D, gcSection as E, generateHtmlReport as F, reportResults as G, exportPerfettoTrace as H, formatDateWithTimezone as I, timeMs as J, formatBytes as K, prepareHtmlData as L, formatConvergence as M, filterMatrix as N, optSection as O, parseMatrixFilter as P, loadCaseData as Q, exportAndLaunchSpeedscope as R, reportMatrixResults as S, cpuSection as T, defaultCliArgs as U, launchSpeedscope as V, parseCliArgs as W, isStatefulVariant as X, truncate as Y, runMatrix as Z, runDefaultMatrixBench as _, cliToMatrixOptions as a, gcStatsColumns as b, exportReports as c, matrixToReportGroups as d, parseBenchArgs as f, runDefaultBench as g, runBenchmarks as h, benchExports as i, totalTimeSection as j, runsSection as k, hasField as l, reportOptStatus as m, getBaselineVersion as n, defaultMatrixReport as o, printHeapReports as p, integer as q, getCurrentGitVersion as r, defaultReport as s, formatGitVersion as t, matrixBenchExports as u, runMatrixSuite as v, buildGenericSections as w, heapTotalColumn as x, gcPauseColumn as y, exportSpeedscope as z };
+//# sourceMappingURL=src-B-DDaCa9.mjs.map