benchforge 0.1.9 → 0.2.4

package/dist/src-Cf_LXwlp.mjs

@@ -1,2873 +0,0 @@
-import { a as createAdaptiveWrapper, c as BasicRunner, i as createRunner, l as computeStats, n as getElapsed, o as average, r as getPerfNow, s as bootstrapDifferenceCI, t as debugWorkerTiming, u as discoverVariants } from "./TimingUtils-ClclVQ7E.mjs";
-import { n as parseGcLine, t as aggregateGcStats } from "./GcStats-ByEovUi1.mjs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { execSync, fork, spawn } from "node:child_process";
-import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import path, { basename, dirname, extname, join, resolve } from "node:path";
-import pico from "picocolors";
-import { table } from "table";
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { createServer } from "node:http";
-import open from "open";
-
-//#region src/matrix/CaseLoader.ts
-/** Load a cases module by URL */
-async function loadCasesModule(moduleUrl) {
-	const module = await import(moduleUrl);
-	if (!Array.isArray(module.cases)) throw new Error(`Cases module at ${moduleUrl} must export 'cases' array`);
-	return {
-		cases: module.cases,
-		defaultCases: module.defaultCases,
-		defaultVariants: module.defaultVariants,
-		loadCase: module.loadCase
-	};
-}
-/** Load case data from a CasesModule or pass through the caseId */
-async function loadCaseData(casesModule, caseId) {
-	if (casesModule?.loadCase) return casesModule.loadCase(caseId);
-	return { data: caseId };
-}
-
-//#endregion
-//#region src/runners/RunnerOrchestrator.ts
-const logTiming = debugWorkerTiming ? (message) => console.log(`[RunnerOrchestrator] ${message}`) : () => {};
-/** Execute benchmarks directly or in worker process */
-async function runBenchmark({ spec, runner, options, useWorker = false, params }) {
-	if (!useWorker) {
-		const resolvedSpec = spec.modulePath ? await resolveModuleSpec(spec, params) : {
-			spec,
-			params
-		};
-		const base = await createRunner(runner);
-		return (options.adaptive ? createAdaptiveWrapper(base, options) : base).runBench(resolvedSpec.spec, options, resolvedSpec.params);
-	}
-	return runInWorker({
-		spec,
-		runner,
-		options,
-		params
-	});
-}
-/** Resolve modulePath/exportName to a real function for non-worker mode */
-async function resolveModuleSpec(spec, params) {
-	const module = await import(spec.modulePath);
-	const fn = spec.exportName ? module[spec.exportName] : module.default || module;
-	if (typeof fn !== "function") {
-		const name = spec.exportName || "default";
-		throw new Error(`Export '${name}' from ${spec.modulePath} is not a function`);
-	}
-	let resolvedParams = params;
-	if (spec.setupExportName) {
-		const setupFn = module[spec.setupExportName];
-		if (typeof setupFn !== "function") {
-			const msg = `Setup export '${spec.setupExportName}' from ${spec.modulePath} is not a function`;
-			throw new Error(msg);
-		}
-		resolvedParams = await setupFn(params);
-	}
-	return {
-		spec: {
-			...spec,
-			fn
-		},
-		params: resolvedParams
-	};
-}
-/** Run benchmark in isolated worker process */
-async function runInWorker(workerParams) {
-	const { spec, runner, options, params } = workerParams;
-	const msg = createRunMessage(spec, runner, options, params);
-	return runWorkerWithMessage(spec.name, options, msg);
-}
-/** Create worker process with timing logs */
-function createWorkerWithTiming(gcStats) {
-	const workerStart = getPerfNow();
-	const gcEvents = [];
-	const worker = createWorkerProcess(gcStats);
-	const createTime = getPerfNow();
-	if (gcStats && worker.stdout) setupGcCapture(worker, gcEvents);
-	logTiming(`Worker process created in ${getElapsed(workerStart, createTime).toFixed(1)}ms`);
-	return {
-		worker,
-		createTime,
-		gcEvents
-	};
-}
-/** Capture and parse GC lines from stdout (V8's --trace-gc-nvp outputs to stdout) */
-function setupGcCapture(worker, gcEvents) {
-	let buffer = "";
-	worker.stdout.on("data", (data) => {
-		buffer += data.toString();
-		const lines = buffer.split("\n");
-		buffer = lines.pop() || "";
-		for (const line of lines) {
-			const event = parseGcLine(line);
-			if (event) gcEvents.push(event);
-			else if (line.trim()) process.stdout.write(line + "\n");
-		}
-	});
-}
-/** Spawn worker, wire handlers, send message, return results */
-function runWorkerWithMessage(name, options, message) {
-	const startTime = getPerfNow();
-	const collectGcStats = options.gcStats ?? false;
-	logTiming(`Starting worker for ${name}`);
-	return new Promise((resolve, reject) => {
-		const { worker, createTime, gcEvents } = createWorkerWithTiming(collectGcStats);
-		setupWorkerHandlers(worker, name, createWorkerHandlers(name, startTime, gcEvents, resolve, reject));
-		sendWorkerMessage(worker, message, createTime);
-	});
-}
-/** Send message to worker with timing log */
-function sendWorkerMessage(worker, message, createTime) {
-	const messageTime = getPerfNow();
-	worker.send(message);
-	logTiming(`Message sent to worker in ${getElapsed(createTime, messageTime).toFixed(1)}ms`);
-}
-/** Setup worker event handlers with cleanup */
-function setupWorkerHandlers(worker, specName, handlers) {
-	const { resolve, reject } = handlers;
-	const cleanup = createCleanup(worker, specName, reject);
-	worker.on("message", createMessageHandler(specName, cleanup, resolve, reject));
-	worker.on("error", createErrorHandler(specName, cleanup, reject));
-	worker.on("exit", createExitHandler(specName, cleanup, reject));
-}
-/** Handle worker messages (results or errors) */
-function createMessageHandler(specName, cleanup, resolve, reject) {
-	return (msg) => {
-		cleanup();
-		if (msg.type === "result") resolve(msg.results, msg.heapProfile);
-		else if (msg.type === "error") {
-			const error = /* @__PURE__ */ new Error(`Benchmark "${specName}" failed: ${msg.error}`);
-			if (msg.stack) error.stack = msg.stack;
-			reject(error);
-		}
-	};
-}
-/** Handle worker process errors */
-function createErrorHandler(specName, cleanup, reject) {
-	return (error) => {
-		cleanup();
-		reject(/* @__PURE__ */ new Error(`Worker process failed for benchmark "${specName}": ${error.message}`));
-	};
-}
-/** Handle worker process exit */
-function createExitHandler(specName, cleanup, reject) {
-	return (code, _signal) => {
-		if (code !== 0 && code !== null) {
-			cleanup();
-			const msg = `Worker exited with code ${code} for benchmark "${specName}"`;
-			reject(new Error(msg));
-		}
-	};
-}
-/** Create cleanup for timeout and termination */
-function createCleanup(worker, specName, reject) {
-	const timeoutId = setTimeout(() => {
-		cleanup();
-		reject(/* @__PURE__ */ new Error(`Benchmark "${specName}" timed out after 60 seconds`));
-	}, 6e4);
-	const cleanup = () => {
-		clearTimeout(timeoutId);
-		if (!worker.killed) worker.kill("SIGTERM");
-	};
-	return cleanup;
-}
-/** Create worker process with configuration */
-function createWorkerProcess(gcStats) {
-	const workerPath = resolveWorkerPath();
-	const execArgv = ["--expose-gc", "--allow-natives-syntax"];
-	if (gcStats) execArgv.push("--trace-gc-nvp");
-	return fork(workerPath, [], {
-		execArgv,
-		silent: gcStats,
-		env: {
-			...process.env,
-			NODE_OPTIONS: ""
-		}
-	});
-}
-/** Resolve WorkerScript path for dev (.ts) or dist (.mjs) */
-function resolveWorkerPath() {
-	const dir = import.meta.dirname;
-	const tsPath = path.join(dir, "WorkerScript.ts");
-	if (existsSync(tsPath)) return tsPath;
-	return path.join(dir, "runners", "WorkerScript.mjs");
-}
-/** @return handlers that attach GC stats and heap profile to results */
-function createWorkerHandlers(specName, startTime, gcEvents, resolve, reject) {
-	return {
-		resolve: (results, heapProfile) => {
-			logTiming(`Total worker time for ${specName}: ${getElapsed(startTime).toFixed(1)}ms`);
-			if (gcEvents?.length) {
-				const gcStats = aggregateGcStats(gcEvents);
-				for (const r of results) r.gcStats = gcStats;
-			}
-			if (heapProfile) for (const r of results) r.heapProfile = heapProfile;
-			resolve(results);
-		},
-		reject
-	};
-}
-/** Create message for worker execution */
-function createRunMessage(spec, runnerName, options, params) {
-	const { fn, ...rest } = spec;
-	const message = {
-		type: "run",
-		spec: rest,
-		runnerName,
-		options,
-		params
-	};
-	if (spec.modulePath) {
-		message.modulePath = spec.modulePath;
-		message.exportName = spec.exportName;
-		if (spec.setupExportName) message.setupExportName = spec.setupExportName;
-	} else message.fnCode = fn.toString();
-	return message;
-}
-/** Run a matrix variant benchmark in isolated worker process */
-async function runMatrixVariant(params) {
-	const { variantDir, variantId, caseId, caseData, casesModule, runner, options } = params;
-	const name = `${variantId}/${caseId}`;
-	return runWorkerWithMessage(name, options, {
-		type: "run",
-		spec: {
-			name,
-			fn: () => {}
-		},
-		runnerName: runner,
-		options,
-		variantDir,
-		variantId,
-		caseId,
-		caseData,
-		casesModule
-	});
-}
-
-//#endregion
-//#region src/BenchMatrix.ts
-/** @return true if variant is a StatefulVariant (has setup + run) */
-function isStatefulVariant(v) {
-	return typeof v === "object" && "setup" in v && "run" in v;
-}
-/** Run a BenchMatrix with inline variants or variantDir */
-async function runMatrix(matrix, options = {}) {
-	validateBaseline(matrix);
-	const effectiveOptions = {
-		...matrix.defaults,
-		...options
-	};
-	if (matrix.variantDir) return runMatrixWithDir(matrix, effectiveOptions);
-	if (matrix.variants) return runMatrixInline(matrix, effectiveOptions);
-	throw new Error("BenchMatrix requires either 'variants' or 'variantDir'");
-}
-/** @throws if both baselineDir and baselineVariant are set */
-function validateBaseline(matrix) {
-	const msg = "BenchMatrix cannot have both 'baselineDir' and 'baselineVariant'";
-	if (matrix.baselineDir && matrix.baselineVariant) throw new Error(msg);
-}
-function buildRunnerOptions(options) {
-	return {
-		maxIterations: options.iterations,
-		maxTime: options.maxTime ?? 1e3,
-		warmup: options.warmup ?? 0,
-		collect: options.collect,
-		cpuCounters: options.cpuCounters,
-		traceOpt: options.traceOpt,
-		noSettle: options.noSettle,
-		pauseFirst: options.pauseFirst,
-		pauseInterval: options.pauseInterval,
-		pauseDuration: options.pauseDuration,
-		gcStats: options.gcStats,
-		heapSample: options.heapSample,
-		heapInterval: options.heapInterval,
-		heapDepth: options.heapDepth
-	};
-}
-/** Load cases module and resolve filtered case IDs */
-async function resolveCases(matrix, options) {
-	const casesModule = matrix.casesModule ? await loadCasesModule(matrix.casesModule) : void 0;
-	const allCaseIds = casesModule?.cases ?? matrix.cases ?? ["default"];
-	return {
-		casesModule,
-		caseIds: options.filteredCases ?? allCaseIds
-	};
-}
-/** Run matrix with inline variants (non-worker mode) */
-async function runMatrixInline(matrix, options) {
-	const msg = "BenchMatrix with inline 'variants' cannot use 'baselineDir'. Use 'variantDir' instead.";
-	if (matrix.baselineDir) throw new Error(msg);
-	const { casesModule, caseIds } = await resolveCases(matrix, options);
-	const runner = new BasicRunner();
-	const runnerOpts = buildRunnerOptions(options);
-	const variantEntries = options.filteredVariants ? Object.entries(matrix.variants).filter(([id]) => options.filteredVariants.includes(id)) : Object.entries(matrix.variants);
-	const variants = [];
-	for (const [variantId, variant] of variantEntries) {
-		const cases = [];
-		for (const caseId of caseIds) {
-			const loaded = await loadCaseData(casesModule, caseId);
-			const measured = await runVariant(variant, casesModule || matrix.cases ? loaded.data : void 0, variantId, runner, runnerOpts);
-			cases.push({
-				caseId,
-				measured,
-				metadata: loaded.metadata
-			});
-		}
-		variants.push({
-			id: variantId,
-			cases
-		});
-	}
-	if (matrix.baselineVariant) applyBaselineVariant(variants, matrix.baselineVariant);
-	return {
-		name: matrix.name,
-		variants
-	};
-}
-/** Run matrix with variantDir (worker mode for memory isolation) */
-async function runMatrixWithDir(matrix, options) {
-	const allVariantIds = await discoverVariants(matrix.variantDir);
-	if (allVariantIds.length === 0) throw new Error(`No variants found in ${matrix.variantDir}`);
-	const variants = await runDirVariants(options.filteredVariants ?? allVariantIds, await createDirContext(matrix, options));
-	if (matrix.baselineVariant) applyBaselineVariant(variants, matrix.baselineVariant);
-	return {
-		name: matrix.name,
-		variants
-	};
-}
-/** Create context for directory-based matrix execution */
-async function createDirContext(matrix, options) {
-	const baselineIds = matrix.baselineDir ? await discoverVariants(matrix.baselineDir) : [];
-	const { casesModule, caseIds } = await resolveCases(matrix, options);
-	return {
-		matrix,
-		casesModule,
-		baselineIds,
-		caseIds,
-		runnerOpts: buildRunnerOptions(options)
-	};
-}
-/** Run all variants using worker processes */
-async function runDirVariants(variantIds, ctx) {
-	const variants = [];
-	for (const variantId of variantIds) {
-		const cases = await runDirVariantCases(variantId, ctx);
-		variants.push({
-			id: variantId,
-			cases
-		});
-	}
-	return variants;
-}
-/** Run all cases for a single variant */
-async function runDirVariantCases(variantId, ctx) {
-	const { matrix, casesModule, caseIds, runnerOpts } = ctx;
-	const cases = [];
-	for (const caseId of caseIds) {
-		const caseData = !matrix.casesModule && matrix.cases ? caseId : void 0;
-		const [measured] = await runMatrixVariant({
-			variantDir: matrix.variantDir,
-			variantId,
-			caseId,
-			caseData,
-			casesModule: matrix.casesModule,
-			runner: "basic",
-			options: runnerOpts
-		});
-		const loaded = await loadCaseData(casesModule, caseId);
-		const baseline = await runBaselineIfExists(variantId, caseId, caseData, ctx);
-		const deltaPercent = baseline ? computeDeltaPercent(baseline, measured) : void 0;
-		const metadata = loaded.metadata;
-		cases.push({
-			caseId,
-			measured,
-			metadata,
-			baseline,
-			deltaPercent
-		});
-	}
-	return cases;
-}
-/** Run baseline variant if it exists in baselineDir */
-async function runBaselineIfExists(variantId, caseId, caseData, ctx) {
-	const { matrix, baselineIds, runnerOpts } = ctx;
-	if (!matrix.baselineDir || !baselineIds.includes(variantId)) return void 0;
-	const [measured] = await runMatrixVariant({
-		variantDir: matrix.baselineDir,
-		variantId,
-		caseId,
-		caseData,
-		casesModule: matrix.casesModule,
-		runner: "basic",
-		options: runnerOpts
-	});
-	return measured;
-}
-/** Compute delta percentage: (current - baseline) / baseline * 100 */
-function computeDeltaPercent(baseline, current) {
-	const baseAvg = average(baseline.samples);
-	if (baseAvg === 0) return 0;
-	return (average(current.samples) - baseAvg) / baseAvg * 100;
-}
-/** Apply baselineVariant comparison - one variant is the reference for all others */
-function applyBaselineVariant(variants, baselineVariantId) {
-	const baselineVariant = variants.find((v) => v.id === baselineVariantId);
-	if (!baselineVariant) return;
-	const baselineByCase = /* @__PURE__ */ new Map();
-	for (const c of baselineVariant.cases) baselineByCase.set(c.caseId, c.measured);
-	for (const variant of variants) {
-		if (variant.id === baselineVariantId) continue;
-		for (const caseResult of variant.cases) {
-			const baseline = baselineByCase.get(caseResult.caseId);
-			if (baseline) {
-				caseResult.baseline = baseline;
-				caseResult.deltaPercent = computeDeltaPercent(baseline, caseResult.measured);
-			}
-		}
-	}
-}
-/** Run a single variant with case data */
-async function runVariant(variant, caseData, name, runner, options) {
-	if (isStatefulVariant(variant)) {
-		const state = await variant.setup(caseData);
-		const [result] = await runner.runBench({
-			name,
-			fn: () => variant.run(state)
-		}, options);
-		return result;
-	}
-	const [result] = await runner.runBench({
-		name,
-		fn: () => variant(caseData)
-	}, options);
-	return result;
-}
-
-//#endregion
-//#region src/table-util/Formatters.ts
-const { red: red$1, green } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? {
-	red: (str) => str,
-	green: (str) => str
-} : pico;
-/** Format percentages with custom precision */
-function percentPrecision(precision) {
-	return (x) => {
-		if (typeof x !== "number") return null;
-		return percent(x, precision);
-	};
-}
-/** Format duration in milliseconds with appropriate units */
-function duration(ms) {
-	if (typeof ms !== "number") return null;
-	if (ms < .001) return `${(ms * 1e6).toFixed(0)}ns`;
-	if (ms < 1) return `${(ms * 1e3).toFixed(1)}μs`;
-	if (ms < 1e3) return `${ms.toFixed(2)}ms`;
-	return `${(ms / 1e3).toFixed(2)}s`;
-}
-/** Format time in milliseconds, showing very small values with units */
-function timeMs(ms) {
-	if (typeof ms !== "number") return null;
-	if (ms < .001) return `${(ms * 1e6).toFixed(0)}ns`;
-	if (ms < .01) return `${(ms * 1e3).toFixed(1)}μs`;
-	if (ms >= 10) return ms.toFixed(0);
-	return ms.toFixed(2);
-}
-/** Format integer with thousand separators */
-function integer(x) {
-	if (typeof x !== "number") return null;
-	return new Intl.NumberFormat("en-US").format(Math.round(x));
-}
-/** Format fraction as percentage (0.473 → 47.3%) */
-function percent(fraction, precision = 1) {
-	if (typeof fraction !== "number") return null;
-	return `${Math.abs(fraction * 100).toFixed(precision)}%`;
-}
-/** Format percentage difference between two values */
-function diffPercent(main, base) {
-	if (typeof main !== "number" || typeof base !== "number") return " ";
-	return coloredPercent(main - base, base);
-}
-/** Format fraction as colored +/- percentage */
-function coloredPercent(numerator, denominator, positiveIsGreen = true) {
-	const fraction = numerator / denominator;
-	if (Number.isNaN(fraction) || !Number.isFinite(fraction)) return " ";
-	const positive = fraction >= 0;
-	const percentStr = `${positive ? "+" : "-"}${percent(fraction)}`;
-	return positive === positiveIsGreen ? green(percentStr) : red$1(percentStr);
-}
-/** Format bytes with appropriate units (B, KB, MB, GB) */
-function formatBytes(bytes) {
-	if (typeof bytes !== "number") return null;
-	if (bytes < 1024) return `${bytes.toFixed(0)}B`;
-	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-	if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
-	return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}GB`;
-}
-/** Format percentage difference with confidence interval */
-function formatDiffWithCI(value) {
-	if (!isDifferenceCI(value)) return null;
-	const { percent, ci, direction } = value;
-	return colorByDirection(diffCIText(percent, ci), direction);
-}
-/** Format percentage difference with CI for throughput metrics (higher is better) */
-function formatDiffWithCIHigherIsBetter(value) {
-	if (!isDifferenceCI(value)) return null;
-	const { percent, ci, direction } = value;
-	return colorByDirection(diffCIText(-percent, [-ci[1], -ci[0]]), direction);
-}
-/** @return formatted "pct [lo, hi]" text for a diff with CI */
-function diffCIText(pct, ci) {
-	return `${formatBound(pct)} [${formatBound(ci[0])}, ${formatBound(ci[1])}]`;
-}
-/** @return text colored green for faster, red for slower */
-function colorByDirection(text, direction) {
-	if (direction === "faster") return green(text);
-	if (direction === "slower") return red$1(text);
-	return text;
-}
-/** @return signed percentage string (e.g. "+1.2%", "-3.4%") */
-function formatBound(v) {
-	return `${v >= 0 ? "+" : ""}${v.toFixed(1)}%`;
-}
-/** @return true if value is a DifferenceCI object */
-function isDifferenceCI(x) {
-	return typeof x === "object" && x !== null && "ci" in x && "direction" in x;
-}
-/** @return truncated string with ellipsis if over maxLen */
-function truncate(str, maxLen = 30) {
-	return str.length > maxLen ? str.slice(0, maxLen - 3) + "..." : str;
-}
-
-//#endregion
-//#region src/table-util/TableReport.ts
-const { bold } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? { bold: (str) => str } : pico;
-/** Build formatted table with column groups and baselines */
-function buildTable(columnGroups, resultGroups, nameKey = "name") {
-	return createTable(columnGroups, flattenGroups(columnGroups, resultGroups, nameKey));
-}
-/** Convert columns and records to formatted table */
-function createTable(groups, records) {
-	const dataRows = toRows(records, groups);
-	const { headerRows, config } = setup(groups, dataRows);
-	return table([...headerRows, ...dataRows], config);
-}
-/** Create header rows with group titles */
-function createGroupHeaders(groups, numColumns) {
-	if (!groups.some((g) => g.groupTitle)) return [];
-	return [groups.flatMap((g) => {
-		return padWithBlanks(g.groupTitle ? [bold(g.groupTitle)] : [], g.columns.length);
-	}), padWithBlanks([], numColumns)];
-}
-/** @return draw functions for horizontal/vertical table borders */
-function createLines(groups) {
-	const { sectionBorders, headerBottom } = calcBorders(groups);
-	function drawVerticalLine(index, size) {
-		return index === 0 || index === size || sectionBorders.includes(index);
-	}
-	function drawHorizontalLine(index, size) {
-		return index === 0 || index === size || index === headerBottom;
-	}
-	return {
-		drawHorizontalLine,
-		drawVerticalLine
-	};
-}
-/** @return spanning cell configs for group title headers */
-function createSectionSpans(groups) {
-	let col = 0;
-	const alignment = "center";
-	return groups.map((g) => {
-		const colSpan = g.columns.length;
-		const span = {
-			row: 0,
-			col,
-			colSpan,
-			alignment
-		};
-		col += colSpan;
-		return span;
-	});
-}
-/** @return bolded column title strings */
-function getTitles(groups) {
-	return groups.flatMap((g) => g.columns.map((c) => bold(c.title || " ")));
-}
-/** @return array padded with blank strings to the given length */
-function padWithBlanks(arr, length) {
-	if (arr.length >= length) return arr;
-	return [...arr, ...Array(length - arr.length).fill(" ")];
-}
-/** Convert records to string arrays for table */
-function toRows(records, groups) {
-	const allColumns = groups.flatMap((group) => group.columns);
-	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 ?? " "));
-}
-/** Add comparison values for diff columns */
-function addComparisons(groups, mainRecord, baselineRecord) {
-	const diffColumns = groups.flatMap((g) => g.columns).filter((col) => col.diffKey);
-	const updatedMain = { ...mainRecord };
-	for (const col of diffColumns) {
-		const dcol = col;
-		const diffKey = dcol.diffKey;
-		const mainValue = mainRecord[diffKey];
-		const baselineValue = baselineRecord[diffKey];
-		const diffStr = (dcol.diffFormatter ?? diffPercent)(mainValue, baselineValue);
-		updatedMain[col.key] = diffStr;
-	}
-	return updatedMain;
-}
-/** Flatten groups with spacing */
-function flattenGroups(columnGroups, resultGroups, nameKey) {
-	return resultGroups.flatMap((group, i) => {
-		const groupRecords = addBaseline(columnGroups, group, nameKey);
-		return i === resultGroups.length - 1 ? groupRecords : [...groupRecords, {}];
-	});
-}
-/** Process results with baseline comparisons */
-function addBaseline(columnGroups, group, nameKey) {
-	const { results, baseline } = group;
-	if (!baseline) return results;
-	const diffResults = results.map((result) => addComparisons(columnGroups, result, baseline));
-	const markedBaseline = {
-		...baseline,
-		[nameKey]: `--> ${baseline[nameKey]}`
-	};
-	return [...diffResults, markedBaseline];
-}
-/** Calculate vertical lines between sections and header bottom position */
-function calcBorders(groups) {
-	if (groups.length === 0) return {
-		sectionBorders: [],
-		headerBottom: 1
-	};
-	const sectionBorders = [];
-	let border = 0;
-	for (const g of groups) {
-		border += g.columns.length;
-		sectionBorders.push(border);
-	}
-	return {
-		sectionBorders,
-		headerBottom: 3
-	};
-}
-/** Create headers and table configuration */
-function setup(groups, dataRows) {
-	const titles = getTitles(groups);
-	const numColumns = titles.length;
-	return {
-		headerRows: [...createGroupHeaders(groups, numColumns), titles],
-		config: {
-			spanningCells: createSectionSpans(groups),
-			columns: calcColumnWidths(groups, titles, dataRows),
-			...createLines(groups)
-		}
-	};
-}
-/** Calculate column widths based on content, including group titles */
-function calcColumnWidths(groups, titles, dataRows) {
-	const widths = [];
-	for (let i = 0; i < titles.length; i++) {
-		const titleW = cellWidth(titles[i]);
-		const maxDataW = dataRows.reduce((max, row) => Math.max(max, cellWidth(row[i])), 0);
-		widths.push(Math.max(titleW, maxDataW));
-	}
-	let colIndex = 0;
-	for (const group of groups) {
-		const groupW = cellWidth(group.groupTitle);
-		if (groupW > 0) {
-			const numCols = group.columns.length;
-			const separatorWidth = (numCols - 1) * 3;
-			const needed = groupW - widths.slice(colIndex, colIndex + numCols).reduce((a, b) => a + b, 0) - separatorWidth;
-			if (needed > 0) widths[colIndex + numCols - 1] += needed;
-		}
-		colIndex += group.columns.length;
-	}
-	return Object.fromEntries(widths.map((w, i) => [i, {
-		width: w,
-		wrapWord: false
-	}]));
-}
-const ansiEscapeRegex = new RegExp(String.fromCharCode(27) + "\\[[0-9;]*m", "g");
-/** Get visible length of a cell value (strips ANSI escape codes) */
-function cellWidth(value) {
-	if (value == null) return 0;
-	return String(value).replace(ansiEscapeRegex, "").length;
-}
-
-//#endregion
-//#region src/BenchmarkReport.ts
-/** @return formatted table report with optional baseline comparisons */
-function reportResults(groups, sections) {
-	const results = groups.map((group) => resultGroupValues(group, sections));
-	return buildTable(createColumnGroups(sections, results.some((g) => g.baseline)), results);
-}
-/** @return values for report group */
-function resultGroupValues(group, sections) {
-	const { reports, baseline } = group;
-	const baselineSamples = baseline?.measuredResults.samples;
-	return {
-		results: reports.map((report) => {
-			const row = {
-				name: truncate(report.name),
-				...extractReportValues(report, sections)
-			};
-			if (baselineSamples && report.measuredResults.samples) row.diffCI = bootstrapDifferenceCI(baselineSamples, report.measuredResults.samples);
-			return row;
-		}),
-		baseline: baseline && valuesForReports([baseline], sections)[0]
-	};
-}
-/** @return rows with stats from sections */
-function valuesForReports(reports, sections) {
-	return reports.map((report) => ({
-		name: truncate(report.name),
-		...extractReportValues(report, sections)
-	}));
-}
-/** @return merged statistics from all sections */
-function extractReportValues(report, sections) {
-	const { measuredResults, metadata } = report;
-	const entries = sections.flatMap((s) => Object.entries(s.extract(measuredResults, metadata)));
-	return Object.fromEntries(entries);
-}
-/** @return column groups with diff columns if baseline exists */
-function createColumnGroups(sections, hasBaseline) {
-	const nameColumn = { columns: [{
-		key: "name",
-		title: "name"
-	}] };
-	const groups = sections.flatMap((section) => section.columns());
-	return [nameColumn, ...hasBaseline ? injectDiffColumns(groups) : groups];
-}
-/** @return groups with single CI column after first comparable field */
-function injectDiffColumns(reportGroups) {
-	let ciAdded = false;
-	return reportGroups.map((group) => ({
-		groupTitle: group.groupTitle,
-		columns: group.columns.flatMap((col) => {
-			if (col.comparable && !ciAdded) {
-				ciAdded = true;
-				return [col, {
-					title: "Δ% CI",
-					key: "diffCI",
-					formatter: col.higherIsBetter ? formatDiffWithCIHigherIsBetter : formatDiffWithCI
-				}];
-			}
-			return [col];
-		})
-	}));
-}
-
-//#endregion
-//#region src/cli/CliArgs.ts
-const defaultAdaptiveMaxTime = 20;
-const cliOptions = {
-	time: {
-		type: "number",
-		default: .642,
-		requiresArg: true,
-		describe: "test duration in seconds"
-	},
-	cpu: {
-		type: "boolean",
-		default: false,
-		describe: "CPU counter measurements (requires root)"
-	},
-	collect: {
-		type: "boolean",
-		default: false,
-		describe: "force GC after each iteration"
-	},
-	"gc-stats": {
-		type: "boolean",
-		default: false,
-		describe: "collect GC statistics (Node: --trace-gc-nvp, browser: CDP tracing)"
-	},
-	profile: {
-		type: "boolean",
-		default: false,
-		describe: "run once for profiling"
-	},
-	filter: {
-		type: "string",
-		requiresArg: true,
-		describe: "filter benchmarks by regex or substring"
-	},
-	all: {
-		type: "boolean",
-		default: false,
-		describe: "run all cases (ignore defaultCases)"
-	},
-	worker: {
-		type: "boolean",
-		default: true,
-		describe: "run in worker process for isolation (default: true)"
-	},
-	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)"
-	},
-	warmup: {
-		type: "number",
-		default: 0,
-		describe: "warmup iterations before measurement"
-	},
-	html: {
-		type: "boolean",
-		default: false,
-		describe: "generate HTML report and open in browser"
-	},
-	"export-html": {
-		type: "string",
-		requiresArg: true,
-		describe: "export HTML report to specified file"
-	},
-	json: {
-		type: "string",
-		requiresArg: true,
-		describe: "export benchmark data to JSON file"
-	},
-	perfetto: {
-		type: "string",
-		requiresArg: true,
-		describe: "export Perfetto trace file (view at ui.perfetto.dev)"
-	},
-	"trace-opt": {
-		type: "boolean",
-		default: false,
-		describe: "trace V8 optimization tiers (requires --allow-natives-syntax)"
-	},
-	"skip-settle": {
-		type: "boolean",
-		default: false,
-		describe: "skip post-warmup settle time (see V8 optimization cold start)"
-	},
-	"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"
-	},
-	batches: {
-		type: "number",
-		default: 1,
-		describe: "divide time into N batches, alternating baseline/current order"
-	},
-	iterations: {
-		type: "number",
-		requiresArg: true,
-		describe: "exact number of iterations (overrides --time)"
-	},
-	"heap-sample": {
-		type: "boolean",
-		default: false,
-		describe: "heap sampling allocation attribution (includes garbage)"
-	},
-	"heap-interval": {
-		type: "number",
-		default: 32768,
-		describe: "heap sampling interval in bytes"
-	},
-	"heap-depth": {
-		type: "number",
-		default: 64,
-		describe: "heap sampling stack depth"
-	},
-	"heap-rows": {
-		type: "number",
-		default: 20,
-		describe: "top allocation sites to show"
-	},
-	"heap-stack": {
-		type: "number",
-		default: 3,
-		describe: "call stack depth to display"
-	},
-	"heap-verbose": {
-		type: "boolean",
-		default: false,
-		describe: "verbose output with file:// paths and line numbers"
-	},
-	"heap-user-only": {
-		type: "boolean",
-		default: false,
-		describe: "filter to user code only (hide node internals)"
-	},
-	url: {
-		type: "string",
-		requiresArg: true,
-		describe: "page URL for browser profiling (enables browser mode)"
-	},
-	headless: {
-		type: "boolean",
-		default: true,
-		describe: "run browser in headless mode"
-	},
-	timeout: {
-		type: "number",
-		default: 60,
-		describe: "browser page timeout in seconds"
-	},
-	"chrome-args": {
-		type: "string",
-		array: true,
-		requiresArg: true,
-		describe: "extra Chromium flags"
-	}
-};
-/** @return yargs with standard benchmark options */
-function defaultCliArgs(yargsInstance) {
-	return yargsInstance.command("$0 [file]", "run benchmarks", (y) => {
-		y.positional("file", {
-			type: "string",
-			describe: "benchmark file to run"
-		});
-	}).options(cliOptions).help().strict();
-}
-/** @return parsed command line arguments */
-function parseCliArgs(args, configure = defaultCliArgs) {
-	return configure(yargs(args)).parseSync();
-}
-
-//#endregion
-//#region src/export/JsonExport.ts
-/** Export benchmark results to JSON file */
-async function exportBenchmarkJson(groups, outputPath, args, suiteName = "Benchmark Suite") {
-	const jsonData = prepareJsonData(groups, args, suiteName);
-	await writeFile(outputPath, JSON.stringify(jsonData, null, 2), "utf-8");
-	console.log(`Benchmark data exported to: ${outputPath}`);
-}
-/** Convert ReportGroup data to JSON format */
-function prepareJsonData(groups, args, suiteName) {
-	return {
-		meta: {
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			version: process.env.npm_package_version || "unknown",
-			args: cleanCliArgs(args),
-			environment: {
-				node: process.version,
-				platform: process.platform,
-				arch: process.arch
-			}
-		},
-		suites: [{
-			name: suiteName,
-			groups: groups.map(convertGroup)
-		}]
-	};
-}
-/** Convert a report group, mapping each report to the JSON result format */
-function convertGroup(group) {
-	return {
-		name: "Benchmark Group",
-		baseline: group.baseline ? convertReport(group.baseline) : void 0,
-		benchmarks: group.reports.map(convertReport)
-	};
-}
-/** Extract measured stats and optional metrics into JSON result shape */
-function convertReport(report) {
-	const { name, measuredResults: m } = report;
-	const { time, heapSize, gcTime, cpu } = m;
-	const minMaxMean = (s) => s ? {
-		min: s.min,
-		max: s.max,
-		mean: s.avg
-	} : void 0;
-	return {
-		name,
-		status: "completed",
-		samples: m.samples || [],
-		time: {
-			...minMaxMean(time),
-			p50: time.p50,
-			p75: time.p75,
-			p99: time.p99,
-			p999: time.p999
-		},
-		heapSize: minMaxMean(heapSize),
-		gcTime: minMaxMean(gcTime),
-		cpu: cpu ? {
-			instructions: cpu.instructions,
-			cycles: cpu.cycles,
-			cacheMisses: m.cpuCacheMiss,
-			branchMisses: cpu.branchMisses
-		} : void 0,
-		execution: {
-			iterations: m.samples?.length || 0,
-			totalTime: m.totalTime || 0,
-			warmupRuns: void 0
-		}
-	};
-}
-/** Clean CLI args for JSON export (remove undefined values) */
-function cleanCliArgs(args) {
-	const toCamel = (k) => k.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
-	const entries = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => [toCamel(k), v]);
-	return Object.fromEntries(entries);
-}
-
-//#endregion
-//#region src/export/PerfettoExport.ts
-const pid = 1;
-const tid = 1;
-/** Export benchmark results to Perfetto-compatible trace file */
-function exportPerfettoTrace(groups, outputPath, args) {
-	const absPath = resolve(outputPath);
-	writeTraceFile(absPath, mergeV8Trace(buildTraceEvents(groups, args)));
-	console.log(`Perfetto trace exported to: ${outputPath}`);
-	scheduleDeferredMerge(absPath);
-}
-/** Build trace events from benchmark results */
-function buildTraceEvents(groups, args) {
-	const meta = (name, a) => ({
-		ph: "M",
-		ts: 0,
-		pid,
-		tid,
-		name,
-		args: a
-	});
-	const events = [
-		meta("process_name", { name: "wesl-bench" }),
-		meta("thread_name", { name: "MainThread" }),
-		meta("bench_settings", cleanArgs(args))
-	];
-	for (const group of groups) for (const report of group.reports) {
-		const results = report.measuredResults;
-		events.push(...buildBenchmarkEvents(results));
-	}
-	return events;
-}
-function instant(ts, name, args) {
-	return {
-		ph: "i",
-		ts,
-		pid,
-		tid,
-		cat: "bench",
-		name,
-		s: "t",
-		args
-	};
-}
-function counter(ts, name, args) {
-	return {
-		ph: "C",
-		ts,
-		pid,
-		tid,
-		cat: "bench",
-		name,
-		args
-	};
-}
-/** Build events for a single benchmark run */
-function buildBenchmarkEvents(results) {
-	const { samples, heapSamples, timestamps, pausePoints } = results;
-	if (!timestamps?.length) return [];
-	const events = [];
-	for (let i = 0; i < samples.length; i++) {
-		const ts = timestamps[i];
-		const ms = Math.round(samples[i] * 100) / 100;
-		events.push(instant(ts, results.name, {
-			n: i,
-			ms
-		}));
-		events.push(counter(ts, "duration", { ms }));
-		if (heapSamples?.[i] !== void 0) {
-			const MB = Math.round(heapSamples[i] / 1024 / 1024 * 10) / 10;
-			events.push(counter(ts, "heap", { MB }));
-		}
-	}
-	for (const pause of pausePoints ?? []) {
-		const ts = timestamps[pause.sampleIndex];
-		if (ts) events.push(instant(ts, "pause", { ms: pause.durationMs }));
-	}
-	return events;
-}
-/** Normalize timestamps so events start at 0 */
-function normalizeTimestamps(events) {
-	const times = events.filter((e) => e.ts > 0).map((e) => e.ts);
-	if (times.length === 0) return;
-	const minTs = Math.min(...times);
-	for (const e of events) if (e.ts > 0) e.ts -= minTs;
-}
-/** Merge V8 trace events from a previous run, aligning timestamps */
-function mergeV8Trace(customEvents) {
-	const v8Events = loadV8Events(readdirSync(".").filter((f) => f.startsWith("node_trace.") && f.endsWith(".log"))[0]);
-	normalizeTimestamps(customEvents);
-	if (!v8Events) return customEvents;
-	normalizeTimestamps(v8Events);
-	return [...v8Events, ...customEvents];
-}
-/** Load V8 trace events from file, or undefined if unavailable */
-function loadV8Events(v8TracePath) {
-	if (!v8TracePath) return void 0;
-	try {
-		const v8Data = JSON.parse(readFileSync(v8TracePath, "utf-8"));
-		console.log(`Merged ${v8Data.traceEvents.length} V8 events from ${v8TracePath}`);
-		return v8Data.traceEvents;
-	} catch {
-		console.warn(`Could not parse V8 trace file: ${v8TracePath}`);
-		return;
-	}
-}
-/** Write trace events to JSON file */
-function writeTraceFile(outputPath, events) {
-	const traceFile = { traceEvents: events };
-	writeFileSync(outputPath, JSON.stringify(traceFile));
-}
-/** Clean CLI args for metadata */
-function cleanArgs(args) {
-	const skip = new Set(["_", "$0"]);
-	const entries = Object.entries(args).filter(([k, v]) => v !== void 0 && !skip.has(k));
-	return Object.fromEntries(entries);
-}
-/** Spawn a detached child to merge V8 trace after process exit */
-function scheduleDeferredMerge(outputPath) {
-	const cwd = process.cwd();
-	const mergeScript = `
-    const { readdirSync, readFileSync, writeFileSync } = require('fs');
-    function normalize(events) {
-      const times = events.filter(e => e.ts > 0).map(e => e.ts);
-      if (!times.length) return;
-      const min = Math.min(...times);
-      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'));
-        normalize(v8Data.traceEvents);
-        const merged = { traceEvents: [...v8Data.traceEvents, ...ourData.traceEvents] };
-        writeFileSync('${outputPath}', JSON.stringify(merged));
-        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();
-	});
-}
-
-//#endregion
-//#region src/HtmlDataPrep.ts
-/** Find higherIsBetter from first comparable column in sections */
-function findHigherIsBetter(sections) {
-	return (sections?.flatMap((s) => s.columns().flatMap((g) => g.columns)))?.find((c) => c.comparable)?.higherIsBetter ?? false;
-}
-/** Flip CI percent for metrics where higher is better (e.g., lines/sec) */
-function flipCI(ci) {
-	return {
-		percent: -ci.percent,
-		ci: [-ci.ci[1], -ci.ci[0]],
-		direction: ci.direction,
-		histogram: ci.histogram?.map((bin) => ({
-			x: -bin.x,
-			count: bin.count
-		}))
-	};
-}
-/** Prepare ReportData from benchmark results for HTML rendering */
-function prepareHtmlData(groups, options) {
-	const { cliArgs, sections, currentVersion, baselineVersion } = options;
-	const higherIsBetter = findHigherIsBetter(sections);
-	return {
-		groups: groups.map((group) => prepareGroupData(group, sections, higherIsBetter)),
-		metadata: {
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			bencherVersion: process.env.npm_package_version || "unknown",
-			cliArgs,
-			gcTrackingEnabled: cliArgs?.["gc-stats"] === true,
-			currentVersion,
-			baselineVersion
-		}
-	};
-}
-/** @return group data with bootstrap CI comparisons against baseline */
-function prepareGroupData(group, sections, higherIsBetter) {
-	const baselineSamples = group.baseline?.measuredResults.samples;
-	return {
-		name: group.name,
-		baseline: group.baseline ? prepareBenchmarkData(group.baseline, sections) : void 0,
-		benchmarks: group.reports.map((report) => {
-			const samples = report.measuredResults.samples;
-			const rawCI = baselineSamples && samples ? bootstrapDifferenceCI(baselineSamples, samples) : void 0;
-			const comparisonCI = rawCI && higherIsBetter ? flipCI(rawCI) : rawCI;
-			return {
-				...prepareBenchmarkData(report, sections),
-				comparisonCI
-			};
-		})
-	};
-}
-/** @return benchmark data with samples, stats, and formatted section values */
-function prepareBenchmarkData(report, sections) {
-	const { measuredResults } = report;
-	return {
-		name: report.name,
-		samples: measuredResults.samples,
-		warmupSamples: measuredResults.warmupSamples,
-		allocationSamples: measuredResults.allocationSamples,
-		heapSamples: measuredResults.heapSamples,
-		gcEvents: measuredResults.nodeGcTime?.events,
-		optSamples: measuredResults.optSamples,
-		pausePoints: measuredResults.pausePoints,
-		stats: measuredResults.time,
-		heapSize: measuredResults.heapSize,
-		sectionStats: sections ? extractSectionStats(report, sections) : void 0
-	};
-}
-/** @return formatted stats from all sections for tooltip display */
-function extractSectionStats(report, sections) {
-	return sections.flatMap((section) => {
-		const vals = section.extract(report.measuredResults, report.metadata);
-		return section.columns().flatMap((g) => formatGroupStats(vals, g));
-	});
-}
-/** @return formatted stats for one column group, skipping undefined values */
-function formatGroupStats(values, group) {
-	return group.columns.map((c) => formatColumnStat(values, c, group.groupTitle)).filter((s) => s !== void 0);
-}
-/** @return formatted stat for a single column, or undefined if empty/placeholder */
-function formatColumnStat(values, col, groupTitle) {
-	const raw = values[col.key];
-	if (raw === void 0) return void 0;
-	const formatted = col.formatter ? col.formatter(raw) : String(raw);
-	if (!formatted || formatted === "—" || formatted === "") return void 0;
-	return {
-		label: col.title,
-		value: formatted,
-		groupTitle
-	};
-}
-
-//#endregion
-//#region src/heap-sample/HeapSampleReport.ts
-/** Sum selfSize across all nodes in profile (before any filtering) */
-function totalProfileBytes(profile) {
-	let total = 0;
-	function walk(node) {
-		total += node.selfSize;
-		for (const child of node.children || []) walk(child);
-	}
-	walk(profile.head);
-	return total;
-}
-/** Flatten profile tree into sorted list of allocation sites with call stacks */
-function flattenProfile(profile) {
-	const sites = [];
-	function walk(node, stack) {
-		const { functionName, url, lineNumber, columnNumber } = node.callFrame;
-		const fn = functionName || "(anonymous)";
-		const col = columnNumber ?? 0;
-		const frame = {
-			fn,
-			url: url || "",
-			line: lineNumber + 1,
-			col
-		};
-		const newStack = [...stack, frame];
-		if (node.selfSize > 0) sites.push({
-			...frame,
-			bytes: node.selfSize,
-			stack: newStack
-		});
-		for (const child of node.children || []) walk(child, newStack);
-	}
-	walk(profile.head, []);
-	return sites.sort((a, b) => b.bytes - a.bytes);
-}
-/** Check if site is user code (not node internals) */
-function isNodeUserCode(site) {
-	if (!site.url) return false;
-	if (site.url.startsWith("node:")) return false;
-	if (site.url.includes("(native)")) return false;
-	if (site.url.includes("internal/")) return false;
-	return true;
-}
-/** Check if site is user code (not browser internals) */
-function isBrowserUserCode(site) {
-	if (!site.url) return false;
-	if (site.url.startsWith("chrome-extension://")) return false;
-	if (site.url.startsWith("devtools://")) return false;
-	if (site.url.includes("(native)")) return false;
-	return true;
-}
-/** Filter sites to user code only */
-function filterSites(sites, isUser = isNodeUserCode) {
-	return sites.filter(isUser);
-}
-/** Aggregate sites by location (combine same file:line:col) */
-function aggregateSites(sites) {
-	const byLocation = /* @__PURE__ */ new Map();
-	for (const site of sites) {
-		const key = `${site.url}:${site.line}:${site.col}`;
-		const existing = byLocation.get(key);
-		if (existing) existing.bytes += site.bytes;
-		else byLocation.set(key, { ...site });
-	}
-	return [...byLocation.values()].sort((a, b) => b.bytes - a.bytes);
-}
-function fmtBytes(bytes) {
-	if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
-	if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-	return `${bytes} B`;
-}
-/** Format heap report for console output */
-function formatHeapReport(sites, options) {
-	const { topN, stackDepth = 3, verbose = false } = options;
-	const { totalAll, totalUserCode, sampleCount } = options;
-	const isUser = options.isUserCode ?? isNodeUserCode;
-	const lines = [];
-	lines.push(`Heap allocation sites (top ${topN}, garbage included):`);
-	for (const site of sites.slice(0, topN)) if (verbose) formatVerboseSite(lines, site, stackDepth, isUser);
-	else formatCompactSite(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");
-}
-/** Compact single-line format: `49 MB  fn1 <- fn2 <- fn3` */
-function formatCompactSite(lines, site, stackDepth, isUser) {
-	const bytes = fmtBytes(site.bytes).padStart(10);
-	const fns = [site.fn];
-	if (site.stack && site.stack.length > 1) {
-		const callers = site.stack.slice(0, -1).reverse().slice(0, stackDepth);
-		for (const frame of callers) {
-			if (!frame.url || !isUser(frame)) continue;
-			fns.push(frame.fn);
-		}
-	}
-	const line = `${bytes}  ${fns.join(" <- ")}`;
-	lines.push(isUser(site) ? line : pico.dim(line));
-}
-/** Verbose multi-line format with file:// paths and line numbers */
-function formatVerboseSite(lines, site, stackDepth, isUser) {
-	const bytes = fmtBytes(site.bytes).padStart(10);
-	const loc = site.url ? `${site.url}:${site.line}:${site.col}` : "(unknown)";
-	const dimFn = isUser(site) ? (s) => s : pico.dim;
-	lines.push(dimFn(`${bytes}  ${site.fn}  ${loc}`));
-	if (site.stack && site.stack.length > 1) {
-		const callers = site.stack.slice(0, -1).reverse().slice(0, stackDepth);
-		for (const frame of callers) {
-			if (!frame.url || !isUser(frame)) continue;
-			const callerLoc = `${frame.url}:${frame.line}:${frame.col}`;
-			lines.push(dimFn(`            <- ${frame.fn}  ${callerLoc}`));
-		}
-	}
-}
-
-//#endregion
-//#region src/html/HtmlTemplate.ts
-const skipArgs = new Set([
-	"_",
-	"$0",
-	"html",
-	"export-html"
-]);
-/** Format ISO date as local time with UTC: "Jan 9, 2026, 3:45 PM (2026-01-09T23:45:00Z)" */
-function formatDateWithTimezone(isoDate) {
-	const date = new Date(isoDate);
-	return `${date.toLocaleString("en-US", {
-		month: "short",
-		day: "numeric",
-		year: "numeric",
-		hour: "numeric",
-		minute: "2-digit"
-	})} (${date.toISOString().replace(".000Z", "Z")})`;
-}
-/** Format relative time: "5m ago", "2h ago", "yesterday", "3 days ago" */
-function formatRelativeTime(isoDate) {
-	const date = new Date(isoDate);
-	const diffMs = (/* @__PURE__ */ new Date()).getTime() - date.getTime();
-	const diffMins = Math.floor(diffMs / 6e4);
-	const diffHours = Math.floor(diffMs / 36e5);
-	const diffDays = Math.floor(diffMs / 864e5);
-	if (diffMins < 1) return "just now";
-	if (diffMins < 60) return `${diffMins}m ago`;
-	if (diffHours < 24) return `${diffHours}h ago`;
-	if (diffDays === 1) return "yesterday";
-	if (diffDays < 30) return `${diffDays} days ago`;
-	return date.toLocaleDateString("en-US", {
-		month: "short",
-		day: "numeric"
-	});
-}
-/** Format git version for display: "abc1234* (5m ago)" */
-function formatVersion(version) {
-	if (!version || version.hash === "unknown") return "unknown";
-	const hashDisplay = version.dirty ? `${version.hash}*` : version.hash;
-	const timeDisplay = version.date ? formatRelativeTime(version.date) : "";
-	return timeDisplay ? `${hashDisplay} (${timeDisplay})` : hashDisplay;
-}
-/** Render current/baseline version info as an HTML div */
-function versionInfoHtml(data) {
-	const { currentVersion, baselineVersion } = data.metadata;
-	if (!currentVersion && !baselineVersion) return "";
-	const parts = [];
-	if (currentVersion) parts.push(`Current: ${formatVersion(currentVersion)}`);
-	if (baselineVersion) parts.push(`Baseline: ${formatVersion(baselineVersion)}`);
-	return `<div class="version-info">${parts.join(" | ")}</div>`;
-}
-const badgeLabels = {
-	faster: "Faster",
-	slower: "Slower",
-	uncertain: "Inconclusive"
-};
-/** Render faster/slower/uncertain badge with CI plot container */
-function comparisonBadge(group, groupIndex) {
-	const ci = group.benchmarks[0]?.comparisonCI;
-	if (!ci) return "";
-	const label = badgeLabels[ci.direction];
-	return `
-    <span class="badge badge-${ci.direction}">${label}</span>
-    <div id="ci-plot-${groupIndex}" class="ci-plot-container"></div>
-  `;
-}
-const defaultArgs = {
-	worker: true,
-	time: 5,
-	warmup: 500,
-	"pause-interval": 0,
-	"pause-duration": 100
-};
-/** @return true if this CLI arg should be hidden from the report header */
-function shouldSkipArg(key, value, adaptive) {
-	if (skipArgs.has(key) || value === void 0 || value === false) return true;
-	if (defaultArgs[key] === value) return true;
-	if (!key.includes("-") && key !== key.toLowerCase()) return true;
-	if (key === "convergence" && !adaptive) return true;
-	return false;
-}
-/** Reconstruct the CLI invocation string, omitting default/internal args */
-function formatCliArgs(args) {
-	if (!args) return "bb bench";
-	const parts = ["bb bench"];
-	for (const [key, value] of Object.entries(args)) {
-		if (shouldSkipArg(key, value, args.adaptive)) continue;
-		parts.push(value === true ? `--${key}` : `--${key} ${value}`);
-	}
-	return parts.join(" ");
-}
-/** Generate complete HTML document with embedded data and visualizations */
-function generateHtmlDocument(data) {
-	return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Benchmark Report - ${(/* @__PURE__ */ new Date()).toLocaleDateString()}</title>
-  <style>
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
-      background: #f5f5f5;
-      padding: 20px;
-      line-height: 1.6;
-    }
-    .header {
-      background: white;
-      padding: 10px 15px;
-      border-radius: 8px;
-      margin-bottom: 20px;
-      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-      display: flex;
-      justify-content: space-between;
-      align-items: center;
-    }
-    h1 { display: none; }
-    h2 {
-      color: #555;
-      margin: 30px 0 20px;
-      font-size: 20px;
-      border-bottom: 2px solid #e0e0e0;
-      padding-bottom: 10px;
-    }
-    .metadata { color: #666; font-size: 12px; }
-    .cli-args {
-      font-family: "SF Mono", Monaco, "Consolas", monospace;
-      font-size: 11px;
-      color: #555;
-      background: #f0f0f0;
-      padding: 6px 10px;
-      border-radius: 4px;
-      word-break: break-word;
-    }
-    .comparison-mode {
-      background: #fff3cd;
-      color: #856404;
-      padding: 8px 12px;
-      border-radius: 4px;
-      display: inline-block;
-      margin-top: 10px;
-      font-weight: 500;
-    }
-    .plot-grid {
-      display: grid;
-      grid-template-columns: 1fr 1fr;
-      gap: 20px;
-      margin-bottom: 30px;
-    }
-    .plot-grid.second-row { grid-template-columns: 1fr; }
-    .plot-container {
-      background: white;
-      padding: 20px;
-      border-radius: 8px;
-      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-    }
-    .plot-container.full-width { grid-column: 1 / -1; }
-    .plot-title { font-size: 18px; font-weight: 600; margin-bottom: 8px; color: #333; }
-    .plot-description { font-size: 14px; color: #666; margin-bottom: 15px; }
-    .plot-area {
-      display: flex;
-      justify-content: center;
-      align-items: center;
-      min-height: 300px;
-    }
-    .plot-area svg { overflow: visible; }
-    .plot-area svg g[aria-label="x-axis label"] text { font-size: 14px; }
-    .summary-stats { background: #f8f9fa; padding: 15px; border-radius: 6px; margin-top: 20px; }
-    .stats-grid {
-      display: grid;
-      grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-      gap: 10px;
-      margin-top: 10px;
-    }
-    .stat-item { background: white; padding: 10px; border-radius: 4px; text-align: center; }
-    .stat-label { font-size: 12px; color: #666; text-transform: uppercase; letter-spacing: 0.5px; }
-    .stat-value { font-size: 18px; font-weight: 600; color: #333; margin-top: 4px; }
-    .loading { color: #666; font-style: italic; padding: 20px; text-align: center; }
-    .error { color: #d32f2f; background: #ffebee; padding: 15px; border-radius: 4px; margin: 10px 0; }
-    .ci-faster { color: #22c55e; }
-    .ci-slower { color: #ef4444; }
-    .ci-uncertain { color: #6b7280; }
-    .group-header {
-      display: flex;
-      align-items: center;
-      gap: 12px;
-      margin: 30px 0 20px;
-      padding-bottom: 10px;
-      border-bottom: 2px solid #e0e0e0;
-    }
-    .group-header h2 { margin: 0; border: none; padding: 0; }
-    .badge {
-      font-size: 12px;
-      font-weight: 600;
-      padding: 4px 10px;
-      border-radius: 12px;
-      text-transform: uppercase;
-      letter-spacing: 0.5px;
-    }
-    .badge-faster { background: #dcfce7; color: #166534; }
-    .badge-slower { background: #fee2e2; color: #991b1b; }
-    .badge-uncertain { background: #dbeafe; color: #1e40af; }
-    .version-info { font-size: 12px; color: #666; margin-top: 6px; }
-    .header-right { text-align: right; }
-    .ci-plot-container { display: inline-block; vertical-align: middle; margin-left: 8px; }
-    .ci-plot-container svg { display: block; }
-  </style>
-</head>
-<body>
-  <div class="header">
-    <div class="cli-args">${formatCliArgs(data.metadata.cliArgs)}</div>
-    <div class="header-right">
-      <div class="metadata">Generated: ${formatDateWithTimezone((/* @__PURE__ */ new Date()).toISOString())}</div>
-      ${versionInfoHtml(data)}
-    </div>
-  </div>
-
-  ${data.groups.map((group, i) => `
-    <div id="group-${i}">
-      ${group.benchmarks.length > 0 ? `
-        <div class="group-header">
-          <h2>${group.name}</h2>
-          ${comparisonBadge(group, i)}
-        </div>
-
-        <div class="plot-grid">
-          <div class="plot-container">
-            <div class="plot-title">Time per Sample</div>
-            <div class="plot-description">Execution time for each sample in collection order</div>
-            <div id="sample-timeseries-${i}" class="plot-area">
-              <div class="loading">Loading time series...</div>
-            </div>
-          </div>
-
-          <div class="plot-container">
-            <div class="plot-title">Time Distribution</div>
-            <div class="plot-description">Frequency distribution of execution times</div>
-            <div id="histogram-${i}" class="plot-area">
-              <div class="loading">Loading histogram...</div>
-            </div>
-          </div>
-        </div>
-
-        <div id="stats-${i}"></div>
-      ` : "<div class=\"error\">No benchmark data available for this group</div>"}
-    </div>
-  `).join("")}
-
-  <script type="importmap">
-    {
-      "imports": {
-        "d3": "https://cdn.jsdelivr.net/npm/d3@7/+esm",
-        "@observablehq/plot": "https://cdn.jsdelivr.net/npm/@observablehq/plot@0.6/+esm"
-      }
-    }
-  <\/script>
-  <script type="module">
-    import { renderPlots } from "./plots.js";
-    const benchmarkData = ${JSON.stringify(data, null, 2)};
-    renderPlots(benchmarkData);
-  <\/script>
-</body>
-</html>`;
-}
-
-//#endregion
-//#region src/html/HtmlReport.ts
-/** Generate HTML report from prepared data and optionally open in browser */
-async function generateHtmlReport(data, options) {
-	const html = generateHtmlDocument(data);
-	const reportDir = options.outputPath || await createReportDir();
-	await mkdir(reportDir, { recursive: true });
-	await writeFile(join(reportDir, "index.html"), html, "utf-8");
-	const plots = await loadPlotsBundle();
-	await writeFile(join(reportDir, "plots.js"), plots, "utf-8");
-	await writeLatestRedirect(reportDir);
-	let server;
-	let closeServer;
-	if (options.openBrowser) {
-		const baseDir = dirname(reportDir);
-		const reportName = reportDir.split("/").pop();
-		const result = await startReportServer(baseDir, 7979, 7978, 7977);
-		server = result.server;
-		closeServer = () => result.server.close();
-		const openUrl = `http://localhost:${result.port}/${reportName}/`;
-		await open(openUrl);
-		console.log(`Report opened in browser: ${openUrl}`);
-	} else console.log(`Report saved to: ${reportDir}/`);
-	return {
-		reportDir,
-		server,
-		closeServer
-	};
-}
-/** Start HTTP server for report directory, trying fallback ports if needed */
-async function startReportServer(baseDir, ...ports) {
-	const mimeTypes = {
-		".html": "text/html",
-		".js": "application/javascript",
-		".css": "text/css",
-		".json": "application/json"
-	};
-	const server = createServer(async (req, res) => {
-		const url = req.url || "/";
-		const filePath = join(baseDir, url.endsWith("/") ? url + "index.html" : url);
-		try {
-			const content = await readFile(filePath);
-			const mime = mimeTypes[extname(filePath)] || "application/octet-stream";
-			res.setHeader("Content-Type", mime);
-			res.end(content);
-		} catch {
-			res.statusCode = 404;
-			res.end("Not found");
-		}
-	});
-	for (const port of ports) try {
-		return await tryListen(server, port);
-	} catch {}
-	return tryListen(server, 0);
-}
-/** Listen on a port, resolving with the actual port or rejecting on error */
-function tryListen(server, port) {
-	return new Promise((resolve, reject) => {
-		server.once("error", reject);
-		server.listen(port, () => {
-			server.removeListener("error", reject);
-			const addr = server.address();
-			resolve({
-				server,
-				port: typeof addr === "object" && addr ? addr.port : port
-			});
-		});
-	});
-}
-/** Create a timestamped report directory under ./bench-report/ */
-async function createReportDir() {
-	const base = "./bench-report";
-	await mkdir(base, { recursive: true });
-	return join(base, `report-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}`);
-}
-/** Read the pre-built browser plots bundle from dist/ */
-async function loadPlotsBundle() {
-	const thisDir = dirname(fileURLToPath(import.meta.url));
-	const builtPath = join(thisDir, "browser/index.js");
-	const devPath = join(thisDir, "../../dist/browser/index.js");
-	try {
-		return await readFile(builtPath, "utf-8");
-	} catch {}
-	return readFile(devPath, "utf-8");
-}
-/** Write an index.html in the parent dir that redirects to this report */
-async function writeLatestRedirect(reportDir) {
-	const baseDir = dirname(reportDir);
-	const reportName = reportDir.split("/").pop();
-	const html = `<!DOCTYPE html>
-<html><head>
-  <meta http-equiv="refresh" content="0; url=./${reportName}/">
-  <script>location.href = "./${reportName}/";<\/script>
-</head><body>
-  <a href="./${reportName}/">Latest report</a>
-</body></html>`;
-	await writeFile(join(baseDir, "index.html"), html, "utf-8");
-}
-
-//#endregion
-//#region src/matrix/MatrixFilter.ts
-/** Parse filter string: "case/variant", "case/", "/variant", or "case" */
-function parseMatrixFilter(filter) {
-	if (filter.includes("/")) {
-		const [casePart, variantPart] = filter.split("/", 2);
-		return {
-			case: casePart || void 0,
-			variant: variantPart || 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 = caseList && matrix.filteredCases ? caseList.filter((c) => matrix.filteredCases.includes(c)) : caseList ?? matrix.filteredCases;
-	const filteredVariants = variantList && matrix.filteredVariants ? variantList.filter((v) => matrix.filteredVariants.includes(v)) : variantList ?? matrix.filteredVariants;
-	return {
-		...matrix,
-		filteredCases,
-		filteredVariants
-	};
-}
-/** Get case IDs matching filter pattern */
-async function getFilteredCases(matrix, casePattern) {
-	if (!casePattern) return void 0;
-	const caseIds = matrix.casesModule ? (await loadCasesModule(matrix.casesModule)).cases : matrix.cases;
-	if (!caseIds) return ["default"];
-	const filtered = caseIds.filter((id) => matchPattern(id, casePattern));
-	if (filtered.length === 0) throw new Error(`No cases match filter: "${casePattern}"`);
-	return filtered;
-}
-/** Get variant IDs matching filter pattern */
-async function getFilteredVariants(matrix, variantPattern) {
-	if (!variantPattern) return void 0;
-	if (matrix.variants) {
-		const ids = Object.keys(matrix.variants).filter((id) => matchPattern(id, variantPattern));
-		if (ids.length === 0) throw new Error(`No variants match filter: "${variantPattern}"`);
-		return ids;
-	}
-	if (matrix.variantDir) {
-		const filtered = (await discoverVariants(matrix.variantDir)).filter((id) => matchPattern(id, variantPattern));
-		if (filtered.length === 0) throw new Error(`No variants match filter: "${variantPattern}"`);
-		return filtered;
-	}
-	throw new Error("BenchMatrix requires 'variants' or 'variantDir'");
-}
-/** Match id against pattern (case-insensitive substring) */
-function matchPattern(id, pattern) {
-	return id.toLowerCase().includes(pattern.toLowerCase());
-}
-
-//#endregion
-//#region src/table-util/ConvergenceFormatters.ts
-const { red } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? { red: (str) => str } : pico;
-const lowConfidence = 80;
-/** @return convergence percentage with color for low values */
-function formatConvergence(v) {
-	if (typeof v !== "number") return "—";
-	const pct = `${Math.round(v)}%`;
-	return v < lowConfidence ? red(pct) : pct;
-}
-
-//#endregion
-//#region src/StandardSections.ts
-/** Section: mean, p50, p99 timing */
-const timeSection = {
-	extract: (results) => ({
-		mean: results.time?.avg,
-		p50: results.time?.p50,
-		p99: results.time?.p99
-	}),
-	columns: () => [{
-		groupTitle: "time",
-		columns: [
-			{
-				key: "mean",
-				title: "mean",
-				formatter: timeMs,
-				comparable: true
-			},
-			{
-				key: "p50",
-				title: "p50",
-				formatter: timeMs,
-				comparable: true
-			},
-			{
-				key: "p99",
-				title: "p99",
-				formatter: timeMs,
-				comparable: true
-			}
-		]
-	}]
-};
-/** Section: GC time as fraction of total benchmark time (Node performance hooks) */
-const gcSection = {
-	extract: (results) => {
-		const { nodeGcTime, time, samples } = results;
-		if (!nodeGcTime || !time?.avg) return { gc: void 0 };
-		const totalBenchTime = time.avg * samples.length;
-		if (totalBenchTime <= 0) return { gc: void 0 };
-		const gcTime = nodeGcTime.inRun / totalBenchTime;
-		return { gc: gcTime <= 1 ? gcTime : void 0 };
-	},
-	columns: () => [{
-		groupTitle: "gc",
-		columns: [{
-			key: "gc",
-			title: "mean",
-			formatter: percent,
-			comparable: true
-		}]
-	}]
-};
-/** Section: detailed GC stats from --trace-gc-nvp (allocation, promotion, pauses) */
-const gcStatsSection = {
-	extract: (results) => {
-		const { gcStats, samples } = results;
-		if (!gcStats) return {};
-		const iterations = samples.length || 1;
-		const { totalAllocated, totalPromoted } = gcStats;
-		const promoPercent = totalAllocated && totalAllocated > 0 ? (totalPromoted ?? 0) / totalAllocated : void 0;
-		return {
-			allocPerIter: totalAllocated != null ? totalAllocated / iterations : void 0,
-			collected: gcStats.totalCollected || void 0,
-			scavenges: gcStats.scavenges,
-			fullGCs: gcStats.markCompacts,
-			promoPercent,
-			pausePerIter: gcStats.gcPauseTime / iterations
-		};
-	},
-	columns: () => [{
-		groupTitle: "gc",
-		columns: [
-			{
-				key: "allocPerIter",
-				title: "alloc/iter",
-				formatter: formatBytes
-			},
-			{
-				key: "collected",
-				title: "collected",
-				formatter: formatBytes
-			},
-			{
-				key: "scavenges",
-				title: "scav",
-				formatter: integer
-			},
-			{
-				key: "fullGCs",
-				title: "full",
-				formatter: integer
-			},
-			{
-				key: "promoPercent",
-				title: "promo%",
-				formatter: percent
-			},
-			{
-				key: "pausePerIter",
-				title: "pause/iter",
-				formatter: timeMs
-			}
-		]
-	}]
-};
-/** Browser GC section: only fields available from CDP tracing */
-const browserGcStatsSection = {
-	extract: gcStatsSection.extract,
-	columns: () => [{
-		groupTitle: "gc",
-		columns: [
-			{
-				key: "collected",
-				title: "collected",
-				formatter: formatBytes
-			},
-			{
-				key: "scavenges",
-				title: "scav",
-				formatter: integer
-			},
-			{
-				key: "fullGCs",
-				title: "full",
-				formatter: integer
-			},
-			{
-				key: "pausePerIter",
-				title: "pause",
-				formatter: timeMs
-			}
-		]
-	}]
-};
-/** Section: CPU L1 cache miss rate and stall rate (requires @mitata/counters) */
-const cpuSection = {
-	extract: (results) => ({
-		cpuCacheMiss: results.cpuCacheMiss,
-		cpuStall: results.cpuStall
-	}),
-	columns: () => [{
-		groupTitle: "cpu",
-		columns: [{
-			key: "cpuCacheMiss",
-			title: "L1 miss",
-			formatter: percent
-		}, {
-			key: "cpuStall",
-			title: "stalls",
-			formatter: percentPrecision(2)
-		}]
-	}]
-};
-/** Section: number of sample iterations */
-const runsSection = {
-	extract: (results) => ({ runs: results.samples.length }),
-	columns: () => [{ columns: [{
-		key: "runs",
-		title: "runs",
-		formatter: integer
-	}] }]
-};
-/** Section: total sampling duration in seconds (brackets if >= 30s) */
-const totalTimeSection = {
-	extract: (results) => ({ totalTime: results.totalTime }),
-	columns: () => [{ columns: [{
-		key: "totalTime",
-		title: "time",
-		formatter: (v) => {
-			if (typeof v !== "number") return "";
-			return v >= 30 ? `[${v.toFixed(1)}s]` : `${v.toFixed(1)}s`;
-		}
-	}] }]
-};
-/** Section: median, mean, p99, and convergence for adaptive mode */
-const adaptiveSection = {
-	extract: (results) => ({
-		median: results.time?.p50,
-		mean: results.time?.avg,
-		p99: results.time?.p99,
-		convergence: results.convergence?.confidence
-	}),
-	columns: () => [{
-		groupTitle: "time",
-		columns: [
-			{
-				key: "median",
-				title: "median",
-				formatter: timeMs,
-				comparable: true
-			},
-			{
-				key: "mean",
-				title: "mean",
-				formatter: timeMs,
-				comparable: true
-			},
-			{
-				key: "p99",
-				title: "p99",
-				formatter: timeMs
-			}
-		]
-	}, { columns: [{
-		key: "convergence",
-		title: "conv%",
-		formatter: formatConvergence
-	}] }]
-};
-/** Build generic sections based on CLI flags */
-function buildGenericSections(args) {
-	const sections = [];
-	if (args["gc-stats"]) sections.push(gcStatsSection);
-	sections.push(runsSection);
-	return sections;
-}
-/** Section: V8 optimization tier distribution and deopt count */
-const optSection = {
-	extract: (results) => {
-		const opt = results.optStatus;
-		if (!opt) return {};
-		const total = Object.values(opt.byTier).reduce((s, t) => s + t.count, 0);
-		return {
-			tiers: Object.entries(opt.byTier).sort((a, b) => b[1].count - a[1].count).map(([name, t]) => `${name}:${(t.count / total * 100).toFixed(0)}%`).join(" "),
-			deopt: opt.deoptCount > 0 ? opt.deoptCount : void 0
-		};
-	},
-	columns: () => [{
-		groupTitle: "v8 opt",
-		columns: [{
-			key: "tiers",
-			title: "tiers",
-			formatter: (v) => typeof v === "string" ? v : ""
-		}, {
-			key: "deopt",
-			title: "deopt",
-			formatter: (v) => typeof v === "number" ? String(v) : ""
-		}]
-	}]
-};
-
-//#endregion
-//#region src/matrix/MatrixReport.ts
-/** Format matrix results as one table per case */
-function reportMatrixResults(results, options) {
-	const tables = buildCaseTables(results, options);
-	return [`Matrix: ${results.name}`, ...tables].join("\n\n");
-}
-/** Build one table for each case showing all variants */
-function buildCaseTables(results, options) {
-	if (results.variants.length === 0) return [];
-	return results.variants[0].cases.map((c) => c.caseId).map((caseId) => buildCaseTable(results, caseId, options));
-}
-/** Build table for a single case showing all variants */
-function buildCaseTable(results, caseId, options) {
-	const caseTitle = formatCaseTitle(results, caseId);
-	if (options?.sections?.length) return buildSectionTable(results, caseId, options, caseTitle);
-	const rows = buildCaseRows(results, caseId, options?.extraColumns);
-	return `${caseTitle}\n${buildTable(buildColumns(rows.some((r) => r.diffCI), options), [{ results: rows }])}`;
-}
-/** Build table using ResultsMapper sections */
-function buildSectionTable(results, caseId, options, caseTitle) {
-	const sections = options.sections;
-	const variantTitle = options.variantTitle ?? "name";
-	const rows = [];
-	let hasBaseline = false;
-	for (const variant of results.variants) {
-		const caseResult = variant.cases.find((c) => c.caseId === caseId);
-		if (!caseResult) continue;
-		const row = { name: truncate(variant.id, 25) };
-		for (const section of sections) Object.assign(row, section.extract(caseResult.measured, caseResult.metadata));
-		if (caseResult.baseline) {
-			hasBaseline = true;
-			const { samples: base } = caseResult.baseline;
-			row.diffCI = bootstrapDifferenceCI(base, caseResult.measured.samples);
-		}
-		rows.push(row);
-	}
-	return `${caseTitle}\n${buildTable(buildSectionColumns(sections, variantTitle, hasBaseline), [{ results: rows }])}`;
-}
-/** Build column groups from ResultsMapper sections */
-function buildSectionColumns(sections, variantTitle, hasBaseline) {
-	const nameCol = { columns: [{
-		key: "name",
-		title: variantTitle
-	}] };
-	const sectionColumns = sections.flatMap((s) => s.columns());
-	return [nameCol, ...hasBaseline ? injectDiffColumns(sectionColumns) : sectionColumns];
-}
-/** Build rows for all variants for a given case */
-function buildCaseRows(results, caseId, extraColumns) {
-	return results.variants.flatMap((variant) => {
-		const caseResult = variant.cases.find((c) => c.caseId === caseId);
-		return caseResult ? [buildRow(variant.id, caseResult, extraColumns)] : [];
-	});
-}
-/** Build a single row from case result */
-function buildRow(variantId, caseResult, extraColumns) {
-	const { measured, baseline } = caseResult;
-	const samples = measured.samples;
-	const time = measured.time?.avg ?? average(samples);
-	const row = {
-		name: truncate(variantId, 25),
-		time,
-		samples: samples.length
-	};
-	if (baseline) row.diffCI = bootstrapDifferenceCI(baseline.samples, samples);
-	if (extraColumns) for (const col of extraColumns) row[col.key] = col.extract(caseResult);
-	return row;
-}
-/** Build column configuration */
-function buildColumns(hasBaseline, options) {
-	const groups = [{ columns: [{
-		key: "name",
-		title: options?.variantTitle ?? "variant"
-	}] }, { columns: [{
-		key: "time",
-		title: "time",
-		formatter: duration
-	}, ...hasBaseline ? [{
-		key: "diffCI",
-		title: "Δ% CI",
-		formatter: formatDiff
-	}] : []] }];
-	const extraColumns = options?.extraColumns;
-	if (extraColumns?.length) {
-		const byGroup = /* @__PURE__ */ new Map();
-		for (const col of extraColumns) {
-			const group = byGroup.get(col.groupTitle) ?? [];
-			group.push(col);
-			byGroup.set(col.groupTitle, group);
-		}
-		for (const [groupTitle, cols] of byGroup) groups.push({
-			groupTitle,
-			columns: cols.map((col) => ({
-				key: col.key,
-				title: col.title,
-				formatter: col.formatter ?? String
-			}))
-		});
-	}
-	return groups;
-}
-/** Format diff with CI, or "baseline" marker */
-function formatDiff(value) {
-	if (!value) return null;
-	return formatDiffWithCI(value);
-}
-/** Format case title with metadata if available */
-function formatCaseTitle(results, caseId) {
-	const metadata = (results.variants[0]?.cases.find((c) => c.caseId === caseId))?.metadata;
-	if (metadata && Object.keys(metadata).length > 0) return `${caseId} (${Object.entries(metadata).map(([k, v]) => `${v} ${k}`).join(", ")})`;
-	return caseId;
-}
-/** GC statistics columns - derived from gcStatsSection for consistency */
-const gcStatsColumns = gcStatsSection.columns()[0].columns.map((col) => ({
-	key: col.key,
-	title: col.title,
-	groupTitle: "GC",
-	extract: (r) => gcStatsSection.extract(r.measured)[col.key],
-	formatter: (v) => col.formatter?.(v) ?? "-"
-}));
-/** Format bytes with fallback to "-" for missing values */
-function formatBytesOrDash(value) {
-	return formatBytes(value) ?? "-";
-}
-/** GC pause time column */
-const gcPauseColumn = {
-	key: "gcPause",
-	title: "pause",
-	groupTitle: "GC",
-	extract: (r) => r.measured.gcStats?.gcPauseTime,
-	formatter: (v) => v != null ? `${v.toFixed(1)}ms` : "-"
-};
-/** Heap sampling total bytes column */
-const heapTotalColumn = {
-	key: "heapTotal",
-	title: "heap",
-	extract: (r) => {
-		const profile = r.measured.heapProfile;
-		if (!profile?.head) return void 0;
-		return totalProfileBytes(profile);
-	},
-	formatter: formatBytesOrDash
-};
-
-//#endregion
-//#region src/cli/FilterBenchmarks.ts
-/** Filter benchmarks by name pattern */
-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);
-	validateFilteredSuite(groups, filter);
-	return {
-		name: suite.name,
-		groups
-	};
-}
-/** Create regex from filter (literal unless regex-like) */
-function createFilterRegex(filter) {
-	if (filter.startsWith("/") && filter.endsWith("/") || filter.includes("*") || filter.includes("?") || filter.includes("[") || filter.includes("|") || filter.startsWith("^") || filter.endsWith("$")) {
-		const pattern = filter.startsWith("/") && filter.endsWith("/") ? filter.slice(1, -1) : filter;
-		try {
-			return new RegExp(pattern, "i");
-		} catch {
-			return new RegExp(escapeRegex(filter), "i");
-		}
-	}
-	return new RegExp("^" + escapeRegex(filter), "i");
-}
-/** Strip case suffix like " [large]" from benchmark name for filtering */
-function stripCaseSuffix(name) {
-	return name.replace(/ \[.*?\]$/, "");
-}
-/** Escape regex special characters */
-function escapeRegex(str) {
-	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-/** Ensure at least one benchmark matches filter */
-function validateFilteredSuite(groups, filter) {
-	if (groups.every((g) => g.benchmarks.length === 0)) throw new Error(`No benchmarks match filter: "${filter}"`);
-}
-
-//#endregion
-//#region src/cli/RunBenchCLI.ts
-/** Validate CLI argument combinations */
-function validateArgs(args) {
-	if (args["gc-stats"] && !args.worker && !args.url) throw new Error("--gc-stats requires worker mode (the default). Remove --no-worker flag.");
-}
-/** Warn about Node-only flags that are ignored in browser mode. */
-function warnBrowserFlags(args) {
-	const ignored = [];
-	if (!args.worker) ignored.push("--no-worker");
-	if (args.cpu) ignored.push("--cpu");
-	if (args["trace-opt"]) ignored.push("--trace-opt");
-	if (args.collect) ignored.push("--collect");
-	if (args.adaptive) ignored.push("--adaptive");
-	if (args.batches > 1) ignored.push("--batches");
-	if (ignored.length) console.warn(yellow(`Ignored in browser mode: ${ignored.join(", ")}`));
-}
-/** Parse CLI with custom configuration */
-function parseBenchArgs(configureArgs) {
-	return parseCliArgs(hideBin(process.argv), configureArgs);
-}
-/** Run suite with CLI arguments */
-async function runBenchmarks(suite, args) {
-	validateArgs(args);
-	const { filter, worker: useWorker, batches = 1 } = args;
-	const options = cliToRunnerOptions(args);
-	return runSuite({
-		suite: filterBenchmarks(suite, filter),
-		runner: "basic",
-		options,
-		useWorker,
-		batches
-	});
-}
-/** Execute all groups in suite */
-async function runSuite(params) {
-	const { suite, runner, options, useWorker, batches } = params;
-	const results = [];
-	for (const group of suite.groups) results.push(await runGroup(group, runner, options, useWorker, batches));
-	return results;
-}
-/** Execute group with shared setup, optionally batching to reduce ordering bias */
-async function runGroup(group, runner, options, useWorker, batches = 1) {
-	const { name, benchmarks, baseline, setup, metadata } = group;
-	const setupParams = await setup?.();
-	validateBenchmarkParameters(group);
-	const runParams = {
-		runner,
-		options,
-		useWorker,
-		params: setupParams,
-		metadata
-	};
-	if (batches === 1) return runSingleBatch(name, benchmarks, baseline, runParams);
-	return runMultipleBatches(name, benchmarks, baseline, runParams, batches);
-}
-/** Run benchmarks in a single batch */
-async function runSingleBatch(name, benchmarks, baseline, runParams) {
-	const baselineReport = baseline ? await runSingleBenchmark(baseline, runParams) : void 0;
-	return {
-		name,
-		reports: await serialMap(benchmarks, (b) => runSingleBenchmark(b, runParams)),
-		baseline: baselineReport
-	};
-}
-/** Run benchmarks in multiple batches, alternating order to reduce bias */
-async function runMultipleBatches(name, benchmarks, baseline, runParams, batches) {
-	const timePerBatch = (runParams.options.maxTime || 5e3) / batches;
-	const batchParams = {
-		...runParams,
-		options: {
-			...runParams.options,
-			maxTime: timePerBatch
-		}
-	};
-	const baselineBatches = [];
-	const benchmarkBatches = /* @__PURE__ */ new Map();
-	for (let i = 0; i < batches; i++) await runBatchIteration(benchmarks, baseline, batchParams, i % 2 === 1, baselineBatches, benchmarkBatches);
-	const meta = runParams.metadata;
-	return mergeBatchResults(name, benchmarks, baseline, baselineBatches, benchmarkBatches, meta);
-}
-/** Run one batch iteration in either order */
-async function runBatchIteration(benchmarks, baseline, runParams, reverseOrder, baselineBatches, benchmarkBatches) {
-	const runBaseline = async () => {
-		if (baseline) {
-			const r = await runSingleBenchmark(baseline, runParams);
-			baselineBatches.push(r.measuredResults);
-		}
-	};
-	const runBenches = async () => {
-		for (const b of benchmarks) {
-			const r = await runSingleBenchmark(b, runParams);
-			appendToMap(benchmarkBatches, b.name, r.measuredResults);
-		}
-	};
-	if (reverseOrder) {
-		await runBenches();
-		await runBaseline();
-	} else {
-		await runBaseline();
-		await runBenches();
-	}
-}
-/** Merge batch results into final ReportGroup */
-function mergeBatchResults(name, benchmarks, baseline, baselineBatches, benchmarkBatches, metadata) {
-	const mergedBaseline = baseline ? {
-		name: baseline.name,
-		measuredResults: mergeResults(baselineBatches),
-		metadata
-	} : void 0;
-	return {
-		name,
-		reports: benchmarks.map((b) => ({
-			name: b.name,
-			measuredResults: mergeResults(benchmarkBatches.get(b.name) || []),
-			metadata
-		})),
-		baseline: mergedBaseline
-	};
-}
-/** Run single benchmark and create report */
-async function runSingleBenchmark(spec, runParams) {
-	const { runner, options, useWorker, params, metadata } = runParams;
-	const [result] = await runBenchmark({
-		spec,
-		runner,
-		options,
-		useWorker,
-		params
-	});
-	return {
-		name: spec.name,
-		measuredResults: result,
-		metadata
-	};
-}
-/** Warn if parameterized benchmarks lack setup */
-function validateBenchmarkParameters(group) {
-	const { name, setup, benchmarks, baseline } = group;
-	if (setup) return;
-	const allBenchmarks = baseline ? [...benchmarks, baseline] : benchmarks;
-	for (const benchmark of allBenchmarks) if (benchmark.fn.length > 0) console.warn(`Benchmark "${benchmark.name}" in group "${name}" expects parameters but no setup() provided.`);
-}
-/** Merge multiple batch results into a single MeasuredResults */
-function mergeResults(results) {
-	if (results.length === 0) throw new Error("Cannot merge empty results array");
-	if (results.length === 1) return results[0];
-	const allSamples = results.flatMap((r) => r.samples);
-	const allWarmup = results.flatMap((r) => r.warmupSamples || []);
-	const time = computeStats(allSamples);
-	let offset = 0;
-	const allPausePoints = results.flatMap((r) => {
-		const pts = (r.pausePoints ?? []).map((p) => ({
-			sampleIndex: p.sampleIndex + offset,
-			durationMs: p.durationMs
-		}));
-		offset += r.samples.length;
-		return pts;
-	});
-	return {
-		name: results[0].name,
-		samples: allSamples,
-		warmupSamples: allWarmup.length ? allWarmup : void 0,
-		time,
-		totalTime: results.reduce((sum, r) => sum + (r.totalTime || 0), 0),
-		pausePoints: allPausePoints.length ? allPausePoints : void 0
-	};
-}
-function appendToMap(map, key, value) {
-	if (!map.has(key)) map.set(key, []);
-	map.get(key).push(value);
-}
-/** Generate table with standard sections */
-function defaultReport(groups, args) {
-	const { adaptive, "gc-stats": gcStats, "trace-opt": traceOpt } = args;
-	const hasCpu = hasField(groups, "cpu");
-	const hasOpt = hasField(groups, "optStatus");
-	return reportResults(groups, buildReportSections(adaptive, gcStats, hasCpu, traceOpt && hasOpt));
-}
-/** Build report sections based on CLI options */
-function buildReportSections(adaptive, gcStats, hasCpuData, hasOptData) {
-	const sections = adaptive ? [adaptiveSection, totalTimeSection] : [timeSection];
-	if (gcStats) sections.push(gcStatsSection);
-	if (hasCpuData) sections.push(cpuSection);
-	if (hasOptData) sections.push(optSection);
-	sections.push(runsSection);
-	return sections;
-}
-/** Run benchmarks, display table, and optionally generate HTML report */
-async function benchExports(suite, args) {
-	const results = await runBenchmarks(suite, args);
-	const report = defaultReport(results, args);
-	console.log(report);
-	await finishReports(results, args, suite.name);
-}
-/** Run browser profiling via Playwright + CDP, report with standard pipeline */
-async function browserBenchExports(args) {
-	warnBrowserFlags(args);
-	let profileBrowser;
-	try {
-		({profileBrowser} = await import("./BrowserHeapSampler-DCeL42RE.mjs"));
-	} catch {
-		throw new Error("playwright is required for browser benchmarking (--url).\n\nQuick start:  npx benchforge-browser --url <your-url>\n\nOr install manually:\n  npm install playwright\n  npx playwright install chromium");
-	}
-	const url = args.url;
-	const { iterations, time } = args;
-	const result = await profileBrowser({
-		url,
-		heapSample: args["heap-sample"],
-		heapOptions: {
-			samplingInterval: args["heap-interval"],
-			stackDepth: args["heap-depth"]
-		},
-		headless: args.headless,
-		chromeArgs: args["chrome-args"]?.flatMap((a) => a.split(/\s+/)).map(stripQuotes).filter(Boolean),
-		timeout: args.timeout,
-		gcStats: args["gc-stats"],
-		maxTime: iterations ? Number.MAX_SAFE_INTEGER : time * 1e3,
-		maxIterations: iterations
-	});
-	const results = browserResultGroups(new URL(url).pathname.split("/").pop() || "browser", result);
-	printBrowserReport(result, results, args);
-	await exportReports({
-		results,
-		args
-	});
-}
-/** Print browser benchmark tables and heap reports */
-function printBrowserReport(result, results, args) {
-	const hasSamples = result.samples && result.samples.length > 0;
-	const sections = [];
-	if (hasSamples || result.wallTimeMs != null) sections.push(timeSection);
-	if (result.gcStats) sections.push(browserGcStatsSection);
-	if (hasSamples || result.wallTimeMs != null) sections.push(runsSection);
-	if (sections.length > 0) console.log(reportResults(results, sections));
-	if (result.heapProfile) printHeapReports(results, {
-		...cliHeapReportOptions(args),
-		isUserCode: isBrowserUserCode
-	});
-}
-/** Wrap browser profile result as ReportGroup[] for the standard pipeline */
-function browserResultGroups(name, result) {
-	const { gcStats, heapProfile } = result;
-	let measured;
-	if (result.samples && result.samples.length > 0) {
-		const { samples } = result;
-		const totalTime = result.wallTimeMs ? result.wallTimeMs / 1e3 : void 0;
-		measured = {
-			name,
-			samples,
-			time: computeStats(samples),
-			totalTime,
-			gcStats,
-			heapProfile
-		};
-	} else {
-		const wallMs = result.wallTimeMs ?? 0;
-		measured = {
-			name,
-			samples: [wallMs],
-			time: {
-				min: wallMs,
-				max: wallMs,
-				avg: wallMs,
-				p50: wallMs,
-				p75: wallMs,
-				p99: wallMs,
-				p999: wallMs
-			},
-			gcStats,
-			heapProfile
-		};
-	}
-	return [{
-		name,
-		reports: [{
-			name,
-			measuredResults: measured
-		}]
-	}];
-}
-/** Print heap allocation reports for benchmarks with heap profiles */
-function printHeapReports(groups, options) {
-	for (const group of groups) {
-		const allReports = group.baseline ? [...group.reports, group.baseline] : group.reports;
-		for (const report of allReports) {
-			const { heapProfile } = report.measuredResults;
-			if (!heapProfile) continue;
-			console.log(dim(`\n─── Heap profile: ${report.name} ───`));
-			const totalAll = totalProfileBytes(heapProfile);
-			const sites = flattenProfile(heapProfile);
-			const userSites = filterSites(sites, options.isUserCode);
-			const totalUserCode = userSites.reduce((sum, s) => sum + s.bytes, 0);
-			const aggregated = aggregateSites(options.userOnly ? userSites : sites);
-			const extra = {
-				totalAll,
-				totalUserCode,
-				sampleCount: heapProfile.samples?.length
-			};
-			console.log(formatHeapReport(aggregated, {
-				...options,
-				...extra
-			}));
-		}
-	}
-}
-/** Run benchmarks and display table. Suite is optional with --url (browser mode). */
-async function runDefaultBench(suite, configureArgs) {
-	const args = parseBenchArgs(configureArgs);
-	if (args.url) await browserBenchExports(args);
-	else if (suite) await benchExports(suite, args);
-	else if (args.file) await fileBenchExports(args.file, args);
-	else throw new Error("Provide a benchmark file, --url for browser mode, or pass a BenchSuite directly.");
-}
-/** Import a file and run it as a benchmark based on what it exports */
-async function fileBenchExports(filePath, args) {
-	const candidate = (await import(pathToFileURL(resolve(filePath)).href)).default;
-	if (candidate && Array.isArray(candidate.groups)) await benchExports(candidate, args);
-	else if (typeof candidate === "function") {
-		const name = basename(filePath).replace(/\.[^.]+$/, "");
-		await benchExports({
-			name,
-			groups: [{
-				name,
-				benchmarks: [{
-					name,
-					fn: candidate
-				}]
-			}]
-		}, args);
-	}
-}
-/** Convert CLI args to runner options */
-function cliToRunnerOptions(args) {
-	const { profile, collect, iterations } = args;
-	if (profile) return {
-		maxIterations: iterations ?? 1,
-		warmupTime: 0,
-		collect
-	};
-	if (args.adaptive) return createAdaptiveOptions(args);
-	return {
-		maxTime: iterations ? Number.POSITIVE_INFINITY : args.time * 1e3,
-		maxIterations: iterations,
-		...cliCommonOptions(args)
-	};
-}
-/** Create options for adaptive mode */
-function createAdaptiveOptions(args) {
-	return {
-		minTime: (args["min-time"] ?? 1) * 1e3,
-		maxTime: defaultAdaptiveMaxTime * 1e3,
-		targetConfidence: args.convergence,
-		adaptive: true,
-		...cliCommonOptions(args)
-	};
-}
-/** Runner/matrix options shared across all CLI modes */
-function cliCommonOptions(args) {
-	const { collect, cpu, warmup } = args;
-	const { "trace-opt": traceOpt, "skip-settle": noSettle } = args;
-	const { "pause-first": pauseFirst, "pause-interval": pauseInterval } = args;
-	const { "pause-duration": pauseDuration, "gc-stats": gcStats } = args;
-	const { "heap-sample": heapSample, "heap-interval": heapInterval } = args;
-	const { "heap-depth": heapDepth } = args;
-	return {
-		collect,
-		cpuCounters: cpu,
-		warmup,
-		traceOpt,
-		noSettle,
-		pauseFirst,
-		pauseInterval,
-		pauseDuration,
-		gcStats,
-		heapSample,
-		heapInterval,
-		heapDepth
-	};
-}
-const { yellow, dim } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? {
-	yellow: (s) => s,
-	dim: (s) => s
-} : pico;
-/** Log V8 optimization tier distribution and deoptimizations */
-function reportOptStatus(groups) {
-	const optData = groups.flatMap(({ reports, baseline }) => {
-		return (baseline ? [...reports, baseline] : reports).filter((r) => r.measuredResults.optStatus).map((r) => ({
-			name: r.name,
-			opt: r.measuredResults.optStatus,
-			samples: r.measuredResults.samples.length
-		}));
-	});
-	if (optData.length === 0) return;
-	console.log(dim("\nV8 optimization:"));
-	for (const { name, opt, samples } of optData) {
-		const total = Object.values(opt.byTier).reduce((s, t) => s + t.count, 0);
-		const tierParts = Object.entries(opt.byTier).sort((a, b) => b[1].count - a[1].count).map(([tier, info]) => `${tier} ${(info.count / total * 100).toFixed(0)}%`).join(", ");
-		console.log(`  ${name}: ${tierParts} ${dim(`(${samples} samples)`)}`);
-	}
-	const totalDeopts = optData.reduce((s, d) => s + d.opt.deoptCount, 0);
-	if (totalDeopts > 0) console.log(yellow(`  ⚠ ${totalDeopts} deoptimization${totalDeopts > 1 ? "s" : ""} detected`));
-}
-/** @return true if any result has the specified field with a defined value */
-function hasField(results, field) {
-	return results.some(({ reports, baseline }) => {
-		return (baseline ? [...reports, baseline] : reports).some(({ measuredResults }) => measuredResults[field] !== void 0);
-	});
-}
-/** Print heap reports (if enabled) and export results */
-async function finishReports(results, args, suiteName, exportOptions) {
-	if (args["heap-sample"]) printHeapReports(results, cliHeapReportOptions(args));
-	await exportReports({
-		results,
-		args,
-		suiteName,
-		...exportOptions
-	});
-}
-/** Export reports (HTML, JSON, Perfetto) based on CLI args */
-async function exportReports(options) {
-	const { results, args, sections, suiteName } = options;
-	const { currentVersion, baselineVersion } = options;
-	const openInBrowser = args.html && !args["export-html"];
-	let closeServer;
-	if (args.html || args["export-html"]) closeServer = (await generateHtmlReport(prepareHtmlData(results, {
-		cliArgs: args,
-		sections,
-		currentVersion,
-		baselineVersion
-	}), {
-		openBrowser: openInBrowser,
-		outputPath: args["export-html"]
-	})).closeServer;
-	if (args.json) await exportBenchmarkJson(results, args.json, args, suiteName);
-	if (args.perfetto) exportPerfettoTrace(results, args.perfetto, args);
-	if (openInBrowser) {
-		await waitForCtrlC();
-		closeServer?.();
-	}
-}
-/** Wait for Ctrl+C before exiting */
-function waitForCtrlC() {
-	return new Promise((resolve) => {
-		console.log(dim("\nPress Ctrl+C to exit"));
-		process.on("SIGINT", () => {
-			console.log();
-			resolve();
-		});
-	});
-}
-/** Run matrix suite with CLI arguments.
-*  no options ==> defaultCases/defaultVariants, --filter ==> subset of defaults,
-*  --all --filter ==> subset of all, --all ==> all cases/variants */
-async function runMatrixSuite(suite, args) {
-	validateArgs(args);
-	const filter = args.filter ? parseMatrixFilter(args.filter) : void 0;
-	const options = cliToMatrixOptions(args);
-	const results = [];
-	for (const matrix of suite.matrices) {
-		const casesModule = matrix.casesModule ? await loadCasesModule(matrix.casesModule) : void 0;
-		let filtered = matrix;
-		if (!args.all && casesModule) filtered = {
-			...matrix,
-			filteredCases: casesModule.defaultCases,
-			filteredVariants: casesModule.defaultVariants
-		};
-		if (filter) filtered = await filterMatrix(filtered, filter);
-		const { filteredCases, filteredVariants } = filtered;
-		results.push(await runMatrix(filtered, {
-			...options,
-			filteredCases,
-			filteredVariants
-		}));
-	}
-	return results;
-}
-/** Convert CLI args to matrix run options */
-function cliToMatrixOptions(args) {
-	const { time, iterations, worker } = args;
-	return {
-		iterations,
-		maxTime: iterations ? void 0 : time * 1e3,
-		useWorker: worker,
-		...cliCommonOptions(args)
-	};
-}
-/** Generate report for matrix results. Uses same sections as regular benchmarks. */
-function defaultMatrixReport(results, reportOptions, args) {
-	const options = args ? mergeMatrixDefaults(reportOptions, args, results) : reportOptions;
-	return results.map((r) => reportMatrixResults(r, options)).join("\n\n");
-}
-/** @return HeapReportOptions from CLI args */
-function cliHeapReportOptions(args) {
-	return {
-		topN: args["heap-rows"],
-		stackDepth: args["heap-stack"],
-		verbose: args["heap-verbose"],
-		userOnly: args["heap-user-only"]
-	};
-}
-/** Apply default sections and extra columns for matrix reports */
-function mergeMatrixDefaults(reportOptions, args, results) {
-	const result = { ...reportOptions };
-	if (!result.sections?.length) {
-		const groups = matrixToReportGroups(results);
-		result.sections = buildReportSections(args.adaptive, args["gc-stats"], hasField(groups, "cpu"), args["trace-opt"] && hasField(groups, "optStatus"));
-	}
-	return result;
-}
-/** Run matrix suite with full CLI handling (parse, run, report, export) */
-async function runDefaultMatrixBench(suite, configureArgs, reportOptions) {
-	await matrixBenchExports(suite, parseBenchArgs(configureArgs), reportOptions);
-}
-/** Convert MatrixResults to ReportGroup[] for export compatibility */
-function matrixToReportGroups(results) {
-	return results.flatMap((matrix) => matrix.variants.flatMap((variant) => variant.cases.map((c) => {
-		const { metadata } = c;
-		const report = {
-			name: variant.id,
-			measuredResults: c.measured,
-			metadata
-		};
-		const baseline = c.baseline ? {
-			name: `${variant.id} (baseline)`,
-			measuredResults: c.baseline,
-			metadata
-		} : void 0;
-		return {
-			name: `${variant.id} / ${c.caseId}`,
-			reports: [report],
-			baseline
-		};
-	})));
-}
-/** Strip surrounding quotes from a chrome arg token.
-*
-* (Needed because --chrome-args values pass through yargs and spawn() without
-* shell processing, so literal quote characters reach Chrome/V8 unrecognized.)
-*/
-function stripQuotes(s) {
-	return s.replace(/^(['"])(.*)\1$/s, "$2").replace(/^(-[^=]+=)(['"])(.*)\2$/s, "$1$3");
-}
-/** Sequential map - like Promise.all(arr.map(fn)) but runs one at a time */
-async function serialMap(arr, fn) {
-	const results = [];
-	for (const item of arr) results.push(await fn(item));
-	return results;
-}
-/** Run matrix benchmarks, display table, and generate exports */
-async function matrixBenchExports(suite, args, reportOptions, exportOptions) {
-	const results = await runMatrixSuite(suite, args);
-	const report = defaultMatrixReport(results, reportOptions, args);
-	console.log(report);
-	await finishReports(matrixToReportGroups(results), args, suite.name, exportOptions);
-}
-
-//#endregion
-//#region src/GitUtils.ts
-/** Get current git version info. For dirty repos, uses most recent modified file date. */
-function getCurrentGitVersion() {
-	try {
-		const exec = (cmd) => execSync(cmd, { encoding: "utf-8" }).trim();
-		const hash = exec("git rev-parse --short HEAD");
-		const commitDate = exec("git log -1 --format=%aI");
-		const dirty = exec("git status --porcelain").length > 0;
-		return {
-			hash,
-			date: dirty ? getMostRecentModifiedDate(".") ?? commitDate : commitDate,
-			dirty
-		};
-	} catch {
-		return;
-	}
-}
-/** Read baseline version from .baseline-version file */
-function getBaselineVersion(baselineDir = "_baseline") {
-	const versionFile = join(baselineDir, ".baseline-version");
-	if (!existsSync(versionFile)) return void 0;
-	try {
-		const content = readFileSync(versionFile, "utf-8");
-		const data = JSON.parse(content);
-		return {
-			hash: data.hash,
-			date: data.date
-		};
-	} catch {
-		return;
-	}
-}
-/** Format git version for display: "abc1234 (Jan 9, 2026, 3:45 PM)" or "abc1234*" if dirty */
-function formatGitVersion(version) {
-	return `${version.dirty ? `${version.hash}*` : version.hash} (${formatDateWithTimezone(version.date)})`;
-}
-/** Get most recent modified file date in a directory (for dirty repos) */
-function getMostRecentModifiedDate(dir) {
-	try {
-		const modifiedFiles = execSync("git status --porcelain", {
-			encoding: "utf-8",
-			cwd: dir
-		}).trim().split("\n").filter((line) => line.length > 0).map((line) => line.slice(3));
-		if (modifiedFiles.length === 0) return void 0;
-		let mostRecent = 0;
-		for (const file of modifiedFiles) try {
-			const filePath = join(dir, file);
-			if (!existsSync(filePath)) continue;
-			const mtime = statSync(filePath).mtimeMs;
-			if (mtime > mostRecent) mostRecent = mtime;
-		} catch {}
-		return mostRecent > 0 ? new Date(mostRecent).toISOString() : void 0;
-	} catch {
-		return;
-	}
-}
-
-//#endregion
-export { timeSection as A, parseCliArgs as B, adaptiveSection as C, gcStatsSection as D, gcSection as E, generateHtmlReport as F, truncate as G, formatBytes as H, formatDateWithTimezone as I, loadCaseData as J, isStatefulVariant as K, prepareHtmlData as L, formatConvergence as M, filterMatrix as N, optSection as O, parseMatrixFilter as P, exportPerfettoTrace as R, reportMatrixResults as S, cpuSection as T, integer as U, reportResults as V, timeMs as W, loadCasesModule as Y, runDefaultMatrixBench as _, cliToMatrixOptions as a, gcStatsColumns as b, exportReports as c, matrixToReportGroups as d, parseBenchArgs as f, runDefaultBench as g, runBenchmarks as h, benchExports as i, totalTimeSection as j, runsSection as k, hasField as l, reportOptStatus as m, getBaselineVersion as n, defaultMatrixReport as o, printHeapReports as p, runMatrix as q, getCurrentGitVersion as r, defaultReport as s, formatGitVersion as t, matrixBenchExports as u, runMatrixSuite as v, buildGenericSections as w, heapTotalColumn as x, gcPauseColumn as y, defaultCliArgs as z };
-//# sourceMappingURL=src-Cf_LXwlp.mjs.map