benchforge 0.1.11 → 0.2.4

package/dist/src-B-DDaCa9.mjs

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