benchforge 0.1.9 → 0.2.4

package/dist/RunBenchCLI-C17DrJz8.mjs

@@ -0,0 +1,3075 @@
+import { C as resolveProfile, S as resolveCallFrame, _ as groupReports, a as archiveBenchmark, b as binBootstrapResult, d as internFrame, f as speedscopeFile, g as findPrimaryColumn, h as extractSectionValues, i as waitForCtrlC, m as computeDiffCI, n as startViewerServer, o as collectSources, p as computeColumnValues, s as buildSpeedscopeFile, t as optionalJson, u as frameContext, v as hasField, x as diffCIs, y as isHigherIsBetter } from "./ViewerServer-BJhdnxlN.mjs";
+import { C as swapDirection, g as percentile, l as flipCI, n as bootstrapCIs, p as median, t as average, u as isBootstrappable } from "./StatisticalUtils-BD92crgM.mjs";
+import { c as timeMs, i as formatDiffWithCI, l as truncate, n as formatBytes, o as integer, r as formatConvergence, s as percent, t as diffPercent, u as colors } from "./Formatters-BWj3d4sv.mjs";
+import { d as mergeGcStats, f as runBatched, h as loadCasesModule, l as discoverVariants, n as runMatrix, p as computeStats, r as runBenchmark, u as aggregateGcStats } from "./BenchMatrix-BZVrBB_h.mjs";
+import yargs from "yargs";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { execFileSync, spawn } from "node:child_process";
+import { table } from "table";
+import { hideBin } from "yargs/helpers";
+import { tmpdir } from "node:os";
+//#region src/cli/CliArgs.ts
+const cliOptions = {
+	duration: {
+		type: "number",
+		requiresArg: true,
+		describe: "duration per batch in seconds (default: 0.642)"
+	},
+	iterations: {
+		type: "number",
+		requiresArg: true,
+		describe: "iterations per batch (page loads for page-load mode, inner loop for bench)"
+	},
+	warmup: {
+		type: "number",
+		default: 0,
+		describe: "warmup iterations before measurement"
+	},
+	filter: {
+		type: "string",
+		requiresArg: true,
+		describe: "filter by name/regex. Matrix: case/variant, case/, /variant"
+	},
+	all: {
+		type: "boolean",
+		default: false,
+		describe: "run all cases (ignore defaultCases)"
+	},
+	list: {
+		type: "boolean",
+		default: false,
+		describe: "list available benchmarks (or matrix cases/variants)"
+	},
+	worker: {
+		type: "boolean",
+		default: true,
+		describe: "run in worker process for isolation (default: true)"
+	},
+	batches: {
+		type: "number",
+		default: 1,
+		describe: "divide time into N batches, alternating baseline/current order"
+	},
+	"warmup-batch": {
+		type: "boolean",
+		default: false,
+		describe: "include first batch in results (normally dropped to avoid OS cache warmup)"
+	},
+	"equiv-margin": {
+		type: "number",
+		default: 2,
+		describe: "equivalence margin % for baseline comparison (0 to disable)"
+	},
+	"no-batch-trim": {
+		type: "boolean",
+		default: false,
+		describe: "disable Tukey trimming of outlier batches"
+	},
+	"pause-first": {
+		type: "number",
+		describe: "iterations before first pause (then pause-interval applies)"
+	},
+	"pause-interval": {
+		type: "number",
+		default: 0,
+		describe: "iterations between pauses for V8 optimization (0 to disable)"
+	},
+	"pause-duration": {
+		type: "number",
+		default: 100,
+		describe: "pause duration in ms for V8 optimization"
+	},
+	"gc-stats": {
+		type: "boolean",
+		default: false,
+		describe: "collect GC statistics (Node: --trace-gc-nvp, browser: CDP tracing)"
+	},
+	"gc-force": {
+		type: "boolean",
+		default: false,
+		describe: "force GC after each iteration"
+	},
+	adaptive: {
+		type: "boolean",
+		default: false,
+		describe: "adaptive sampling (experimental)"
+	},
+	"min-time": {
+		type: "number",
+		default: 1,
+		describe: "minimum time before adaptive convergence can stop"
+	},
+	convergence: {
+		type: "number",
+		default: 95,
+		describe: "adaptive confidence threshold (0-100)"
+	},
+	alloc: {
+		type: "boolean",
+		default: false,
+		describe: "allocation sampling attribution (includes garbage)"
+	},
+	"alloc-interval": {
+		type: "number",
+		default: 32768,
+		describe: "allocation sampling interval in bytes"
+	},
+	"alloc-depth": {
+		type: "number",
+		default: 64,
+		describe: "allocation sampling stack depth"
+	},
+	"alloc-rows": {
+		type: "number",
+		default: 20,
+		describe: "top allocation sites to show"
+	},
+	"alloc-stack": {
+		type: "number",
+		default: 3,
+		describe: "call stack depth to display"
+	},
+	"alloc-verbose": {
+		type: "boolean",
+		default: false,
+		describe: "verbose output with file:// paths and line numbers"
+	},
+	"alloc-raw": {
+		type: "boolean",
+		default: false,
+		describe: "dump every raw allocation sample (ordinal, size, stack)"
+	},
+	"alloc-user-only": {
+		type: "boolean",
+		default: false,
+		describe: "filter to user code only (hide node internals)"
+	},
+	profile: {
+		type: "boolean",
+		default: false,
+		alias: "time-sample",
+		describe: "V8 CPU time sampling profiler"
+	},
+	"profile-interval": {
+		type: "number",
+		default: 1e3,
+		alias: "time-interval",
+		describe: "CPU sampling interval in microseconds"
+	},
+	"call-counts": {
+		type: "boolean",
+		default: false,
+		describe: "collect per-function execution counts via V8 precise coverage"
+	},
+	stats: {
+		type: "string",
+		default: "mean,p50,p99",
+		describe: "timing columns: mean|median|min|max|p<N> (e.g. mean,p70,p99)"
+	},
+	view: {
+		type: "boolean",
+		default: false,
+		alias: "html",
+		describe: "open viewer in browser"
+	},
+	"view-serve": {
+		type: "boolean",
+		default: false,
+		describe: "start viewer server without opening browser (reload an existing tab)"
+	},
+	"export-perfetto": {
+		type: "string",
+		requiresArg: true,
+		describe: "export Perfetto trace file (view at ui.perfetto.dev)"
+	},
+	"export-profile": {
+		type: "string",
+		requiresArg: true,
+		alias: "export-time",
+		describe: "export CPU profile as .cpuprofile (V8/Chrome DevTools format)"
+	},
+	archive: {
+		type: "string",
+		describe: "archive profile + sources to .benchforge file"
+	},
+	editor: {
+		type: "string",
+		default: "vscode",
+		describe: "editor for source links: vscode, cursor, or custom://scheme"
+	},
+	inspect: {
+		type: "boolean",
+		default: false,
+		describe: "run once for external profiler attach"
+	},
+	"trace-opt": {
+		type: "boolean",
+		default: false,
+		describe: "trace V8 optimization tiers (requires --allow-natives-syntax)"
+	},
+	"pause-warmup": {
+		type: "number",
+		default: 0,
+		requiresArg: true,
+		describe: "post-warmup settle time in ms for V8 background compilation (0 to skip)"
+	},
+	url: {
+		type: "string",
+		requiresArg: true,
+		describe: "page URL for browser profiling (enables browser mode)"
+	},
+	"page-load": {
+		type: "boolean",
+		default: false,
+		describe: "passive page-load profiling (no __bench needed)"
+	},
+	"wait-for": {
+		type: "string",
+		requiresArg: true,
+		describe: "page-load completion: CSS selector, JS expression, 'load', or 'domcontentloaded'"
+	},
+	headless: {
+		type: "boolean",
+		default: false,
+		describe: "run browser in headless mode (default: headed)"
+	},
+	timeout: {
+		type: "number",
+		default: 60,
+		describe: "browser page timeout in seconds"
+	},
+	chrome: {
+		type: "string",
+		requiresArg: true,
+		describe: "Chrome binary path (default: auto-detect or CHROME_PATH)"
+	},
+	"chrome-profile": {
+		type: "string",
+		requiresArg: true,
+		describe: "Chrome user profile directory (default: temp profile)"
+	},
+	"baseline-url": {
+		type: "string",
+		requiresArg: true,
+		describe: "baseline URL for A/B comparison (fresh tab per batch)"
+	},
+	"chrome-args": {
+		type: "string",
+		array: true,
+		requiresArg: true,
+		describe: "extra Chromium flags"
+	}
+};
+const defaultDuration = .642;
+/** Default values for all CLI options, including alias keys for yargs filtering. */
+const cliDefaults = Object.fromEntries(Object.entries(cliOptions).filter(([, opt]) => "default" in opt).flatMap(([key, opt]) => {
+	const o = opt;
+	const entries = [[key, o.default]];
+	if (o.alias) entries.push([o.alias, o.default]);
+	return entries;
+}));
+const optionGroups = {
+	"Run:": ["duration", "iterations"],
+	"Batching:": [
+		"batches",
+		"warmup-batch",
+		"no-batch-trim"
+	],
+	"Node:": ["worker", "inspect"],
+	"Browser:": [
+		"url",
+		"baseline-url",
+		"page-load",
+		"wait-for",
+		"headless",
+		"timeout",
+		"chrome",
+		"chrome-profile",
+		"chrome-args"
+	],
+	"GC:": ["gc-stats", "gc-force"],
+	"Allocation Profiling:": [
+		"alloc",
+		"alloc-interval",
+		"alloc-depth",
+		"alloc-rows",
+		"alloc-stack",
+		"alloc-verbose",
+		"alloc-raw",
+		"alloc-user-only"
+	],
+	"CPU Profiling:": [
+		"profile",
+		"profile-interval",
+		"call-counts"
+	],
+	"Output:": [
+		"stats",
+		"view",
+		"view-serve",
+		"equiv-margin",
+		"archive",
+		"export-perfetto",
+		"export-profile",
+		"editor"
+	],
+	"Selecting Benchmarks:": [
+		"filter",
+		"all",
+		"list"
+	],
+	"V8 Tuning:": [
+		"warmup",
+		"trace-opt",
+		"pause-first",
+		"pause-interval",
+		"pause-duration",
+		"pause-warmup"
+	],
+	"Adaptive:": [
+		"adaptive",
+		"min-time",
+		"convergence"
+	]
+};
+const { url: _url, ...browserOnlyOptions } = cliOptions;
+/** Parse command line arguments with optional custom yargs configuration. */
+function parseCliArgs(args, configure = defaultCliArgs) {
+	return configure(yargs(args)).parseSync();
+}
+/** Configure yargs for browser benchmarking with url as a required positional. */
+function browserCliArgs(yargsInstance) {
+	return applyGroups(yargsInstance.command("$0 <url>", "run browser benchmarks", (y) => {
+		y.positional("url", {
+			type: "string",
+			describe: "page URL for browser profiling"
+		});
+	}).options(browserOnlyOptions).help().strict());
+}
+/** Configure yargs with standard benchmark options and file positional. */
+function defaultCliArgs(yargsInstance) {
+	return applyGroups(yargsInstance.command("$0 [file]", "run benchmarks", (y) => {
+		y.positional("file", {
+			type: "string",
+			describe: "benchmark file to run"
+		});
+	}).options(cliOptions).help().strict());
+}
+/** Strip yargs internals (`_`, `$0`) and undefined values, converting kebab-case to camelCase. */
+function cleanCliArgs(args) {
+	const skip = new Set(["_", "$0"]);
+	const camel = (k) => k.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+	return Object.fromEntries(Object.entries(args).filter(([k, v]) => v !== void 0 && v !== null && !skip.has(k)).map(([k, v]) => [camel(k), v]));
+}
+/** Assign options to their labeled groups in yargs help output. */
+function applyGroups(y) {
+	return Object.entries(optionGroups).reduce((acc, [label, keys]) => acc.group(keys, label), y);
+}
+//#endregion
+//#region src/export/CoverageExport.ts
+/** Build coverage data from raw CDP/inspector coverage and source texts. */
+function buildCoverageMap(coverage, sources) {
+	const map = /* @__PURE__ */ new Map();
+	const byName = /* @__PURE__ */ new Map();
+	for (const script of coverage.scripts) processScript(script, sources, map, byName);
+	return {
+		map,
+		byName
+	};
+}
+/** Annotate speedscope frame names with execution counts (e.g. "fn [1.2K]"). */
+function annotateFramesWithCounts(frames, coverage) {
+	for (const frame of frames) {
+		const entries = frame.file ? coverage.map.get(frame.file) : void 0;
+		const count = entries && findCount(frame.name, frame.line, entries);
+		const isAnon = frame.name.startsWith("(anonymous");
+		const resolved = count ?? (isAnon ? void 0 : coverage.byName.get(frame.name));
+		if (resolved !== void 0 && resolved > 0) frame.name = `${frame.name} [${formatCount(resolved)}]`;
+	}
+}
+/** Extract per-function coverage entries from a single script. */
+function processScript(script, sources, map, byName) {
+	const { url, functions } = script;
+	const source = url ? sources[url] : void 0;
+	const lineOffsets = source ? buildLineOffsets(source) : void 0;
+	const entries = [];
+	for (const fn of functions) {
+		const range = fn.ranges[0];
+		if (!range) continue;
+		if (lineOffsets && url) entries.push({
+			startLine: offsetToLine(range.startOffset, lineOffsets),
+			functionName: fn.functionName,
+			count: range.count
+		});
+		if (fn.functionName && range.count > 0) {
+			const prev = byName.get(fn.functionName) ?? 0;
+			byName.set(fn.functionName, prev + range.count);
+		}
+	}
+	if (entries.length > 0 && url) map.set(url, entries);
+}
+/** Match a frame to a coverage entry by function name (or closest line for anonymous). */
+function findCount(frameName, frameLine, entries) {
+	if (frameName === "(anonymous)" || frameName.startsWith("(anonymous ")) {
+		if (!frameLine) return void 0;
+		return closestByLine(entries.filter((e) => e.functionName === ""), frameLine)?.count;
+	}
+	const nameMatches = entries.filter((e) => e.functionName === frameName);
+	if (nameMatches.length === 0) return void 0;
+	if (nameMatches.length === 1) return nameMatches[0].count;
+	if (frameLine) return closestByLine(nameMatches, frameLine)?.count;
+	return nameMatches[0].count;
+}
+/** Format a count for display (e.g. 1234567 ==> "1.2M"). */
+function formatCount(n) {
+	if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+	if (n >= 1e4) return `${(n / 1e3).toFixed(1)}K`;
+	return String(n);
+}
+/** Build array where index i is the character offset where line (i+1) starts. */
+function buildLineOffsets(source) {
+	const offsets = [0];
+	for (let i = 0; i < source.length; i++) if (source[i] === "\n") offsets.push(i + 1);
+	return offsets;
+}
+/** Convert character offset to 1-indexed line number via binary search. */
+function offsetToLine(offset, lineOffsets) {
+	let lo = 0;
+	let hi = lineOffsets.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >> 1;
+		if (lineOffsets[mid] <= offset) lo = mid;
+		else hi = mid - 1;
+	}
+	return lo + 1;
+}
+/** Find the entry whose startLine is closest to the given line. */
+function closestByLine(entries, line) {
+	if (!entries.length) return void 0;
+	const dist = (e) => Math.abs(e.startLine - line);
+	return entries.reduce((best, e) => dist(e) < dist(best) ? e : best);
+}
+//#endregion
+//#region src/export/EditorUri.ts
+const presets = {
+	vscode: "vscode://file",
+	cursor: "cursor://file"
+};
+/** Resolve editor name or custom URI to a prefix.
+*  Links are formatted as `{prefix}{absolutePath}:{line}:{col}` */
+function resolveEditorUri(editor) {
+	return presets[editor] ?? editor;
+}
+//#endregion
+//#region src/export/PerfettoExport.ts
+/** Export benchmark samples to Chrome Trace Event format for viewing in Perfetto. */
+const pid = 1;
+const tid = 1;
+/** Export benchmark results to Perfetto-compatible trace file */
+function exportPerfettoTrace(groups, outputPath, args) {
+	const absPath = resolve(outputPath);
+	const traceFile = { traceEvents: mergeV8Trace(buildTraceEvents(groups, args)) };
+	writeFileSync(absPath, JSON.stringify(traceFile));
+	console.log(`Perfetto trace exported to: ${outputPath}`);
+	scheduleDeferredMerge(absPath);
+}
+function buildTraceEvents(groups, cliArgs) {
+	const metadata = [
+		meta("process_name", { name: "wesl-bench" }),
+		meta("thread_name", { name: "MainThread" }),
+		meta("bench_settings", cleanCliArgs(cliArgs))
+	];
+	const benchEvents = groups.flatMap((group) => group.reports.flatMap((report) => buildBenchmarkEvents(report.measuredResults)));
+	return [...metadata, ...benchEvents];
+}
+function mergeV8Trace(events) {
+	const v8Events = loadV8Events(readdirSync(".").find((f) => f.startsWith("node_trace.") && f.endsWith(".log")));
+	const merged = v8Events ? [...v8Events, ...events] : events;
+	normalizeTimestamps(merged);
+	return merged;
+}
+/** V8 writes trace files after process exit, so we spawn a deferred merge. */
+function scheduleDeferredMerge(outputPath) {
+	const cwd = process.cwd();
+	const mergeScript = `
+    const { readdirSync, readFileSync, writeFileSync } = require('fs');
+    function normalize(events) {
+      let min = Infinity;
+      for (const e of events) if (e.ts > 0 && e.ts < min) min = e.ts;
+      if (min === Infinity) return;
+      for (const e of events) if (e.ts > 0) e.ts -= min;
+    }
+    setTimeout(() => {
+      const traceFiles = readdirSync('.').filter(f => f.startsWith('node_trace.') && f.endsWith('.log'));
+      if (traceFiles.length === 0) process.exit(0);
+      try {
+        const v8Data = JSON.parse(readFileSync(traceFiles[0], 'utf-8'));
+        const ourData = JSON.parse(readFileSync('${outputPath}', 'utf-8'));
+        const allEvents = [...v8Data.traceEvents, ...ourData.traceEvents];
+        normalize(allEvents);
+        writeFileSync('${outputPath}', JSON.stringify({ traceEvents: allEvents }));
+        console.log('Merged ' + v8Data.traceEvents.length + ' V8 events into ' + '${outputPath}');
+      } catch (e) { console.error('Merge failed:', e.message); }
+    }, 100);
+  `;
+	process.on("exit", () => {
+		spawn("node", ["-e", mergeScript], {
+			detached: true,
+			stdio: "inherit",
+			cwd
+		}).unref();
+	});
+}
+function meta(name, args) {
+	return {
+		ph: "M",
+		ts: 0,
+		pid,
+		tid,
+		name,
+		args
+	};
+}
+/** Build events for a single benchmark run, deriving timestamps from cumulative sample durations. */
+function buildBenchmarkEvents(results) {
+	const { samples, heapSamples, pausePoints, startTime = 0 } = results;
+	if (!samples?.length) return [];
+	const timestamps = cumulativeTimestamps(samples, startTime);
+	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: mb }));
+		}
+	}
+	for (const pause of pausePoints ?? []) {
+		const ts = timestamps[pause.sampleIndex];
+		if (ts) events.push(instant(ts, "pause", { ms: pause.durationMs }));
+	}
+	return events;
+}
+function loadV8Events(v8TracePath) {
+	if (!v8TracePath) return void 0;
+	try {
+		const { traceEvents } = JSON.parse(readFileSync(v8TracePath, "utf-8"));
+		console.log(`Merged ${traceEvents.length} V8 events from ${v8TracePath}`);
+		return traceEvents;
+	} catch {
+		console.warn(`Could not parse V8 trace file: ${v8TracePath}`);
+		return;
+	}
+}
+/** Normalize timestamps so events start at 0 */
+function normalizeTimestamps(events) {
+	let min = Number.POSITIVE_INFINITY;
+	for (const e of events) if (e.ts > 0 && e.ts < min) min = e.ts;
+	if (min === Number.POSITIVE_INFINITY) return;
+	for (const e of events) if (e.ts > 0) e.ts -= min;
+}
+/** Derive μs timestamps from cumulative sample durations (ms), offset by startTime. */
+function cumulativeTimestamps(samples, offset = 0) {
+	const timestamps = new Array(samples.length);
+	let cumulative = 0;
+	for (let i = 0; i < samples.length; i++) {
+		cumulative += samples[i];
+		timestamps[i] = offset + Math.round(cumulative * 1e3);
+	}
+	return timestamps;
+}
+/** Create a thread-scoped instant event */
+function instant(ts, name, args) {
+	return {
+		ph: "i",
+		ts,
+		pid,
+		tid,
+		cat: "bench",
+		name,
+		s: "t",
+		args
+	};
+}
+/** Create a counter event (shown as a time-series chart in Perfetto) */
+function counter(ts, name, args) {
+	return {
+		ph: "C",
+		ts,
+		pid,
+		tid,
+		cat: "bench",
+		name,
+		args
+	};
+}
+//#endregion
+//#region src/export/TimeExport.ts
+/** CPU time profile conversion to Speedscope sampled format. */
+/** Build a SpeedscopeFile from multiple named time profiles (shared frames). */
+function buildTimeSpeedscopeFile(entries) {
+	if (entries.length === 0) return void 0;
+	const ctx = frameContext();
+	return speedscopeFile(ctx, entries.map((e) => buildTimeProfile(e.name, e.profile, ctx)));
+}
+/** Build a speedscope profile from a V8 TimeProfile */
+function buildTimeProfile(name, profile, ctx) {
+	const { samples: sampleIds, timeDeltas, nodes } = profile;
+	if (!sampleIds?.length || !timeDeltas) return {
+		type: "sampled",
+		name,
+		unit: "microseconds",
+		startValue: 0,
+		endValue: 0,
+		samples: [],
+		weights: []
+	};
+	const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+	const parentMap = /* @__PURE__ */ new Map();
+	for (const node of nodes) for (const childId of node.children ?? []) parentMap.set(childId, node.id);
+	const cache = /* @__PURE__ */ new Map();
+	const resolve = (id) => resolveStack(id, nodeMap, parentMap, cache, ctx);
+	const samples = sampleIds.map(resolve);
+	return {
+		type: "sampled",
+		name,
+		unit: "microseconds",
+		startValue: 0,
+		endValue: timeDeltas.reduce((sum, w) => sum + w, 0),
+		samples,
+		weights: timeDeltas
+	};
+}
+/** Walk from node to root, building a stack of frame indices (root-first) */
+function resolveStack(nodeId, nodeMap, parentMap, cache, ctx) {
+	const cached = cache.get(nodeId);
+	if (cached) return cached;
+	const path = [];
+	let current = nodeId;
+	while (current !== void 0) {
+		path.push(current);
+		current = parentMap.get(current);
+	}
+	const stack = [];
+	for (let i = path.length - 1; i >= 0; i--) {
+		const node = nodeMap.get(path[i]);
+		if (!node) continue;
+		const { functionName, url, lineNumber } = node.callFrame;
+		if (!functionName && !url && lineNumber <= 0) continue;
+		const frame = resolveCallFrame(node.callFrame);
+		stack.push(internFrame(frame.name, frame.url, frame.line, frame.col, ctx));
+	}
+	cache.set(nodeId, stack);
+	return stack;
+}
+//#endregion
+//#region src/profiling/node/HeapSampleReport.ts
+/** 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 = [];
+	const nodeIdToSites = /* @__PURE__ */ new Map();
+	for (const node of resolved.allocationNodes) {
+		const site = {
+			...node.frame,
+			bytes: node.selfSize,
+			stack: node.stack
+		};
+		sites.push(site);
+		const bucket = nodeIdToSites.get(node.nodeId) ?? [];
+		if (!bucket.length) nodeIdToSites.set(node.nodeId, bucket);
+		bucket.push(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);
+		}
+	}
+	return sites.sort((a, b) => b.bytes - a.bytes);
+}
+/** Return true if the call frame is user code (excludes node: and internal/ URLs) */
+function isNodeUserCode(site) {
+	const { url } = site;
+	return !!url && !url.startsWith("node:") && !url.includes("(native)") && !url.includes("internal/");
+}
+/** Return true if the call frame is user code (excludes chrome-extension:// and devtools:// URLs) */
+function isBrowserUserCode(site) {
+	const { url } = site;
+	return !!url && !url.startsWith("chrome-extension://") && !url.startsWith("devtools://") && !url.includes("(native)");
+}
+/** Return only sites matching a user-code predicate (default: {@link isNodeUserCode}) */
+function filterSites(sites, isUser = isNodeUserCode) {
+	return sites.filter(isUser);
+}
+/** 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 colKey = site.col != null ? `${site.col}` : `?:${site.name}`;
+		const key = `${site.url}:${site.line}:${colKey}`;
+		const existing = byLocation.get(key);
+		if (existing) {
+			existing.bytes += site.bytes;
+			addCaller(existing, site);
+		} else {
+			const callers = site.stack ? [{
+				stack: site.stack,
+				bytes: site.bytes
+			}] : void 0;
+			byLocation.set(key, {
+				...site,
+				callers
+			});
+		}
+	}
+	for (const site of byLocation.values()) {
+		if (!site.callers || site.callers.length <= 1) continue;
+		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);
+}
+/** Format heap report for console output */
+function formatHeapReport(sites, options) {
+	const { topN, stackDepth = 3, verbose = false } = options;
+	const { totalAll, totalUserCode, sampleCount, isUserCode } = options;
+	const isUser = isUserCode ?? isNodeUserCode;
+	const formatSite = verbose ? formatVerboseSite : formatCompactSite;
+	const lines = [];
+	lines.push(`Heap allocation sites (top ${topN}, garbage included):`);
+	for (const site of sites.slice(0, topN)) formatSite(lines, site, stackDepth, isUser);
+	lines.push("");
+	if (totalAll !== void 0) lines.push(`Total (all):       ${fmtBytes(totalAll)}`);
+	if (totalUserCode !== void 0) lines.push(`Total (user-code): ${fmtBytes(totalUserCode)}`);
+	if (sampleCount !== void 0) lines.push(`Samples: ${sampleCount.toLocaleString()}`);
+	return lines.join("\n");
+}
+/** Sum bytes across all sites */
+function totalBytes(sites) {
+	return sites.reduce((sum, s) => sum + s.bytes, 0);
+}
+/** Format every raw sample as one line, ordered by ordinal (time).
+*  Output is tab-separated for easy piping/grep/diff. */
+function formatRawSamples(resolved) {
+	const { sortedSamples, nodeMap } = resolved;
+	if (!sortedSamples || sortedSamples.length === 0) return "No raw samples available.";
+	return ["ordinal	size	function	location", ...sortedSamples.map((s) => {
+		const frame = nodeMap.get(s.nodeId)?.frame;
+		const fn = frame?.name || "(unknown)";
+		const url = frame?.url || "";
+		const loc = url ? fmtLoc(url, frame.line, frame.col) : "(unknown)";
+		return `${s.ordinal}\t${s.size}\t${fn}\t${loc}`;
+	})].join("\n");
+}
+/** Add a caller stack to an aggregated site, merging if the same path exists */
+function addCaller(existing, site) {
+	if (!site.stack) return;
+	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 loc = site.url ? fmtLoc(site.url, site.line, site.col) : "(unknown)";
+	const style = isUser(site) ? (s) => s : colors.dim;
+	lines.push(style(`${bytes}  ${site.name}  ${loc}`));
+	const userCallers = callerFrames(site, stackDepth).filter((f) => f.url && isUser(f));
+	for (const frame of userCallers) {
+		const loc = fmtLoc(frame.url, frame.line, frame.col);
+		lines.push(style(`            <- ${frame.name}  ${loc}`));
+	}
+}
+/** Compact single-line format: `49 MB  fn1 <- fn2 <- fn3` */
+function formatCompactSite(lines, site, stackDepth, isUser) {
+	const bytes = fmtBytes(site.bytes).padStart(10);
+	const callers = callerFrames(site, stackDepth).filter((f) => f.url && isUser(f)).map((f) => f.name);
+	const line = `${bytes}  ${[site.name, ...callers].join(" <- ")}`;
+	lines.push(isUser(site) ? line : colors.dim(line));
+}
+/** Format bytes with a space separator, falling back to raw bytes */
+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("|");
+}
+/** Get caller frames (parent stack excluding self, reversed, truncated) */
+function callerFrames(site, depth) {
+	if (!site.stack || site.stack.length <= 1) return [];
+	return site.stack.slice(0, -1).reverse().slice(0, depth);
+}
+//#endregion
+//#region src/report/GcSections.ts
+/** Report section: GC time as fraction of total benchmark time. */
+const gcSection = {
+	title: "gc",
+	columns: [{
+		key: "gc",
+		title: "mean",
+		formatter: percent,
+		comparable: true,
+		value: (r) => {
+			const { nodeGcTime, time, samples } = r;
+			if (!nodeGcTime || !time?.avg) return void 0;
+			const totalBenchTime = time.avg * samples.length;
+			if (totalBenchTime <= 0) return void 0;
+			const gcFraction = nodeGcTime.inRun / totalBenchTime;
+			return gcFraction <= 1 ? gcFraction : void 0;
+		}
+	}]
+};
+/** Report section: detailed GC stats from --trace-gc-nvp. */
+const gcStatsSection = {
+	title: "gc",
+	columns: [
+		{
+			key: "allocPerIter",
+			title: "alloc/iter",
+			formatter: formatBytes,
+			comparable: true,
+			value: (r) => {
+				const { gcStats, samples } = r;
+				if (!gcStats) return void 0;
+				const alloc = gcStats.totalAllocated;
+				return alloc != null ? alloc / (samples.length || 1) : void 0;
+			}
+		},
+		{
+			key: "collected",
+			title: "collected",
+			formatter: formatBytes,
+			comparable: true,
+			value: (r) => r.gcStats?.totalCollected || void 0
+		},
+		{
+			key: "scavenges",
+			title: "scav",
+			formatter: integer,
+			comparable: true,
+			value: (r) => r.gcStats?.scavenges
+		},
+		{
+			key: "fullGCs",
+			title: "full",
+			formatter: integer,
+			comparable: true,
+			value: (r) => r.gcStats?.markCompacts
+		},
+		{
+			key: "promoPercent",
+			title: "promo%",
+			formatter: percent,
+			comparable: true,
+			value: (r) => {
+				const gs = r.gcStats;
+				if (!gs) return void 0;
+				const alloc = gs.totalAllocated;
+				return alloc && alloc > 0 ? (gs.totalPromoted ?? 0) / alloc : void 0;
+			}
+		},
+		{
+			key: "pausePerIter",
+			title: "pause/iter",
+			formatter: timeMs,
+			comparable: true,
+			value: (r) => {
+				const gs = r.gcStats;
+				return gs ? gs.gcPauseTime / (r.samples.length || 1) : void 0;
+			}
+		}
+	]
+};
+/** Report section: browser GC stats from CDP tracing (subset of gcStatsSection). */
+const browserGcStatsSection = {
+	title: "gc",
+	columns: [
+		gcStatsSection.columns.find((c) => c.key === "collected"),
+		gcStatsSection.columns.find((c) => c.key === "scavenges"),
+		gcStatsSection.columns.find((c) => c.key === "fullGCs"),
+		{
+			key: "pausePerIter",
+			title: "pause",
+			formatter: timeMs,
+			comparable: true,
+			value: gcStatsSection.columns.find((c) => c.key === "pausePerIter").value
+		}
+	]
+};
+/** Report sections: page-load stats (mean/p50/p99) across multiple iterations. */
+const pageLoadStatsSections = [
+	pageLoadSection("DCL", (n) => n.domContentLoaded || void 0),
+	pageLoadSection("load", (n) => n.loadEvent || void 0),
+	pageLoadSection("LCP", (n) => n.lcp)
+];
+/** @return GC stats sections if enabled by CLI flags */
+function gcSections(args) {
+	return args["gc-stats"] ? [gcStatsSection] : [];
+}
+/** Build a page-load section with mean/p50/p99 columns from NavTiming data */
+function pageLoadSection(title, extract) {
+	const vals = (r) => navValues(r.navTimings, extract);
+	const col = (suffix, stat) => ({
+		key: `${title.toLowerCase()}${suffix}`,
+		title: suffix.toLowerCase(),
+		formatter: timeMs,
+		value: (r) => {
+			const v = vals(r);
+			return v.length ? stat(v) : void 0;
+		}
+	});
+	return {
+		title,
+		columns: [
+			col("Mean", average),
+			col("P50", median),
+			col("P99", (v) => percentile(v, .99))
+		]
+	};
+}
+/** Extract one field from all NavTimings, filtering undefineds. */
+function navValues(navs, fn) {
+	if (!navs?.length) return [];
+	return navs.map(fn).filter((v) => v != null);
+}
+//#endregion
+//#region src/report/ParseStats.ts
+/** Parse --stats into column specs. Throws on empty/invalid tokens. */
+function parseStatsArg(stats) {
+	const tokens = stats.split(",").map((t) => t.trim()).filter(Boolean);
+	if (tokens.length === 0) throw new Error("--stats must list at least one column");
+	const seen = /* @__PURE__ */ new Set();
+	const specs = [];
+	for (const token of tokens) {
+		const spec = parseStatToken(token);
+		if (seen.has(spec.key)) continue;
+		seen.add(spec.key);
+		specs.push(spec);
+	}
+	return specs;
+}
+/** @return stat spec for a single --stats token. Throws on invalid input. */
+function parseStatToken(token) {
+	const lower = token.toLowerCase();
+	if (lower === "mean" || lower === "avg") return {
+		key: "mean",
+		title: "mean",
+		statKind: "mean"
+	};
+	if (lower === "median") return {
+		key: "p50",
+		title: "p50",
+		statKind: { percentile: .5 }
+	};
+	if (lower === "min") return {
+		key: "min",
+		title: "min",
+		statKind: "min"
+	};
+	if (lower === "max") return {
+		key: "max",
+		title: "max",
+		statKind: "max"
+	};
+	const m = lower.match(/^p(\d+)$/);
+	if (m) return parsePercentileToken(token, m[1]);
+	throw new Error(`invalid --stats token "${token}": expected mean, median, min, max, or p<N> (e.g. p50, p99, p999)`);
+}
+/** @return spec for a p<N> token, enforcing the 2-digit minimum and 9-prefix rule. */
+function parsePercentileToken(token, digits) {
+	if (digits.length < 2) throw new Error(`invalid --stats token "${token}": percentile needs at least 2 digits (e.g. p05, p50, p99, p999)`);
+	if (digits.length > 2 && digits[0] !== "9") throw new Error(`invalid --stats token "${token}": percentiles with 3+ digits must start with 9 (e.g. p999, p9999); otherwise use 2-digit form (e.g. p50)`);
+	const q = Number(digits) / 10 ** digits.length;
+	return {
+		key: `p${digits}`,
+		title: `p${digits}`,
+		statKind: { percentile: q }
+	};
+}
+//#endregion
+//#region src/report/StandardSections.ts
+/** Default timing section: mean, p50, p99. */
+const timeSection = buildTimeSection();
+/** Report section: number of sample iterations. */
+const runsSection = {
+	title: "",
+	columns: [{
+		key: "runs",
+		title: "runs",
+		formatter: (v) => String(v),
+		value: (r) => r.samples.length
+	}]
+};
+/** Report section: total sampling duration. */
+const totalTimeSection = {
+	title: "",
+	columns: [{
+		key: "totalTime",
+		title: "time",
+		formatter: formatTotalTime,
+		value: (r) => r.totalTime
+	}]
+};
+/** Report sections: timing stats and convergence for adaptive mode. */
+const adaptiveSections = [{
+	title: "time",
+	columns: [
+		{
+			key: "median",
+			title: "median",
+			formatter: timeMs,
+			comparable: true,
+			statKind: { percentile: .5 }
+		},
+		{
+			key: "mean",
+			title: "mean",
+			formatter: timeMs,
+			comparable: true,
+			statKind: "mean"
+		},
+		{
+			key: "p99",
+			title: "p99",
+			formatter: timeMs,
+			statKind: { percentile: .99 }
+		}
+	]
+}, {
+	title: "",
+	columns: [{
+		key: "convergence",
+		title: "conv%",
+		formatter: formatConvergence,
+		value: (r) => r.convergence?.confidence
+	}]
+}];
+/** Report section: V8 optimization tier distribution and deopt count. */
+const optSection = {
+	title: "v8 opt",
+	columns: [{
+		key: "tiers",
+		title: "tiers",
+		formatter: (v) => typeof v === "string" ? v : "",
+		value: (r) => {
+			const opt = r.optStatus;
+			return opt ? formatTierSummary(opt) : void 0;
+		}
+	}, {
+		key: "deopt",
+		title: "deopt",
+		formatter: (v) => typeof v === "number" ? String(v) : "",
+		value: (r) => {
+			const opt = r.optStatus;
+			return opt && opt.deoptCount > 0 ? opt.deoptCount : void 0;
+		}
+	}]
+};
+/** Build a time section with user-chosen percentile/stat columns. */
+function buildTimeSection(stats = "mean,p50,p99") {
+	return {
+		title: "time",
+		columns: parseStatsArg(stats).map((s) => ({
+			key: s.key,
+			title: s.title,
+			formatter: timeMs,
+			comparable: isBootstrappable(s.statKind),
+			statKind: s.statKind
+		}))
+	};
+}
+/** Format V8 tier distribution sorted by count (e.g. "turbofan:85% sparkplug:15%"). */
+function formatTierSummary(opt, sep = ":", glue = " ") {
+	const tiers = Object.entries(opt.byTier);
+	const total = tiers.reduce((s, [, t]) => s + t.count, 0);
+	const pct = (n) => `${(n / total * 100).toFixed(0)}%`;
+	return tiers.sort((a, b) => b[1].count - a[1].count).map(([name, t]) => `${name}${sep}${pct(t.count)}`).join(glue);
+}
+/** @return default report sections from CLI flags (GC stats if enabled, plus run count). */
+function buildGenericSections(args) {
+	return [...gcSections(args), runsSection];
+}
+/** Format total time; brackets indicate >= 30s. */
+function formatTotalTime(v) {
+	if (typeof v !== "number") return "";
+	return v >= 30 ? `[${v.toFixed(1)}s]` : `${v.toFixed(1)}s`;
+}
+/** @return true if comparing with fewer than minBatches on either side */
+function hasLowBatchCount(baseline, current) {
+	if (!baseline) return false;
+	return batchCount(baseline) < 20 || batchCount(current) < 20;
+}
+/** @return true if either side has no real batch structure */
+function isSingleBatch(baseline, current) {
+	if (!baseline) return batchCount(current) < 2;
+	return batchCount(baseline) < 2 || batchCount(current) < 2;
+}
+/** Add label, mark unreliable, and override direction when batch count is low */
+function annotateCI(ci, title, lowBatches) {
+	if (!ci) return ci;
+	if (lowBatches) ci.direction = "uncertain";
+	ci.ciReliable = !lowBatches && ci.ciLevel !== "sample";
+	if (title) ci.label = `${title} Δ%`;
+	return ci;
+}
+/** Build ViewerSections from ReportSections, with bootstrap CIs for comparable columns */
+function buildViewerSections(sections, base) {
+	const { current, baseline, currentMeta, baselineMeta } = base;
+	return sections.flatMap((section) => {
+		const curVals = computeColumnValues(section, current, currentMeta);
+		const baseVals = baseline ? computeColumnValues(section, baseline, baselineMeta) : void 0;
+		const ctx = {
+			...base,
+			curVals,
+			baseVals
+		};
+		const rows = buildGroupRows(section.columns, ctx);
+		if (!rows.length) return [];
+		return [{
+			title: section.title,
+			rows
+		}];
+	});
+}
+function batchCount(m) {
+	return m?.batchOffsets?.length ?? 0;
+}
+/** Build ViewerRow[] for a column group, using shared resampling for statKind columns */
+function buildGroupRows(columns, ctx) {
+	const ciMap = buildCIMap(columns, ctx);
+	const rows = [];
+	for (const col of columns) {
+		const key = col.key ?? col.title;
+		const row = buildRow(col, key, ctx, ciMap.get(key));
+		if (row) rows.push(row);
+	}
+	const first = rows.find((r) => r.entries.some((e) => e.bootstrapCI));
+	if (first) first.primary = true;
+	return rows;
+}
+/** Compute batched bootstrap CIs, returning a Map keyed by column key */
+function buildCIMap(columns, ctx) {
+	const ciCols = columns.filter((c) => c.comparable && c.statKind && isBootstrappable(c.statKind));
+	const statKinds = ciCols.map((c) => c.statKind);
+	const map = /* @__PURE__ */ new Map();
+	if (statKinds.length === 0) return map;
+	const curSamples = ctx.current.samples;
+	const baseSamples = ctx.baseline?.samples;
+	const curResults = curSamples?.length > 1 ? bootstrapCIs(curSamples, ctx.current.batchOffsets, statKinds) : void 0;
+	const baseResults = baseSamples?.length && baseSamples.length > 1 ? bootstrapCIs(baseSamples, ctx.baseline.batchOffsets, statKinds) : void 0;
+	const diffResults = buildDiffResults(ciCols, statKinds, ctx);
+	for (let i = 0; i < ciCols.length; i++) {
+		const key = ciCols[i].key ?? ciCols[i].title;
+		map.set(key, {
+			cur: curResults?.[i],
+			base: baseResults?.[i],
+			diff: diffResults?.[i]
+		});
+	}
+	return map;
+}
+/** Build a ViewerRow for a column, using pre-computed CIs if available */
+function buildRow(col, key, ctx, cis) {
+	const curRaw = ctx.curVals[key];
+	const baseRaw = ctx.baseVals?.[key];
+	if (curRaw === void 0 && baseRaw === void 0) return void 0;
+	const format = (v) => {
+		if (v === void 0) return "";
+		return (col.formatter ? col.formatter(v) : String(v)) ?? "";
+	};
+	if (!col.comparable) {
+		const value = format(curRaw ?? baseRaw);
+		if (!value || value === "—") return void 0;
+		return {
+			label: col.title,
+			entries: [{
+				runName: ctx.current.name,
+				value
+			}],
+			shared: true
+		};
+	}
+	const entries = [buildEntry(ctx.current.name, format(curRaw), col, cis?.cur, ctx.current.batchOffsets, ctx.currentMeta)];
+	if (ctx.baseline && baseRaw !== void 0) {
+		const baseEntry = buildEntry("baseline", format(baseRaw), col, cis?.base, ctx.baseline.batchOffsets, ctx.baselineMeta);
+		entries.push(baseEntry);
+	}
+	return {
+		label: col.title,
+		entries,
+		comparisonCI: cis?.diff
+	};
+}
+/** Compute difference CIs with annotation and higher-is-better flip */
+function buildDiffResults(cols, stats, ctx) {
+	const { baseline, current, comparison } = ctx;
+	if (!baseline?.samples?.length || !current.samples?.length) return void 0;
+	const opts = {
+		equivMargin: comparison?.equivMargin,
+		noBatchTrim: comparison?.noBatchTrim
+	};
+	const rawCIs = diffCIs(baseline.samples, baseline.batchOffsets, current.samples, current.batchOffsets, stats, opts);
+	const lowBatches = hasLowBatchCount(baseline, current);
+	return rawCIs.map((ci, i) => {
+		if (!ci) return void 0;
+		const col = cols[i];
+		return annotateCI(col.higherIsBetter ? swapDirection(flipCI(ci)) : ci, col.title, lowBatches);
+	});
+}
+/** Build a ViewerEntry, attaching bootstrap CI data if available */
+function buildEntry(runName, value, col, result, batchOffsets, metadata) {
+	if (!result) return {
+		runName,
+		value
+	};
+	return {
+		runName,
+		value,
+		bootstrapCI: formatBootstrapCI(col, result, batchOffsets, metadata)
+	};
+}
+/** Format a BootstrapResult into display-domain BootstrapCIData */
+function formatBootstrapCI(col, result, batchOffsets, metadata) {
+	const toDisplay = col.toDisplay ? (v) => col.toDisplay(v, metadata) : (v) => v;
+	const formatValue = (v) => (col.formatter ? col.formatter(v) : String(v)) ?? String(v);
+	const binned = binBootstrapResult(result);
+	const dLo = toDisplay(binned.ci[0]);
+	const dHi = toDisplay(binned.ci[1]);
+	const ci = dLo <= dHi ? [dLo, dHi] : [dHi, dLo];
+	const histogram = binned.histogram.map((b) => ({
+		x: toDisplay(b.x),
+		count: b.count
+	}));
+	const ciLabels = [formatValue(ci[0]), formatValue(ci[1])];
+	const nBatches = batchOffsets?.length ?? 0;
+	const ciReliable = result.ciLevel === "block" && nBatches >= 20;
+	return {
+		estimate: toDisplay(binned.estimate),
+		ci,
+		histogram,
+		ciLabels,
+		ciLevel: result.ciLevel,
+		ciReliable
+	};
+}
+//#endregion
+//#region src/report/HtmlReport.ts
+/** Convert benchmark results into a ReportData payload for the HTML viewer */
+function prepareHtmlData(groups, options) {
+	const { cliArgs, currentVersion, baselineVersion, equivMargin, noBatchTrim } = options;
+	const comparison = {
+		equivMargin,
+		noBatchTrim
+	};
+	const sections = options.sections ?? defaultSections$1(groups, cliArgs);
+	return {
+		groups: groups.map((g) => prepareGroupData(g, sections, comparison)),
+		metadata: {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			bencherVersion: process.env.npm_package_version || "unknown",
+			cliArgs,
+			cliDefaults,
+			gcTrackingEnabled: cliArgs?.["gc-stats"] === true,
+			currentVersion,
+			baselineVersion,
+			environment: {
+				node: process.version,
+				platform: process.platform,
+				arch: process.arch
+			}
+		}
+	};
+}
+/** Build default sections when caller doesn't provide custom ones */
+function defaultSections$1(groups, cliArgs) {
+	const hasGc = cliArgs?.["gc-stats"] === true;
+	const hasOpt = hasField(groups, "optStatus");
+	return [
+		buildTimeSection(typeof cliArgs?.stats === "string" ? cliArgs.stats : void 0),
+		hasGc ? gcStatsSection : void 0,
+		hasOpt ? optSection : void 0,
+		runsSection
+	].filter((s) => s !== void 0);
+}
+/** @return group data with structured ViewerSections and bootstrap CIs */
+function prepareGroupData(group, sections, comparison) {
+	const base = group.baseline;
+	const baseM = base?.measuredResults;
+	const baseline = base ? {
+		...prepareBenchmarkData(base),
+		comparisonCI: void 0
+	} : void 0;
+	const curM = group.reports[0]?.measuredResults;
+	const singleBatch = isSingleBatch(baseM, curM);
+	const lowBatches = hasLowBatchCount(baseM, curM);
+	const ctx = {
+		baseM,
+		baseMeta: base?.metadata,
+		sections,
+		comparison,
+		lowBatches
+	};
+	return {
+		name: group.name,
+		baseline,
+		warnings: buildWarnings(singleBatch, lowBatches),
+		benchmarks: group.reports.map((r) => prepareReportEntry(r, ctx))
+	};
+}
+/** @return benchmark data with samples, stats, and profiling summaries */
+function prepareBenchmarkData(report) {
+	const { measuredResults: m, name } = report;
+	return {
+		name,
+		samples: m.samples,
+		warmupSamples: m.warmupSamples,
+		allocationSamples: m.allocationSamples,
+		heapSamples: m.heapSamples,
+		gcEvents: m.nodeGcTime?.events,
+		optSamples: m.optSamples,
+		pausePoints: m.pausePoints,
+		batchOffsets: m.batchOffsets,
+		stats: m.time,
+		heapSize: m.heapSize,
+		totalTime: m.totalTime,
+		heapSummary: m.heapProfile ? summarizeHeap(m.heapProfile) : void 0,
+		coverageSummary: m.coverage ? summarizeCoverage(m.coverage) : void 0
+	};
+}
+function buildWarnings(singleBatch, lowBatches) {
+	const parts = [];
+	const singleMsg = "Confidence intervals may be too narrow (single batch). Use --batches for more accurate intervals.";
+	if (singleBatch) parts.push(singleMsg);
+	if (lowBatches) parts.push(`Too few batches for reliable comparison (need 20+).`);
+	return parts.length ? parts : void 0;
+}
+/** @return a single benchmark entry with sections and comparison CI */
+function prepareReportEntry(report, ctx) {
+	const sectionCtx = {
+		current: report.measuredResults,
+		baseline: ctx.baseM,
+		currentMeta: report.metadata,
+		baselineMeta: ctx.baseMeta,
+		comparison: ctx.comparison
+	};
+	const sections = ctx.sections ? buildViewerSections(ctx.sections, sectionCtx) : void 0;
+	const comparisonCI = findPrimarySectionCI(sections);
+	return {
+		...prepareBenchmarkData(report),
+		sections,
+		comparisonCI
+	};
+}
+/** Compute heap allocation summary from profile */
+function summarizeHeap(profile) {
+	const resolved = resolveProfile(profile);
+	const userSites = filterSites(flattenProfile(resolved));
+	return {
+		totalBytes: resolved.totalBytes,
+		userBytes: totalBytes(userSites)
+	};
+}
+/** Compute coverage summary from V8 coverage data */
+function summarizeCoverage(coverage) {
+	const called = coverage.scripts.flatMap((s) => s.functions).filter((fn) => fn.ranges.length > 0 && fn.ranges[0].count > 0);
+	const totalCalls = called.reduce((sum, fn) => sum + fn.ranges[0].count, 0);
+	return {
+		functionCount: called.length,
+		totalCalls
+	};
+}
+/** Extract the comparison CI from the first primary row across all sections */
+function findPrimarySectionCI(sections) {
+	if (!sections) return void 0;
+	for (const section of sections) for (const row of section.rows) if (row.primary && row.comparisonCI) return row.comparisonCI;
+}
+//#endregion
+//#region src/cli/CliOptions.ts
+/** Convert CLI args to matrix runner options. */
+function cliToMatrixOptions(args) {
+	const { iterations, worker, batches } = args;
+	const { maxTime } = resolveLimits(args);
+	return {
+		iterations,
+		maxTime,
+		useWorker: worker,
+		batches,
+		warmupBatch: args["warmup-batch"],
+		...cliCommonOptions(args)
+	};
+}
+/** 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.");
+	if (args.stats) buildTimeSection(args.stats);
+}
+/** Convert CLI args to benchmark runner options. */
+function cliToRunnerOptions(args) {
+	const { inspect, iterations, adaptive } = args;
+	const gcForce = args["gc-force"];
+	if (inspect) return {
+		maxIterations: iterations ?? 1,
+		warmupTime: 0,
+		gcForce
+	};
+	if (adaptive) return createAdaptiveOptions(args);
+	return {
+		...resolveLimits(args),
+		...cliCommonOptions(args)
+	};
+}
+/** Convert CLI args to heap report display options. */
+function cliHeapReportOptions(args) {
+	return {
+		topN: args["alloc-rows"],
+		stackDepth: args["alloc-stack"],
+		verbose: args["alloc-verbose"],
+		raw: args["alloc-raw"],
+		userOnly: args["alloc-user-only"]
+	};
+}
+/** True if any alloc-related flag implies allocation sampling. */
+function needsAlloc(args) {
+	return args.alloc || args.archive != null || args["alloc-raw"] || args["alloc-verbose"] || args["alloc-user-only"];
+}
+/** True if any profiling flag implies CPU time sampling. */
+function needsProfile(args) {
+	return args.profile || !!args["export-profile"];
+}
+/** Extract baseline comparison options from CLI args. */
+function cliComparisonOptions(args) {
+	return {
+		equivMargin: args["equiv-margin"],
+		noBatchTrim: args["no-batch-trim"]
+	};
+}
+function resolveLimits(args) {
+	const { duration, iterations } = args;
+	if (duration == null && iterations == null) return {
+		maxTime: defaultDuration * 1e3,
+		maxIterations: void 0
+	};
+	return {
+		maxTime: duration != null ? duration * 1e3 : void 0,
+		maxIterations: iterations
+	};
+}
+/** Runner/matrix options shared across all CLI modes. */
+function cliCommonOptions(args) {
+	const { warmup } = args;
+	const { "gc-force": gcForce, "gc-stats": gcStats } = args;
+	const { "trace-opt": traceOpt, "call-counts": callCounts } = args;
+	const { "pause-warmup": pauseWarmup, "pause-first": pauseFirst } = args;
+	const { "pause-interval": pauseInterval, "pause-duration": pauseDuration } = args;
+	const { "alloc-interval": allocInterval, "alloc-depth": allocDepth } = args;
+	const { "profile-interval": profileInterval } = args;
+	return {
+		gcForce,
+		warmup,
+		traceOpt,
+		gcStats,
+		callCounts,
+		pauseWarmup,
+		pauseFirst,
+		pauseInterval,
+		pauseDuration,
+		alloc: needsAlloc(args),
+		allocInterval,
+		allocDepth,
+		profile: needsProfile(args),
+		profileInterval
+	};
+}
+/** Build runner options for adaptive sampling mode. */
+function createAdaptiveOptions(args) {
+	return {
+		minTime: (args["min-time"] ?? 1) * 1e3,
+		maxTime: 20 * 1e3,
+		targetConfidence: args.convergence,
+		adaptive: true,
+		...cliCommonOptions(args)
+	};
+}
+//#endregion
+//#region src/report/text/TableReport.ts
+const { bold } = colors;
+const ansiEscapeRegex = new RegExp(String.fromCharCode(27) + "\\[[0-9;]*m", "g");
+/** Build formatted table with column groups and baseline diffs. */
+function buildTable(columnGroups, resultGroups, nameKey = "name") {
+	return createTable(columnGroups, flattenGroups(columnGroups, resultGroups, nameKey));
+}
+/** Convert records to string arrays for table rendering. */
+function toRows(records, groups) {
+	const allColumns = groups.flatMap((group) => group.columns);
+	return records.map((record) => allColumns.map((col) => {
+		const value = record[col.key];
+		return col.formatter ? col.formatter(value) : value;
+	})).map((row) => row.map((cell) => cell ?? " "));
+}
+/** Flatten result groups into a single array, inserting blank separator rows. */
+function flattenGroups(groups, resultGroups, nameKey) {
+	return resultGroups.flatMap((group, i) => {
+		const records = addBaseline(groups, group, nameKey);
+		return i === resultGroups.length - 1 ? records : [...records, {}];
+	});
+}
+/** Render column groups and records into a formatted table string. */
+function createTable(groups, records) {
+	const dataRows = toRows(records, groups);
+	const { headerRows, config } = buildTableConfig(groups, dataRows);
+	return table([...headerRows, ...dataRows], config);
+}
+/** Append baseline row and inject diff values into result rows. */
+function addBaseline(groups, group, nameKey) {
+	const { results, baseline } = group;
+	if (!baseline) return results;
+	const diffResults = results.map((r) => addComparisons(groups, r, baseline));
+	const marked = {
+		...baseline,
+		[nameKey]: `--> ${baseline[nameKey]}`
+	};
+	return [...diffResults, marked];
+}
+/** Build header rows, spanning cells, column widths, and border rules. */
+function buildTableConfig(groups, dataRows) {
+	const titles = getTitles(groups);
+	return {
+		headerRows: [...createGroupHeaders(groups, titles.length), titles],
+		config: {
+			spanningCells: createSectionSpans(groups),
+			columns: calcColumnWidths(groups, titles, dataRows),
+			...createLines(groups)
+		}
+	};
+}
+/** Compute formatted diff values by comparing a row against baseline. */
+function addComparisons(groups, main, baseline) {
+	const cols = groups.flatMap((g) => g.columns).filter((col) => col.diffKey !== void 0);
+	const diffs = Object.fromEntries(cols.map((col) => {
+		const fmt = col.diffFormatter ?? diffPercent;
+		return [col.key, fmt(main[col.diffKey], baseline[col.diffKey])];
+	}));
+	return {
+		...main,
+		...diffs
+	};
+}
+/** @return bolded column title strings */
+function getTitles(groups) {
+	return groups.flatMap((g) => g.columns.map((c) => bold(c.title || " ")));
+}
+/** @return header rows with group titles, or empty if no groups have 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) {
+	const offsets = groupOffsets(groups);
+	return groups.map((g, i) => ({
+		row: 0,
+		col: offsets[i],
+		colSpan: g.columns.length,
+		alignment: "center"
+	}));
+}
+/** Calculate column widths based on content, widening to fit group titles. */
+function calcColumnWidths(groups, titles, dataRows) {
+	const maxData = (i) => dataRows.reduce((m, row) => Math.max(m, cellWidth(row[i])), 0);
+	const widths = titles.map((t, i) => Math.max(cellWidth(t), maxData(i)));
+	const offsets = groupOffsets(groups);
+	for (const [i, group] of groups.entries()) {
+		const titleWidth = cellWidth(group.groupTitle);
+		if (titleWidth <= 0) continue;
+		const col = offsets[i];
+		const n = group.columns.length;
+		const sepWidth = (n - 1) * 3;
+		const needed = titleWidth - widths.slice(col, col + n).reduce((a, b) => a + b, 0) - sepWidth;
+		if (needed > 0) widths[col + n - 1] += needed;
+	}
+	return Object.fromEntries(widths.map((w, i) => [i, {
+		width: w,
+		wrapWord: false
+	}]));
+}
+/** @return draw functions for horizontal/vertical table borders */
+function createLines(groups) {
+	const { sectionBorders, headerBottom } = calcBorders(groups);
+	return {
+		drawVerticalLine: (i, size) => i === 0 || i === size || sectionBorders.includes(i),
+		drawHorizontalLine: (i, size) => i === 0 || i === size || i === headerBottom
+	};
+}
+/** @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(" ")];
+}
+/** @return cumulative column offsets for each group boundary */
+function groupOffsets(groups) {
+	let offset = 0;
+	return groups.map((g) => {
+		const start = offset;
+		offset += g.columns.length;
+		return start;
+	});
+}
+/** @return visible length of a cell value, stripping ANSI escape codes. */
+function cellWidth(value) {
+	if (value == null) return 0;
+	return String(value).replace(ansiEscapeRegex, "").length;
+}
+/** @return vertical line positions between sections and header bottom row. */
+function calcBorders(groups) {
+	return {
+		sectionBorders: groupOffsets(groups).map((o, i) => o + groups[i].columns.length),
+		headerBottom: groups.length === 0 ? 1 : 3
+	};
+}
+//#endregion
+//#region src/report/text/TextReport.ts
+/** Build a formatted text table from benchmark groups, with baseline diff columns when present. */
+function reportResults(groups, sections, options) {
+	const primary = findPrimaryColumn(sections);
+	const results = groups.map((g) => resultGroupValues(g, sections, primary, options));
+	const table = buildTable(sectionColumnGroups(sections, results.some((g) => g.baseline)), results);
+	if (!results.some((g) => g.results.some((r) => r.diffCI && r.diffCI.ciLevel === "sample"))) return table;
+	return table + "\n* Confidence intervals may be too narrow (single batch). Use --batches for more accurate intervals.\n";
+}
+/** Extract stats from all sections into row objects for each report. */
+function valuesForReports(reports, sections) {
+	return reports.map((r) => ({
+		name: truncate(r.name),
+		...extractSectionValues(r.measuredResults, sections, r.metadata)
+	}));
+}
+/** Insert a "delta% CI" column after the first comparable column. */
+function injectDiffColumns(groups) {
+	const higher = isHigherIsBetter(groups.map((g) => ({
+		title: g.groupTitle ?? "",
+		columns: g.columns
+	})));
+	const fmt = (v) => formatDiffWithCI(v, higher);
+	const ciCol = {
+		title: "Δ% CI",
+		key: "diffCI",
+		formatter: fmt
+	};
+	let ciAdded = false;
+	return groups.map((group) => ({
+		groupTitle: group.groupTitle,
+		columns: group.columns.flatMap((col) => {
+			if (col.comparable && !ciAdded) {
+				ciAdded = true;
+				return [col, ciCol];
+			}
+			return [col];
+		})
+	}));
+}
+/** Build table columns from sections, with name column and optional CI diff columns. */
+function sectionColumnGroups(sections, hasBaseline, nameTitle = "name") {
+	const nameCol = { columns: [{
+		key: "name",
+		title: nameTitle
+	}] };
+	const groups = sections.map((s) => ({
+		groupTitle: s.title || void 0,
+		columns: s.columns.map((c) => ({
+			...c,
+			key: c.key ?? c.title
+		}))
+	}));
+	return [nameCol, ...hasBaseline ? injectDiffColumns(groups) : groups];
+}
+/** Extract section stats and bootstrap CI diffs for all reports in a group. */
+function resultGroupValues(group, sections, primary, options) {
+	const { reports, baseline } = group;
+	const baseM = baseline?.measuredResults;
+	const { statKind, higherIsBetter } = primary ?? {};
+	return {
+		results: reports.map((r) => {
+			const { measuredResults: m, metadata } = r;
+			const diffCI = statKind ? computeDiffCI(baseM, m, statKind, options, higherIsBetter) : void 0;
+			const values = extractSectionValues(m, sections, metadata);
+			return {
+				name: truncate(r.name),
+				...values,
+				...diffCI && { diffCI }
+			};
+		}),
+		baseline: baseline && valuesForReports([baseline], sections)[0]
+	};
+}
+//#endregion
+//#region src/matrix/MatrixReport.ts
+const defaultSections = [timeSection, runsSection];
+/** Format matrix results as text, with one table per case */
+function reportMatrixResults(results, options) {
+	if (results.variants.length === 0) return `Matrix: ${results.name}`;
+	const tables = results.variants[0].cases.map((c) => c.caseId).map((caseId) => buildCaseTable(results, caseId, options));
+	return [`Matrix: ${results.name}`, ...tables].join("\n\n");
+}
+/** Build table for a single case showing all variants */
+function buildCaseTable(results, caseId, options) {
+	const title = formatCaseTitle(results, caseId);
+	const sections = options?.sections ?? defaultSections;
+	const variantTitle = options?.variantTitle ?? "variant";
+	const primaryCol = findPrimaryColumn(sections);
+	const caseResults = collectCaseResults(results, caseId);
+	const shared = sharedBaseline(caseResults);
+	const rows = caseResults.flatMap(({ variant, cr }) => {
+		const vals = extractSectionValues(cr.measured, sections, cr.metadata);
+		const row = {
+			name: truncate(variant.id, 25),
+			...vals
+		};
+		if (cr.baseline && primaryCol?.statKind) {
+			const { statKind, higherIsBetter } = primaryCol;
+			row.diffCI = computeDiffCI(cr.baseline, cr.measured, statKind, options?.comparison, higherIsBetter);
+		}
+		const out = [row];
+		if (cr.baseline && !shared) out.push({
+			name: " ↳ baseline",
+			...extractSectionValues(cr.baseline, sections, cr.metadata)
+		});
+		return out;
+	});
+	if (shared) rows.push({
+		name: "=> baseline",
+		...extractSectionValues(shared, sections)
+	});
+	return `${title}\n${buildTable(sectionColumnGroups(sections, rows.some((r) => r.diffCI), variantTitle), [{ 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;
+	return `${caseId} (${Object.entries(metadata).map(([k, v]) => `${v} ${k}`).join(", ")})`;
+}
+/** Collect (variant, caseResult) pairs for a given caseId */
+function collectCaseResults(results, caseId) {
+	return results.variants.flatMap((variant) => {
+		const cr = variant.cases.find((c) => c.caseId === caseId);
+		return cr ? [{
+			variant,
+			cr
+		}] : [];
+	});
+}
+/** @return shared baseline if all variants reference the same one (baselineVariant mode) */
+function sharedBaseline(caseResults) {
+	const baselines = caseResults.map(({ cr }) => cr.baseline).filter(Boolean);
+	if (baselines.length < 2) return void 0;
+	return baselines.every((b) => b === baselines[0]) ? baselines[0] : void 0;
+}
+//#endregion
+//#region src/cli/CliReport.ts
+const { yellow: yellow$1, dim } = colors;
+/** Show a transient status message on stderr, run a sync computation, then clear. */
+function withStatus(msg, fn) {
+	process.stderr.write(`◊ ${msg}...\r`);
+	const result = fn();
+	process.stderr.write("\r" + " ".repeat(40) + "\r");
+	return result;
+}
+/** Generate text report table with standard sections based on CLI args. */
+function defaultReport(groups, args, opts) {
+	return reportResults(groups, opts?.sections?.length ? opts.sections : cliDefaultSections(groups, args), cliComparisonOptions(args));
+}
+/** Log V8 optimization tier distribution and deoptimizations. */
+function reportOptStatus(groups) {
+	const optData = groups.flatMap((group) => groupReports(group).filter((r) => r.measuredResults.optStatus).map(({ name, measuredResults: m }) => ({
+		name,
+		opt: m.optStatus,
+		samples: m.samples.length
+	})));
+	if (optData.length === 0) return;
+	console.log(dim("\nV8 optimization:"));
+	for (const { name, opt, samples } of optData) {
+		const tierParts = formatTierSummary(opt, " ", ", ");
+		console.log(`  ${name}: ${tierParts} ${dim(`(${samples} samples)`)}`);
+	}
+	const totalDeopts = optData.reduce((sum, d) => sum + d.opt.deoptCount, 0);
+	if (totalDeopts > 0) console.log(yellow$1(`  ⚠ ${totalDeopts} deoptimization${totalDeopts > 1 ? "s" : ""} detected`));
+}
+/** Print heap allocation profiles for each benchmark in the report groups. */
+function printHeapReports(groups, options) {
+	for (const report of groups.flatMap((g) => groupReports(g))) {
+		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 agg = aggregateSites(options.userOnly ? userSites : sites);
+		const { totalBytes, sortedSamples } = resolved;
+		const totalUserCode = userSites.reduce((sum, s) => sum + s.bytes, 0);
+		const sampleCount = sortedSamples?.length;
+		const heapOpts = {
+			...options,
+			totalAll: totalBytes,
+			totalUserCode,
+			sampleCount
+		};
+		console.log(formatHeapReport(agg, heapOpts));
+		if (options.raw) {
+			console.log(dim(`\n─── Raw samples: ${report.name} ───`));
+			console.log(formatRawSamples(resolved));
+		}
+	}
+}
+/** Format matrix benchmark results as text, applying default sections from CLI args. */
+function defaultMatrixReport(results, reportOptions, args) {
+	const options = args ? mergeMatrixDefaults(reportOptions, args, results) : reportOptions;
+	return results.map((r) => reportMatrixResults(r, options)).join("\n\n");
+}
+/** Convert MatrixResults to ReportGroup[] for the standard export pipeline. */
+function matrixToReportGroups(results) {
+	return results.flatMap((matrix) => matrix.variants.flatMap((variant) => variant.cases.map((c) => caseToReportGroup(variant.id, c))));
+}
+/** Assemble report sections from CLI flags. Under --adaptive, the
+*  adaptive section provides its own time columns and `stats` is ignored. */
+function buildReportSections(adaptive, gcStats, hasOptData, stats) {
+	return [
+		...adaptive ? [...adaptiveSections, totalTimeSection] : [buildTimeSection(stats)],
+		...gcStats ? [gcStatsSection] : [],
+		...hasOptData ? [optSection] : [],
+		runsSection
+	];
+}
+/** Build sections from CLI feature flags (time/gc/opt/runs). */
+function cliDefaultSections(groups, args) {
+	const { adaptive, "gc-stats": gcStats, "trace-opt": traceOpt, stats } = args;
+	const hasOpt = hasField(groups, "optStatus");
+	return buildReportSections(adaptive, gcStats, traceOpt && hasOpt, stats);
+}
+/** Apply default sections and extra columns for matrix reports. */
+function mergeMatrixDefaults(opts, args, results) {
+	const merged = { ...opts };
+	if (!merged.sections?.length) {
+		const groups = matrixToReportGroups(results);
+		const hasOpt = args["trace-opt"] && hasField(groups, "optStatus");
+		merged.sections = buildReportSections(args.adaptive, args["gc-stats"], hasOpt, args.stats);
+	}
+	if (!merged.comparison) merged.comparison = cliComparisonOptions(args);
+	return merged;
+}
+/** Wrap a single matrix case and its optional baseline into a ReportGroup. */
+function caseToReportGroup(variantId, c) {
+	const { metadata, baseline: baselineMeasured } = c;
+	const report = {
+		name: variantId,
+		measuredResults: c.measured,
+		metadata
+	};
+	const baseline = baselineMeasured ? {
+		name: `${variantId} (baseline)`,
+		measuredResults: baselineMeasured,
+		metadata
+	} : void 0;
+	return {
+		name: `${variantId} / ${c.caseId}`,
+		reports: [report],
+		baseline
+	};
+}
+//#endregion
+//#region src/cli/CliExport.ts
+/** Export reports (JSON, Perfetto, archive, viewer) based on CLI args. */
+async function exportReports(options) {
+	const { results, args, sections, currentVersion, baselineVersion } = options;
+	const wantViewer = args.view || args["view-serve"] || args.archive != null;
+	const htmlOpts = {
+		cliArgs: args,
+		sections,
+		currentVersion,
+		baselineVersion,
+		...cliComparisonOptions(args)
+	};
+	const reportData = wantViewer ? withStatus("computing viewer data", () => prepareHtmlData(results, htmlOpts)) : void 0;
+	exportFileFormats(results, args);
+	const profileFile = buildSpeedscopeFile(results);
+	const timeFile = buildAllTimeProfiles(results);
+	const coverageData = await annotateCoverage(results, profileFile, timeFile);
+	const timeData = timeFile ? JSON.stringify(timeFile) : void 0;
+	if (args.archive != null) await archiveBenchmark({
+		groups: results,
+		reportData,
+		timeProfileData: timeData,
+		coverageData,
+		outputPath: args.archive || void 0
+	});
+	if (args.view || args["view-serve"]) await openViewer(profileFile, timeData, coverageData, reportData, args);
+}
+/** Print heap reports (if enabled) and export results. */
+async function finishReports(results, args, exportOptions) {
+	if (needsAlloc(args)) printHeapReports(results, cliHeapReportOptions(args));
+	await exportReports({
+		results,
+		args,
+		...exportOptions
+	});
+}
+/** Write Perfetto and time profile files if requested by CLI args. */
+function exportFileFormats(results, args) {
+	if (args["export-perfetto"]) exportPerfettoTrace(results, args["export-perfetto"], args);
+	if (args["export-profile"]) exportTimeProfile(results, args["export-profile"]);
+}
+/** Build combined Speedscope file from all time profiles in results. */
+function buildAllTimeProfiles(results) {
+	return buildTimeSpeedscopeFile(results.flatMap((group) => groupReports(group).filter((r) => r.measuredResults.timeProfile).map((r) => ({
+		name: r.name,
+		profile: r.measuredResults.timeProfile
+	}))));
+}
+/** Annotate speedscope frame names with coverage counts. Returns serialized coverage map. */
+async function annotateCoverage(results, profileFile, timeFile) {
+	const coverage = mergeCoverage(results);
+	if (!coverage) return void 0;
+	const covMap = buildCoverageMap(coverage, await collectSources(coverage.scripts.map((s) => ({ file: s.url }))));
+	if (profileFile) annotateFramesWithCounts(profileFile.shared.frames, covMap);
+	if (timeFile) annotateFramesWithCounts(timeFile.shared.frames, covMap);
+	return JSON.stringify(Object.fromEntries(covMap.map));
+}
+/** Start viewer server with profile data and block until Ctrl+C. */
+async function openViewer(profileFile, timeData, coverageData, reportData, args) {
+	const viewer = await startViewerServer({
+		profileData: optionalJson(profileFile),
+		timeProfileData: timeData,
+		coverageData,
+		reportData: optionalJson(reportData),
+		editorUri: resolveEditorUri(args.editor),
+		open: !args["view-serve"]
+	});
+	await waitForCtrlC();
+	viewer.close();
+}
+/** Export the first raw V8 TimeProfile to a JSON file. */
+function exportTimeProfile(results, path) {
+	const profile = results.flatMap((g) => groupReports(g)).find((r) => r.measuredResults.timeProfile)?.measuredResults.timeProfile;
+	if (!profile) return void console.log("No time profiles to export.");
+	writeFileSync(resolve(path), JSON.stringify(profile));
+	console.log(`Time profile exported to: ${path}`);
+}
+/** Merge coverage data from all results into a single CoverageData. */
+function mergeCoverage(results) {
+	const scripts = results.flatMap((group) => groupReports(group).flatMap((r) => r.measuredResults.coverage?.scripts ?? []));
+	return scripts.length > 0 ? { scripts } : void 0;
+}
+//#endregion
+//#region src/matrix/MatrixFilter.ts
+/** Parse filter string: "case/variant", "case/", "/variant", or "case" */
+function parseMatrixFilter(filter) {
+	if (filter.includes("/")) {
+		const [casePart, varPart] = filter.split("/", 2);
+		return {
+			case: casePart || void 0,
+			variant: varPart || void 0
+		};
+	}
+	return { case: filter };
+}
+/** Apply filter to a matrix, merging with existing filters via intersection */
+async function filterMatrix(matrix, filter) {
+	if (!filter || !filter.case && !filter.variant) return matrix;
+	const caseList = await getFilteredCases(matrix, filter.case);
+	const variantList = await getFilteredVariants(matrix, filter.variant);
+	const filteredCases = intersectFilters(caseList, matrix.filteredCases);
+	const filteredVariants = intersectFilters(variantList, matrix.filteredVariants);
+	return {
+		...matrix,
+		filteredCases,
+		filteredVariants
+	};
+}
+/** Collect all case IDs from either casesModule or inline cases */
+async function resolveCaseIds(matrix) {
+	if (matrix.casesModule) return (await loadCasesModule(matrix.casesModule)).cases;
+	return matrix.cases;
+}
+/** Collect all variant IDs from either inline variants or variantDir */
+async function resolveVariantIds(matrix) {
+	if (matrix.variants) return Object.keys(matrix.variants);
+	if (matrix.variantDir) return discoverVariants(matrix.variantDir);
+	throw new Error("BenchMatrix requires 'variants' or 'variantDir'");
+}
+/** Return case IDs matching a substring pattern, or all if no pattern */
+async function getFilteredCases(matrix, casePattern) {
+	if (!casePattern) return void 0;
+	const caseIds = await resolveCaseIds(matrix);
+	if (!caseIds) return ["default"];
+	return filterByPattern(caseIds, casePattern, "cases");
+}
+/** Return variant IDs matching a substring pattern, or all if no pattern */
+async function getFilteredVariants(matrix, variantPattern) {
+	if (!variantPattern) return void 0;
+	return filterByPattern(await resolveVariantIds(matrix), variantPattern, "variants");
+}
+/** Intersect two optional filter lists: both present ==> intersection, otherwise the one that exists */
+function intersectFilters(a, b) {
+	if (a && b) return a.filter((v) => b.includes(v));
+	return a ?? b;
+}
+/** Filter IDs by substring pattern, throwing if no matches */
+function filterByPattern(ids, pattern, label) {
+	const filtered = ids.filter((id) => matchPattern(id, pattern));
+	if (filtered.length === 0) throw new Error(`No ${label} match filter: "${pattern}"`);
+	return filtered;
+}
+/** Case-insensitive substring match */
+function matchPattern(id, pattern) {
+	return id.toLowerCase().includes(pattern.toLowerCase());
+}
+//#endregion
+//#region src/profiling/browser/BrowserGcStats.ts
+/** Convert MinorGC/MajorGC trace events into GcEvent[]. */
+function parseGcTraceEvents(traceEvents) {
+	return traceEvents.filter((e) => e.ph === "X" && gcType(e.name)).map((e) => ({
+		type: gcType(e.name),
+		pauseMs: (e.dur ?? 0) / 1e3,
+		collected: Math.max(0, Number(e.args?.usedHeapSizeBefore ?? 0) - Number(e.args?.usedHeapSizeAfter ?? 0))
+	}));
+}
+/** Parse and aggregate CDP trace events into GcStats. */
+function browserGcStats(traceEvents) {
+	return aggregateGcStats(parseGcTraceEvents(traceEvents));
+}
+/** Map CDP event names (MinorGC/MajorGC) to GcEvent type. */
+function gcType(name) {
+	if (name === "MinorGC") return "scavenge";
+	if (name === "MajorGC") return "mark-compact";
+}
+//#endregion
+//#region src/profiling/browser/BrowserCDP.ts
+/** Build InstrumentOpts from profile params and heap sampling interval. */
+function instrumentOpts(params, samplingInterval) {
+	const { alloc = false, profile = false, callCounts = false, profileInterval } = params;
+	return {
+		alloc,
+		profile,
+		callCounts,
+		samplingInterval,
+		profileInterval
+	};
+}
+/** Start CDP GC tracing; returns the mutable array that collects trace events. */
+async function startGcTracing(cdp) {
+	const events = [];
+	cdp.on("Tracing.dataCollected", ({ value }) => {
+		events.push(...value);
+	});
+	await cdp.send("Tracing.start", { traceConfig: { includedCategories: ["v8", "v8.gc"] } });
+	return events;
+}
+/** End CDP tracing and aggregate collected events into GcStats. */
+async function collectTracing(cdp, traceEvents) {
+	const done = new Promise((r) => cdp.once("Tracing.tracingComplete", () => r()));
+	await cdp.send("Tracing.end");
+	await done;
+	return browserGcStats(traceEvents);
+}
+/** Start CDP Profiler for CPU time sampling (caller manages Profiler.enable/disable) */
+async function startTimeProfiling(cdp, interval) {
+	if (interval) await cdp.send("Profiler.setSamplingInterval", { interval });
+	await cdp.send("Profiler.start");
+}
+/** Stop CDP CPU sampling and return the profile. */
+async function stopTimeProfiling(cdp) {
+	const { profile } = await cdp.send("Profiler.stop");
+	return profile;
+}
+/** Start precise coverage (caller manages Profiler.enable/disable). */
+async function startCoverageCollection(cdp) {
+	await cdp.send("Profiler.startPreciseCoverage", {
+		callCount: true,
+		detailed: true
+	});
+}
+/** Collect precise coverage, filtering out browser-internal scripts. */
+async function collectCoverage(cdp) {
+	const { result } = await cdp.send("Profiler.takePreciseCoverage");
+	await cdp.send("Profiler.stopPreciseCoverage");
+	return { scripts: result.filter(isPageScript) };
+}
+/** Stop active instruments and return collected profiles/coverage. */
+async function stopInstruments(cdp, opts) {
+	const heapProfile = opts.alloc ? (await cdp.send("HeapProfiler.stopSampling")).profile : void 0;
+	const timeProfile = opts.profile ? await stopTimeProfiling(cdp) : void 0;
+	const coverage = opts.callCounts ? await collectCoverage(cdp) : void 0;
+	if (opts.profile || opts.callCounts) await cdp.send("Profiler.disable");
+	return {
+		heapProfile,
+		timeProfile,
+		coverage
+	};
+}
+/** Start requested CDP instruments (heap, CPU, coverage). */
+async function startInstruments(cdp, opts) {
+	if (opts.alloc) await cdp.send("HeapProfiler.startSampling", {
+		samplingInterval: opts.samplingInterval,
+		includeObjectsCollectedByMajorGC: true,
+		includeObjectsCollectedByMinorGC: true
+	});
+	if (opts.profile || opts.callCounts) await cdp.send("Profiler.enable");
+	if (opts.profile) await startTimeProfiling(cdp, opts.profileInterval);
+	if (opts.callCounts) await startCoverageCollection(cdp);
+}
+/** Exclude chrome:// and devtools:// internal scripts. */
+function isPageScript(s) {
+	return !!s.url && !s.url.startsWith("chrome") && !s.url.startsWith("devtools");
+}
+//#endregion
+//#region src/profiling/browser/BenchLoop.ts
+/**
+* Bench function mode: run window.__bench in a timed iteration loop.
+*
+* Simplified vs TimingRunner because it runs inside page.evaluate()
+* where shared code, Node APIs, and V8 intrinsics are unavailable.
+*
+* Not feasible in browser page context:
+*  - heap tracking (no getHeapStatistics)
+*  - V8 opt status tracing (no %GetOptimizationStatus)
+*  - explicit GC or pause-for-compilation
+*/
+async function runBenchLoop(ctx) {
+	const { page, cdp, params, samplingInterval } = ctx;
+	const maxTime = params.maxTime ?? Number.MAX_SAFE_INTEGER;
+	const maxIter = params.maxIterations ?? Number.MAX_SAFE_INTEGER;
+	const opts = instrumentOpts(params, samplingInterval);
+	await startInstruments(cdp, opts);
+	const { samples, totalMs } = await page.evaluate(async ({ maxTime, maxIter }) => {
+		const bench = globalThis.__bench;
+		const estimated = Math.min(maxIter, Math.ceil(maxTime / .1));
+		const samples = new Array(estimated);
+		let count = 0;
+		const startAll = performance.now();
+		const deadline = startAll + maxTime;
+		for (let i = 0; i < maxIter && performance.now() < deadline; i++) {
+			const t0 = performance.now();
+			await bench();
+			samples[count++] = performance.now() - t0;
+		}
+		samples.length = count;
+		return {
+			samples,
+			totalMs: performance.now() - startAll
+		};
+	}, {
+		maxTime,
+		maxIter
+	});
+	return {
+		samples,
+		wallTimeMs: totalMs,
+		...await stopInstruments(cdp, opts)
+	};
+}
+//#endregion
+//#region src/profiling/browser/CdpClient.ts
+/** Connect to a CDP WebSocket endpoint and return a client. */
+async function connectCdp(wsUrl) {
+	const ws = await openWebSocket(wsUrl);
+	let nextId = 1;
+	const pending = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	ws.addEventListener("message", (event) => {
+		const msg = JSON.parse(String(event.data));
+		if ("id" in msg) {
+			const p = pending.get(msg.id);
+			if (!p) return;
+			pending.delete(msg.id);
+			if (msg.error) p.reject(/* @__PURE__ */ new Error(`CDP: ${msg.error.message}`));
+			else p.resolve(msg.result ?? {});
+		} else if ("method" in msg) for (const h of listeners.get(msg.method) ?? []) h(msg.params ?? {});
+	});
+	const client = {
+		send(method, params) {
+			return new Promise((resolve, reject) => {
+				const id = nextId++;
+				const timer = setTimeout(() => {
+					if (pending.delete(id)) reject(/* @__PURE__ */ new Error(`CDP timeout after 60s: ${method}`));
+				}, 6e4);
+				const clear = () => clearTimeout(timer);
+				pending.set(id, {
+					resolve(v) {
+						clear();
+						resolve(v);
+					},
+					reject(e) {
+						clear();
+						reject(e);
+					}
+				});
+				ws.send(JSON.stringify({
+					id,
+					method,
+					params
+				}));
+			});
+		},
+		on(event, handler) {
+			const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+			listeners.set(event, set);
+			set.add(handler);
+		},
+		once(event, handler) {
+			const wrap = (params) => {
+				listeners.get(event)?.delete(wrap);
+				handler(params);
+			};
+			client.on(event, wrap);
+		},
+		close() {
+			for (const [, p] of pending) p.reject(/* @__PURE__ */ new Error("CDP connection closed"));
+			pending.clear();
+			ws.close();
+		}
+	};
+	return client;
+}
+/** Open a WebSocket connection, rejecting if the handshake fails. */
+async function openWebSocket(wsUrl) {
+	const ws = new WebSocket(wsUrl);
+	const err = /* @__PURE__ */ new Error(`CDP connect failed: ${wsUrl}`);
+	await new Promise((resolve, reject) => {
+		ws.addEventListener("open", () => resolve());
+		ws.addEventListener("error", () => reject(err));
+	});
+	return ws;
+}
+//#endregion
+//#region src/profiling/browser/CdpPage.ts
+/** Create a page abstraction over a CDP client connected to a page target. */
+async function createCdpPage(cdp, opts) {
+	const timeout = opts?.timeout ?? 3e4;
+	await cdp.send("Page.enable");
+	await cdp.send("Runtime.enable");
+	return {
+		navigate: (url, navOpts) => cdpNavigate(cdp, url, navOpts),
+		evaluate: (fn, arg) => cdpEvaluate(cdp, fn, arg),
+		exposeFunction: (name, fn) => cdpExpose(cdp, name, fn),
+		async addInitScript(fn) {
+			await cdp.send("Page.addScriptToEvaluateOnNewDocument", { source: `(${fn.toString()})()` });
+		},
+		waitForSelector(sel) {
+			return pollEval(cdp, `!!document.querySelector(${JSON.stringify(sel)})`, timeout);
+		},
+		waitForFunction: (expr) => pollEval(cdp, expr, timeout),
+		onPageError(handler) {
+			cdp.on("Runtime.exceptionThrown", ({ exceptionDetails: d }) => {
+				handler(d.exception?.description || d.text);
+			});
+		}
+	};
+}
+/** Navigate to a URL and wait for the specified load condition. */
+async function cdpNavigate(cdp, url, navOpts) {
+	const event = (navOpts?.waitUntil ?? "load") === "domcontentloaded" ? "Page.domContentEventFired" : "Page.loadEventFired";
+	const loaded = new Promise((r) => cdp.once(event, () => r()));
+	await cdp.send("Page.navigate", { url });
+	await loaded;
+}
+/** Evaluate a function in the page and return the result. */
+async function cdpEvaluate(cdp, fn, arg) {
+	const argStr = arg !== void 0 ? JSON.stringify(arg) : "";
+	const opts = {
+		expression: `(${fn.toString()})(${argStr})`,
+		awaitPromise: true,
+		returnByValue: true
+	};
+	const { result, exceptionDetails: err } = await cdp.send("Runtime.evaluate", opts);
+	if (err) throw new Error(err.exception?.description || err.text);
+	return result.value;
+}
+/** Expose a Node function to the page via Runtime.addBinding. */
+async function cdpExpose(cdp, name, fn) {
+	const binding = `__cdp_${name}`;
+	await cdp.send("Runtime.addBinding", { name: binding });
+	const wrapper = `(() => {
+    const g = globalThis;
+    if (!g.__cdpSeq) { g.__cdpSeq = 0; g.__cdpCbs = {}; }
+    g[${JSON.stringify(name)}] = (...args) => new Promise((resolve, reject) => {
+      const seq = ++g.__cdpSeq;
+      g.__cdpCbs[seq] = { resolve, reject };
+      g[${JSON.stringify(binding)}](JSON.stringify({ seq, args }));
+    });
+  })()`;
+	await cdp.send("Page.addScriptToEvaluateOnNewDocument", { source: wrapper });
+	await cdp.send("Runtime.evaluate", { expression: wrapper });
+	const pageEval = (expr) => cdp.send("Runtime.evaluate", { expression: expr });
+	cdp.on("Runtime.bindingCalled", async (params) => {
+		if (params.name !== binding) return;
+		const { seq, args } = JSON.parse(params.payload);
+		const cb = `globalThis.__cdpCbs[${seq}]`;
+		try {
+			const val = await fn(...args);
+			await pageEval(`${cb}?.resolve(${JSON.stringify(val ?? null)})`);
+		} catch (err) {
+			await pageEval(`${cb}?.reject(new Error(${JSON.stringify(String(err.message))}))`);
+		}
+	});
+}
+/** Poll a JS expression until truthy, with timeout. */
+async function pollEval(cdp, expression, timeout) {
+	const deadline = Date.now() + timeout;
+	const evalOpts = {
+		expression,
+		returnByValue: true
+	};
+	while (Date.now() < deadline) {
+		const { result } = await cdp.send("Runtime.evaluate", evalOpts);
+		if (result.value) return;
+		await new Promise((r) => setTimeout(r, 100));
+	}
+	throw new Error(`Timed out waiting for: ${expression}`);
+}
+//#endregion
+//#region src/profiling/browser/ChromeLauncher.ts
+/** Flags to suppress background services irrelevant to benchmarking. */
+const quietFlags = [
+	"--disable-background-networking",
+	"--disable-client-side-phishing-detection",
+	"--disable-component-update",
+	"--disable-field-trial-config",
+	"--disable-sync",
+	"--disable-breakpad",
+	"--noerrdialogs",
+	"--disable-features=OptimizationHints,Translate,MediaRouter,DialMediaRouteProvider",
+	"--disable-extensions",
+	"--disable-component-extensions-with-background-pages",
+	"--disable-default-apps",
+	"--metrics-recording-only",
+	"--no-service-autorun",
+	"--password-store=basic",
+	"--use-mock-keychain"
+];
+/** Stderr patterns to suppress (irrelevant to benchmarking). */
+const chromeNoise = /SharedImageManager|skia_output_device_buffer_queue|task_policy_set/;
+/** Launch Chrome with remote debugging and return instance handle. */
+async function launchChrome(opts) {
+	const { headless = false, chromeProfile, chromePath, args = [] } = opts;
+	const chrome = chromePath || process.env.CHROME_PATH || findChrome();
+	const tmpDir = chromeProfile ? void 0 : await mkdtemp(join(tmpdir(), "benchforge-"));
+	const proc = spawn(chrome, [
+		"--remote-debugging-port=0",
+		`--user-data-dir=${chromeProfile ?? tmpDir}`,
+		"--no-first-run",
+		"--no-default-browser-check",
+		...quietFlags,
+		...headless ? ["--headless=new"] : [],
+		...args
+	], { stdio: [
+		"pipe",
+		"pipe",
+		"pipe"
+	] });
+	const wsUrlPromise = parseWsUrl(proc);
+	pipeChromeOutput(proc);
+	const wsUrl = await wsUrlPromise;
+	return {
+		port: Number(new URL(wsUrl).port),
+		process: proc,
+		async close() {
+			proc.kill();
+			await new Promise((r) => proc.on("exit", () => r()));
+			if (tmpDir) await rm(tmpDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		}
+	};
+}
+/** Create a new browser tab and return its CDP WebSocket URL and target ID. */
+async function createTab(port) {
+	const url = `http://127.0.0.1:${port}/json/new`;
+	const text = await (await fetch(url, { method: "PUT" })).text();
+	try {
+		const json = JSON.parse(text);
+		return {
+			wsUrl: json.webSocketDebuggerUrl,
+			targetId: json.id
+		};
+	} catch {
+		const msg = `Chrome /json/new returned non-JSON: ${text.slice(0, 200)}`;
+		throw new Error(msg);
+	}
+}
+/** Close a browser tab by target ID. */
+async function closeTab(port, targetId) {
+	const url = `http://127.0.0.1:${port}/json/close/${targetId}`;
+	await fetch(url).catch(() => {});
+}
+/** Find Chrome/Chromium on the system. */
+function findChrome() {
+	if (process.platform === "darwin") {
+		const path = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+		if (existsSync(path)) return path;
+	}
+	if (process.platform === "win32") for (const env of ["ProgramFiles", "ProgramFiles(x86)"]) {
+		const base = process.env[env];
+		if (!base) continue;
+		const p = join(base, "Google", "Chrome", "Application", "chrome.exe");
+		if (existsSync(p)) return p;
+	}
+	for (const name of [
+		"google-chrome",
+		"chromium-browser",
+		"chromium"
+	]) try {
+		return execFileSync("which", [name], { encoding: "utf8" }).trim();
+	} catch {}
+	throw new Error("Chrome not found. Install Chrome or set CHROME_PATH, or use --chrome <path>.");
+}
+/** Parse the DevTools WebSocket URL from Chrome's stderr. */
+function parseWsUrl(proc) {
+	return new Promise((resolve, reject) => {
+		const wsPattern = /DevTools listening on (ws:\/\/\S+)/;
+		const onData = (chunk) => {
+			const match = chunk.toString().match(wsPattern);
+			if (match) {
+				proc.stderr?.off("data", onData);
+				resolve(match[1]);
+			}
+		};
+		proc.stderr?.on("data", onData);
+		proc.on("error", reject);
+		proc.on("exit", (code) => reject(/* @__PURE__ */ new Error(`Chrome exited (code ${code}) before DevTools ready`)));
+	});
+}
+/** Forward Chrome stdout/stderr to terminal, filtering known noise. */
+function pipeChromeOutput(proc) {
+	const forward = (stream) => stream?.on("data", (chunk) => {
+		const lines = chunk.toString().split("\n").map((l) => l.trim()).filter((l) => l && !chromeNoise.test(l));
+		for (const line of lines) process.stderr.write(`[chrome] ${line}\n`);
+	});
+	forward(proc.stdout);
+	forward(proc.stderr);
+}
+//#endregion
+//#region src/profiling/browser/PageLoadMode.ts
+/** Run passive page-load profiling: instrument ==> navigate ==> wait ==> collect. */
+async function runPageLoad(ctx) {
+	const { page, cdp, params, samplingInterval } = ctx;
+	const opts = instrumentOpts(params, samplingInterval);
+	await startInstruments(cdp, opts);
+	await page.addInitScript(() => {
+		const g = globalThis;
+		g.__lcpTime = void 0;
+		new PerformanceObserver((list) => {
+			const entries = list.getEntries();
+			if (entries.length) g.__lcpTime = entries.at(-1).startTime;
+		}).observe({
+			type: "largest-contentful-paint",
+			buffered: true
+		});
+	});
+	const { url, waitFor } = params;
+	const isBuiltinWait = waitFor === "load" || waitFor === "domcontentloaded";
+	const waitUntil = isBuiltinWait ? waitFor : "load";
+	await page.navigate(url, { waitUntil });
+	if (waitFor && !isBuiltinWait) if (/^[#.[]/.test(waitFor)) await page.waitForSelector(waitFor);
+	else await page.waitForFunction(waitFor);
+	const navTiming = await readNavTiming(page);
+	return {
+		...await stopInstruments(cdp, opts),
+		navTiming,
+		wallTimeMs: navTiming.loadEvent
+	};
+}
+/** Read navigation timing from the page via Performance API. */
+async function readNavTiming(page) {
+	return page.evaluate(() => {
+		const nav = performance.getEntriesByType("navigation")[0] ?? {};
+		return {
+			domContentLoaded: nav.domContentLoadedEventEnd ?? 0,
+			loadEvent: nav.loadEventEnd ?? 0,
+			lcp: globalThis.__lcpTime
+		};
+	});
+}
+//#endregion
+//#region src/profiling/browser/BrowserProfiler.ts
+/**
+* Run browser benchmark, auto-detecting mode:
+* - Bench function (window.__bench): CLI controls iteration and timing.
+* - Page load (no __bench, or --page-load): measures navigation timing.
+*/
+async function profileBrowser(params) {
+	const { headless = false, chromePath, chromeProfile, chromeArgs: args } = params;
+	const owned = !params.chrome;
+	const launch = {
+		headless,
+		chromePath,
+		chromeProfile,
+		args
+	};
+	const chrome = params.chrome ?? await launchChrome(launch);
+	try {
+		const { wsUrl, targetId } = await createTab(chrome.port);
+		const cdp = await connectCdp(wsUrl);
+		try {
+			return await runProfile(await createCdpPage(cdp, { timeout: (params.timeout ?? 60) * 1e3 }), cdp, params);
+		} finally {
+			cdp.close();
+			await closeTab(chrome.port, targetId);
+		}
+	} finally {
+		if (owned) await chrome.close();
+	}
+}
+/**
+* Run profiling on an open CDP page, auto-detecting mode:
+* - **bench**: page exports `window.__bench` ==> CLI iterates and times it
+* - **page-load**: no `__bench` found (or `--page-load` flag) ==> profile navigation
+*
+* When auto-detecting, navigates once to check for `__bench`. If not found,
+* reloads via `runPageLoad` which starts instruments before navigation.
+*/
+async function runProfile(page, cdp, params) {
+	const samplingInterval = params.allocOptions?.samplingInterval ?? 32768;
+	const traceEvents = params.gcStats ? await startGcTracing(cdp) : [];
+	const ctx = {
+		page,
+		cdp,
+		params,
+		samplingInterval
+	};
+	let result;
+	if (params.pageLoad) result = await runPageLoad(ctx);
+	else {
+		await page.navigate(params.url, { waitUntil: "load" });
+		if (await page.evaluate(() => typeof globalThis.__bench === "function")) result = await runBenchLoop(ctx);
+		else {
+			console.warn("No __bench found. Reloading in --page-load mode.");
+			result = await runPageLoad(ctx);
+		}
+	}
+	if (params.gcStats) return {
+		...result,
+		gcStats: await collectTracing(cdp, traceEvents)
+	};
+	return result;
+}
+//#endregion
+//#region src/cli/BrowserBench.ts
+const { yellow } = colors;
+/** Run browser profiling via CDP and report with standard pipeline. */
+async function browserBenchExports(args) {
+	warnBrowserFlags(args);
+	const params = buildBrowserParams(args);
+	const name = nameFromUrl(args.url);
+	const baselineUrl = args["baseline-url"];
+	if (!(args.batches > 1 || !!baselineUrl || (args.iterations ?? 0) > 1 || params.pageLoad)) {
+		const result = await profileBrowser(params);
+		const results = browserResultGroups(name, result);
+		printBrowserReport(result, results, args);
+		await exportReports({
+			results,
+			args
+		});
+		return;
+	}
+	const { lastRaw, results } = await runBrowserBatches(params, name, args);
+	printBrowserReport(lastRaw, results, args);
+	await exportReports({
+		results,
+		args
+	});
+}
+/** Warn about Node-only flags ignored in browser mode. */
+function warnBrowserFlags(args) {
+	const ignored = [
+		[!args.worker, "--no-worker"],
+		[!!args["trace-opt"], "--trace-opt"],
+		[!!args["gc-force"], "--gc-force"],
+		[!!args.adaptive, "--adaptive"]
+	].filter(([active]) => active).map(([, flag]) => flag);
+	if (ignored.length > 0) console.warn(yellow(`Ignored in browser mode: ${ignored.join(", ")}`));
+}
+/** Convert CLI args to browser profiler parameters. */
+function buildBrowserParams(args) {
+	const { maxTime, maxIterations } = resolveLimits(args);
+	const chromeArgs = args["chrome-args"]?.flatMap((a) => a.split(/\s+/)).map(stripQuotes).filter(Boolean);
+	return {
+		url: args.url,
+		pageLoad: args["page-load"] || !!args["wait-for"],
+		maxTime,
+		maxIterations,
+		chromeArgs,
+		allocOptions: {
+			samplingInterval: args["alloc-interval"],
+			stackDepth: args["alloc-depth"]
+		},
+		alloc: needsAlloc(args),
+		profile: needsProfile(args),
+		profileInterval: args["profile-interval"],
+		headless: args.headless,
+		chromePath: args.chrome,
+		chromeProfile: args["chrome-profile"],
+		timeout: args.timeout,
+		gcStats: args["gc-stats"],
+		callCounts: args["call-counts"],
+		waitFor: args["wait-for"]
+	};
+}
+/** Extract a short name from a URL for report labels. */
+function nameFromUrl(url) {
+	return new URL(url).pathname.split("/").pop() || "browser";
+}
+/** Wrap browser profile result as ReportGroup[] for the standard export pipeline. */
+function browserResultGroups(name, result) {
+	return [{
+		name,
+		reports: [{
+			name,
+			measuredResults: toBrowserMeasured(name, result)
+		}]
+	}];
+}
+/** Print text report and optional heap profile for browser results. */
+function printBrowserReport(result, results, args) {
+	const hasPageLoad = ((results[0]?.reports[0]?.measuredResults)?.navTimings?.length ?? 0) > 0 || !!result.navTiming;
+	const hasIterSamples = !!result.samples?.length;
+	const sections = [
+		...hasPageLoad ? pageLoadStatsSections : [],
+		...hasIterSamples ? [buildTimeSection(args.stats)] : [],
+		...result.gcStats ? [browserGcStatsSection] : [],
+		...hasPageLoad || hasIterSamples ? [runsSection] : []
+	];
+	if (sections.length > 0) console.log(withStatus("computing report", () => reportResults(results, sections)));
+	if (!result.heapProfile) return;
+	printHeapReports(results, {
+		...cliHeapReportOptions(args),
+		isUserCode: isBrowserUserCode
+	});
+}
+/** Launch Chrome, run batched fresh tabs, merge results. */
+async function runBrowserBatches(params, name, args) {
+	const { headless, chrome: chromePath } = args;
+	const chromeProfile = args["chrome-profile"];
+	const chrome = await launchChrome({
+		headless,
+		chromePath,
+		chromeProfile,
+		args: params.chromeArgs
+	});
+	try {
+		return await runBatchedTabs(params, name, args, chrome);
+	} finally {
+		await chrome.close();
+	}
+}
+/** Strip surrounding quotes from a chrome-args token. */
+function stripQuotes(s) {
+	return s.replace(/^(['"])(.*)\1$/s, "$2").replace(/^(-[^=]+=)(['"])(.*)\2$/s, "$1$3");
+}
+/** Convert a browser profile result into a MeasuredResults for the report pipeline. */
+function toBrowserMeasured(name, result) {
+	const { gcStats, heapProfile, timeProfile, coverage, navTiming, samples } = result;
+	const base = {
+		name,
+		gcStats,
+		heapProfile,
+		timeProfile,
+		coverage,
+		navTimings: navTiming ? [navTiming] : void 0
+	};
+	if (samples?.length) {
+		const totalTime = result.wallTimeMs ? result.wallTimeMs / 1e3 : void 0;
+		return {
+			...base,
+			samples,
+			time: computeStats(samples),
+			totalTime
+		};
+	}
+	const wallTime = result.wallTimeMs ?? 0;
+	return {
+		...base,
+		samples: [wallTime],
+		time: computeStats([wallTime])
+	};
+}
+/** Execute batched browser tabs within an already-launched Chrome instance. */
+async function runBatchedTabs(params, name, args, chrome) {
+	const baselineUrl = args["baseline-url"];
+	const { maxTime, maxIterations } = params;
+	const limits = {
+		maxTime,
+		maxIterations
+	};
+	const state = { detectedPageLoad: params.pageLoad };
+	const warmup = !(args["warmup-batch"] ?? false) && args.batches > 1;
+	const mk = (url, label) => makeTabRunner(params, chrome, limits, warmup, state, url, label);
+	const runCurrent = mk(params.url, name);
+	const runBaseline = baselineUrl ? mk(baselineUrl, nameFromUrl(baselineUrl)) : void 0;
+	const progress = (p) => {
+		const sec = (p.elapsed / 1e3).toFixed(0);
+		const msg = `\r◊ batch ${p.batch + 1}/${p.batches} ${p.label} (${sec}s)   `;
+		process.stderr.write(msg);
+	};
+	const { results: [current], baseline } = await runBatched([runCurrent], runBaseline, Math.max(args.batches, 2), args["warmup-batch"] ?? false, progress);
+	process.stderr.write("\r" + " ".repeat(50) + "\r");
+	const baseName = baselineUrl ? nameFromUrl(baselineUrl) : void 0;
+	const baselineEntry = baseline && baseName ? {
+		name: baseName,
+		measuredResults: baseline
+	} : void 0;
+	const reports = [{
+		name,
+		measuredResults: current
+	}];
+	return {
+		lastRaw: state.lastRaw,
+		results: [{
+			name,
+			reports,
+			baseline: baselineEntry
+		}]
+	};
+}
+/** Create a batch runner closure for a single URL (current or baseline). */
+function makeTabRunner(params, chrome, limits, warmup, state, url, label) {
+	let firstCall = warmup;
+	return async () => {
+		const isWarmup = firstCall;
+		firstCall = false;
+		const p = {
+			...params,
+			chrome,
+			url
+		};
+		if (state.detectedPageLoad) {
+			const batchLimits = isWarmup ? { maxIterations: 1 } : limits;
+			const result = await runMultiPageLoad({
+				...p,
+				pageLoad: true
+			}, label, batchLimits);
+			state.lastRaw ??= {
+				navTiming: result.navTimings?.[0],
+				wallTimeMs: result.time.p50
+			};
+			return result;
+		}
+		const raw = await profileBrowser(p);
+		state.lastRaw = raw;
+		if (!raw.samples?.length && raw.navTiming) state.detectedPageLoad = true;
+		return toBrowserMeasured(label, raw);
+	};
+}
+/** Run page loads until duration or iteration limit, collecting wallTimeMs as samples. */
+async function runMultiPageLoad(params, name, limits) {
+	const { maxTime, maxIterations } = limits;
+	const raws = [];
+	let accumulated = 0;
+	for (let i = 0;; i++) {
+		if (maxIterations != null && i >= maxIterations) break;
+		const raw = await profileBrowser(params);
+		raws.push(raw);
+		accumulated += raw.wallTimeMs ?? 0;
+		if (maxTime != null && accumulated >= maxTime) break;
+	}
+	const samples = raws.map((r) => r.wallTimeMs ?? 0);
+	const navTimings = raws.map((r) => r.navTiming).filter(Boolean);
+	const { heapProfile, timeProfile, coverage } = raws[raws.length - 1];
+	const totalTime = accumulated / 1e3;
+	const gcStats = mergeGcStats(raws);
+	return {
+		name,
+		samples,
+		time: computeStats(samples),
+		totalTime,
+		navTimings: navTimings.length ? navTimings : void 0,
+		gcStats,
+		heapProfile,
+		timeProfile,
+		coverage
+	};
+}
+//#endregion
+//#region src/cli/FilterBenchmarks.ts
+/** Filter suite benchmarks by name pattern (substring or regex). */
+function filterBenchmarks(suite, filter, removeEmpty = true) {
+	if (!filter) return suite;
+	const regex = createFilterRegex(filter);
+	const groups = suite.groups.map((group) => ({
+		...group,
+		benchmarks: group.benchmarks.filter((bench) => regex.test(stripCaseSuffix(bench.name))),
+		baseline: group.baseline && regex.test(stripCaseSuffix(group.baseline.name)) ? group.baseline : void 0
+	})).filter((group) => !removeEmpty || group.benchmarks.length > 0);
+	if (groups.every((g) => g.benchmarks.length === 0)) throw new Error(`No benchmarks match filter: "${filter}"`);
+	return {
+		name: suite.name,
+		groups
+	};
+}
+/** Create regex from filter string. Uses literal prefix match unless the string looks like regex. */
+function createFilterRegex(filter) {
+	const isSlashed = filter.startsWith("/") && filter.endsWith("/");
+	if (!(isSlashed || /[*?[|]/.test(filter) || filter.startsWith("^") || filter.endsWith("$"))) return new RegExp("^" + escapeRegex(filter), "i");
+	const pattern = isSlashed ? filter.slice(1, -1) : filter;
+	try {
+		return new RegExp(pattern, "i");
+	} catch {
+		return new RegExp(escapeRegex(filter), "i");
+	}
+}
+/** Strip case suffix like " [large]" from benchmark name for filtering. */
+function stripCaseSuffix(name) {
+	return name.replace(/ \[.*?\]$/, "");
+}
+/** Escape special regex characters for literal matching. */
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/cli/SuiteRunner.ts
+/** Run a benchmark suite with CLI arguments. */
+async function runBenchmarks(suite, args) {
+	validateArgs(args);
+	const { filter, worker: useWorker, batches = 1 } = args;
+	const warmupBatch = args["warmup-batch"] ?? false;
+	const options = cliToRunnerOptions(args);
+	const filtered = filterBenchmarks(suite, filter);
+	const suiteParams = {
+		runner: "timing",
+		options,
+		useWorker,
+		batches,
+		warmupBatch
+	};
+	return serialMap(filtered.groups, (g) => runGroup(g, suiteParams));
+}
+/** 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;
+}
+/** Execute group with shared setup, optionally batching to reduce ordering bias. */
+async function runGroup(group, suiteParams) {
+	const { batches, warmupBatch, ...rest } = suiteParams;
+	const { name, benchmarks, baseline, setup, metadata } = group;
+	const setupParams = await setup?.();
+	validateBenchmarkParameters(group);
+	const runParams = {
+		...rest,
+		params: setupParams,
+		metadata
+	};
+	if (batches === 1) return runSingleBatch(name, benchmarks, baseline, runParams);
+	return runMultipleBatches(name, benchmarks, baseline, runParams, batches, warmupBatch);
+}
+/** Warn if parameterized benchmarks lack a setup function. */
+function validateBenchmarkParameters(group) {
+	if (group.setup) return;
+	const { benchmarks, baseline } = group;
+	const all = baseline ? [...benchmarks, baseline] : benchmarks;
+	for (const bench of all.filter((b) => b.fn.length > 0)) console.warn(`Benchmark "${bench.name}" in group "${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, warmupBatch) {
+	const { metadata } = runParams;
+	const run = (spec) => async () => (await runSingleBenchmark(spec, runParams)).measuredResults;
+	const batched = await runBatched(benchmarks.map(run), baseline ? run(baseline) : void 0, batches, warmupBatch);
+	return {
+		name,
+		reports: benchmarks.map((b, i) => ({
+			name: b.name,
+			measuredResults: batched.results[i],
+			metadata
+		})),
+		baseline: batched.baseline && baseline ? {
+			name: baseline.name,
+			measuredResults: batched.baseline,
+			metadata
+		} : void 0
+	};
+}
+/** Run single benchmark and create report. */
+async function runSingleBenchmark(spec, { runner, options, useWorker, params, metadata }) {
+	const [result] = await runBenchmark({
+		spec,
+		runner,
+		options,
+		useWorker,
+		params
+	});
+	return {
+		name: spec.name,
+		measuredResults: result,
+		metadata
+	};
+}
+//#endregion
+//#region src/cli/RunBenchCLI.ts
+/** Top-level CLI dispatch: route to view, analyze, or default bench runner. */
+async function dispatchCli() {
+	const argv = hideBin(process.argv);
+	const [command] = argv;
+	if (command === "view") {
+		const { viewArchive } = await import("./ViewerServer-CuMNdNBz.mjs");
+		return viewArchive(requireFile(argv[1], "view"));
+	}
+	if (command === "analyze") {
+		const { analyzeArchive } = await import("./AnalyzeArchive-8NCJhmhS.mjs");
+		return analyzeArchive(requireFile(argv[1], "analyze"));
+	}
+	await runDefaultBench(void 0, void 0, argv);
+}
+/** Run benchmarks and display results. Suite is optional with --url (browser mode). */
+async function runDefaultBench(suite, configureArgs, argv, opts) {
+	const args = parseBenchArgs(configureArgs, argv);
+	if (args.url) return browserBenchExports(args);
+	if (args.list && suite) return listSuite(suite);
+	if (suite) return benchExports(suite, args, opts);
+	if (args.file) return fileBenchExports(args.file, args);
+	throw new Error("Provide a benchmark file, --url for browser mode, or pass a BenchSuite directly.");
+}
+/** Parse CLI args with optional custom yargs configuration. */
+function parseBenchArgs(configureArgs, argv) {
+	return parseCliArgs(argv ?? hideBin(process.argv), configureArgs);
+}
+/** Run a BenchSuite and print results with standard reporting. */
+async function benchExports(suite, args, opts) {
+	const results = await runBenchmarks(suite, args);
+	console.log(withStatus("computing report", () => defaultReport(results, args, opts)));
+	await finishReports(results, args, opts);
+}
+/** Run matrix suite with full CLI handling (parse, run, report, export). */
+async function runDefaultMatrixBench(suite, configureArgs, reportOptions) {
+	await matrixBenchExports(suite, parseBenchArgs(configureArgs), reportOptions);
+}
+/** Run a matrix suite, print results, and handle exports. */
+async function matrixBenchExports(suite, args, reportOptions, exportOptions) {
+	const results = await runMatrixSuite(suite, args);
+	const report = withStatus("computing report", () => defaultMatrixReport(results, reportOptions, args));
+	console.log(report);
+	await finishReports(matrixToReportGroups(results), args, exportOptions);
+}
+/** Run matrix suite with CLI arguments. --filter narrows defaults, --all --filter narrows all. */
+async function runMatrixSuite(suite, args) {
+	if (args.list) {
+		await listMatrixSuite(suite);
+		return [];
+	}
+	validateArgs(args);
+	const filter = args.filter ? parseMatrixFilter(args.filter) : void 0;
+	const options = cliToMatrixOptions(args);
+	const results = [];
+	for (const matrix of suite.matrices) {
+		const filtered = await applyMatrixFilters(matrix, args.all, filter);
+		const { filteredCases, filteredVariants } = filtered;
+		results.push(await runMatrix(filtered, {
+			...options,
+			filteredCases,
+			filteredVariants
+		}));
+	}
+	return results;
+}
+/** Require a file argument for a subcommand, exiting with usage on missing. */
+function requireFile(filePath, subcommand) {
+	if (filePath) return filePath;
+	console.error(`Usage: benchforge ${subcommand} <file.benchforge>`);
+	process.exit(1);
+}
+/** Print available benchmarks in a suite for --list. */
+function listSuite(suite) {
+	for (const group of suite.groups) {
+		console.log(group.name);
+		for (const bench of group.benchmarks) console.log(`  ${bench.name}`);
+		if (group.baseline) console.log(`  ${group.baseline.name} (baseline)`);
+	}
+}
+/** Import a file and run it as a benchmark based on what it exports. */
+async function fileBenchExports(filePath, args) {
+	const { default: candidate } = await import(pathToFileURL(resolve(filePath)).href);
+	if (candidate && Array.isArray(candidate.matrices)) {
+		if (args.list) return listMatrixSuite(candidate);
+		return matrixBenchExports(candidate, args);
+	}
+	if (candidate && Array.isArray(candidate.groups)) {
+		if (args.list) return listSuite(candidate);
+		return benchExports(candidate, args);
+	}
+	if (typeof candidate === "function") {
+		const name = basename(filePath).replace(/\.[^.]+$/, "");
+		return benchExports({
+			name,
+			groups: [{
+				name,
+				benchmarks: [{
+					name,
+					fn: candidate
+				}]
+			}]
+		}, args);
+	}
+}
+/** Print available cases and variants in a matrix suite for --list. */
+async function listMatrixSuite(suite) {
+	for (const matrix of suite.matrices) {
+		console.log(matrix.name);
+		const caseIds = await resolveCaseIds(matrix);
+		if (caseIds) {
+			console.log("  cases:");
+			for (const id of caseIds) console.log(`    ${id}`);
+		}
+		const variantIds = await resolveVariantIds(matrix);
+		console.log("  variants:");
+		for (const id of variantIds) console.log(`    ${id}`);
+	}
+}
+/** --filter bypasses defaults (implies --all for the filtered dimension). */
+async function applyMatrixFilters(matrix, runAll, filter) {
+	const mod = matrix.casesModule ? await loadCasesModule(matrix.casesModule) : void 0;
+	let withDefaults = matrix;
+	if (!runAll && !filter && mod) {
+		const { defaultCases: filteredCases, defaultVariants: filteredVariants } = mod;
+		withDefaults = {
+			...matrix,
+			filteredCases,
+			filteredVariants
+		};
+	}
+	return filter ? filterMatrix(withDefaults, filter) : withDefaults;
+}
+//#endregion
+export { gcStatsSection as A, buildTimeSection as C, totalTimeSection as D, timeSection as E, browserCliArgs as M, defaultCliArgs as N, gcSection as O, parseCliArgs as P, buildGenericSections as S, runsSection as T, reportMatrixResults as _, runDefaultBench as a, prepareHtmlData as b, runBenchmarks as c, exportReports as d, defaultMatrixReport as f, reportOptStatus as g, printHeapReports as h, parseBenchArgs as i, exportPerfettoTrace as j, gcSections as k, filterMatrix as l, matrixToReportGroups as m, dispatchCli as n, runDefaultMatrixBench as o, defaultReport as p, matrixBenchExports as r, runMatrixSuite as s, benchExports as t, parseMatrixFilter as u, reportResults as v, optSection as w, adaptiveSections as x, cliToMatrixOptions as y };
+
+//# sourceMappingURL=RunBenchCLI-C17DrJz8.mjs.map