benchforge 0.1.0

package/dist/src-CGuaC3Wo.mjs

@@ -0,0 +1,3676 @@
+import fs, { mkdir, readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { getHeapStatistics } from "node:v8";
+import { execSync, fork, spawn } from "node:child_process";
+import path, { 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 { chromium } from "playwright";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+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/matrix/VariantLoader.ts
+/** Discover variant ids from a directory of .ts files */
+async function discoverVariants(dirUrl) {
+	const dirPath = fileURLToPath(dirUrl);
+	return (await fs.readdir(dirPath, { withFileTypes: true })).filter((e) => e.isFile() && e.name.endsWith(".ts")).map((e) => e.name.slice(0, -3)).sort();
+}
+
+//#endregion
+//#region src/StatisticalUtils.ts
+const bootstrapSamples = 1e4;
+const confidence = .95;
+/** @return relative standard deviation (coefficient of variation) */
+function coefficientOfVariation(samples) {
+	const mean = average(samples);
+	if (mean === 0) return 0;
+	return standardDeviation(samples) / mean;
+}
+/** @return median absolute deviation for robust variability measure */
+function medianAbsoluteDeviation(samples) {
+	const median = percentile$1(samples, .5);
+	return percentile$1(samples.map((x) => Math.abs(x - median)), .5);
+}
+/** @return mean of values */
+function average(values) {
+	return values.reduce((a, b) => a + b, 0) / values.length;
+}
+/** @return standard deviation with Bessel's correction */
+function standardDeviation(samples) {
+	if (samples.length <= 1) return 0;
+	const mean = average(samples);
+	const variance = samples.reduce((sum, x) => sum + (x - mean) ** 2, 0) / (samples.length - 1);
+	return Math.sqrt(variance);
+}
+/** @return value at percentile p (0-1) */
+function percentile$1(values, p) {
+	const sorted = [...values].sort((a, b) => a - b);
+	const index = Math.ceil(sorted.length * p) - 1;
+	return sorted[Math.max(0, index)];
+}
+/** @return bootstrap resample with replacement */
+function createResample(samples) {
+	const n = samples.length;
+	const rand = () => samples[Math.floor(Math.random() * n)];
+	return Array.from({ length: n }, rand);
+}
+/** @return confidence interval [lower, upper] */
+function computeInterval(medians, confidence) {
+	const alpha = (1 - confidence) / 2;
+	return [percentile$1(medians, alpha), percentile$1(medians, 1 - alpha)];
+}
+/** Bin values into histogram for compact visualization */
+function binValues(values, binCount = 30) {
+	const sorted = [...values].sort((a, b) => a - b);
+	const min = sorted[0];
+	const max = sorted[sorted.length - 1];
+	if (min === max) return [{
+		x: min,
+		count: values.length
+	}];
+	const step = (max - min) / binCount;
+	const counts = new Array(binCount).fill(0);
+	for (const v of values) {
+		const bin = Math.min(Math.floor((v - min) / step), binCount - 1);
+		counts[bin]++;
+	}
+	return counts.map((count, i) => ({
+		x: min + (i + .5) * step,
+		count
+	}));
+}
+/** @return bootstrap CI for percentage difference between baseline and current medians */
+function bootstrapDifferenceCI(baseline, current, options = {}) {
+	const { resamples = bootstrapSamples, confidence: conf = confidence } = options;
+	const baselineMedian = percentile$1(baseline, .5);
+	const observedPercent = (percentile$1(current, .5) - baselineMedian) / baselineMedian * 100;
+	const diffs = [];
+	for (let i = 0; i < resamples; i++) {
+		const resB = createResample(baseline);
+		const resC = createResample(current);
+		const medB = percentile$1(resB, .5);
+		const medC = percentile$1(resC, .5);
+		diffs.push((medC - medB) / medB * 100);
+	}
+	const ci = computeInterval(diffs, conf);
+	const excludesZero = ci[0] > 0 || ci[1] < 0;
+	let direction = "uncertain";
+	if (excludesZero) direction = observedPercent < 0 ? "faster" : "slower";
+	const histogram = binValues(diffs);
+	return {
+		percent: observedPercent,
+		ci,
+		direction,
+		histogram
+	};
+}
+
+//#endregion
+//#region src/runners/RunnerUtils.ts
+const msToNs = 1e6;
+
+//#endregion
+//#region src/runners/AdaptiveWrapper.ts
+const minTime = 1e3;
+const maxTime = 1e4;
+const targetConfidence = 95;
+const fallbackThreshold = 80;
+const windowSize = 50;
+const stability = .05;
+const initialBatch = 100;
+const continueBatch = 100;
+const continueIterations = 10;
+/** @return adaptive sampling runner wrapper */
+function createAdaptiveWrapper(baseRunner, options) {
+	return { async runBench(benchmark, runnerOptions, params) {
+		return runAdaptiveBench(baseRunner, benchmark, runnerOptions, options, params);
+	} };
+}
+/** @return results using adaptive sampling strategy */
+async function runAdaptiveBench(baseRunner, benchmark, runnerOptions, options, params) {
+	const { minTime: min = options.minTime ?? minTime, maxTime: max = options.maxTime ?? maxTime, targetConfidence: target = options.convergence ?? targetConfidence } = runnerOptions;
+	const allSamples = [];
+	const warmup = await collectInitial(baseRunner, benchmark, runnerOptions, params, allSamples);
+	const startTime = performance.now();
+	await collectAdaptive(baseRunner, benchmark, runnerOptions, params, allSamples, {
+		minTime: min,
+		maxTime: max,
+		targetConfidence: target,
+		startTime
+	});
+	return buildResults(allSamples, startTime, checkConvergence(allSamples.map((s) => s * msToNs)), benchmark.name, warmup);
+}
+/** @return warmupSamples from initial batch */
+async function collectInitial(baseRunner, benchmark, runnerOptions, params, allSamples) {
+	const opts = {
+		...runnerOptions,
+		maxTime: initialBatch,
+		maxIterations: void 0
+	};
+	const results = await baseRunner.runBench(benchmark, opts, params);
+	appendSamples(results[0], allSamples);
+	return results[0].warmupSamples;
+}
+/** @return samples until convergence or timeout */
+async function collectAdaptive(baseRunner, benchmark, runnerOptions, params, allSamples, limits) {
+	const { minTime, maxTime, targetConfidence, startTime } = limits;
+	let lastLog = 0;
+	while (performance.now() - startTime < maxTime) {
+		const convergence = checkConvergence(allSamples.map((s) => s * msToNs));
+		const elapsed = performance.now() - startTime;
+		if (elapsed - lastLog > 1e3) {
+			const elapsedSec = (elapsed / 1e3).toFixed(1);
+			const conf = convergence.confidence.toFixed(0);
+			process.stderr.write(`\r◊ ${benchmark.name}: ${conf}% confident (${elapsedSec}s)   `);
+			lastLog = elapsed;
+		}
+		if (shouldStop(convergence, targetConfidence, elapsed, minTime)) break;
+		const opts = {
+			...runnerOptions,
+			maxTime: continueBatch,
+			maxIterations: continueIterations,
+			skipWarmup: true
+		};
+		appendSamples((await baseRunner.runBench(benchmark, opts, params))[0], allSamples);
+	}
+	process.stderr.write("\r" + " ".repeat(60) + "\r");
+}
+/** Append samples one-by-one to avoid stack overflow from spread on large arrays */
+function appendSamples(result, samples) {
+	if (!result.samples?.length) return;
+	for (const sample of result.samples) samples.push(sample);
+}
+/** @return true if convergence reached or timeout */
+function shouldStop(convergence, targetConfidence, elapsedTime, minTime) {
+	if (convergence.converged && convergence.confidence >= targetConfidence) return true;
+	const threshold = Math.max(targetConfidence, fallbackThreshold);
+	return elapsedTime >= minTime && convergence.confidence >= threshold;
+}
+/** @return measured results with convergence metrics */
+function buildResults(samplesMs, startTime, convergence, name, warmupSamples) {
+	const totalTime = (performance.now() - startTime) / 1e3;
+	return [{
+		name,
+		samples: samplesMs,
+		warmupSamples,
+		time: computeTimeStats(samplesMs.map((s) => s * msToNs)),
+		totalTime,
+		convergence
+	}];
+}
+/** @return time percentiles and statistics in ms */
+function computeTimeStats(samplesNs) {
+	const samplesMs = samplesNs.map((s) => s / msToNs);
+	const { min, max, sum } = getMinMaxSum(samplesNs);
+	const percentiles = getPercentiles(samplesNs);
+	const robust = getRobustMetrics(samplesMs);
+	return {
+		min: min / msToNs,
+		max: max / msToNs,
+		avg: sum / samplesNs.length / msToNs,
+		...percentiles,
+		...robust
+	};
+}
+/** @return min, max, sum of samples */
+function getMinMaxSum(samples) {
+	return {
+		min: samples.reduce((a, b) => Math.min(a, b), Number.POSITIVE_INFINITY),
+		max: samples.reduce((a, b) => Math.max(a, b), Number.NEGATIVE_INFINITY),
+		sum: samples.reduce((a, b) => a + b, 0)
+	};
+}
+/** @return percentiles in ms */
+function getPercentiles(samples) {
+	return {
+		p25: percentile$1(samples, .25) / msToNs,
+		p50: percentile$1(samples, .5) / msToNs,
+		p75: percentile$1(samples, .75) / msToNs,
+		p95: percentile$1(samples, .95) / msToNs,
+		p99: percentile$1(samples, .99) / msToNs,
+		p999: percentile$1(samples, .999) / msToNs
+	};
+}
+/** @return robust variability metrics */
+function getRobustMetrics(samplesMs) {
+	const impact = getOutlierImpact(samplesMs);
+	return {
+		cv: coefficientOfVariation(samplesMs),
+		mad: medianAbsoluteDeviation(samplesMs),
+		outlierRate: impact.ratio
+	};
+}
+/** @return outlier impact as proportion of total time */
+function getOutlierImpact(samples) {
+	if (samples.length === 0) return {
+		ratio: 0,
+		count: 0
+	};
+	const median = percentile$1(samples, .5);
+	const threshold = median + 1.5 * (percentile$1(samples, .75) - median);
+	let excessTime = 0;
+	let count = 0;
+	for (const sample of samples) if (sample > threshold) {
+		excessTime += sample - median;
+		count++;
+	}
+	const totalTime = samples.reduce((a, b) => a + b, 0);
+	return {
+		ratio: totalTime > 0 ? excessTime / totalTime : 0,
+		count
+	};
+}
+/** @return convergence based on window stability */
+function checkConvergence(samples) {
+	const windowSize = getWindowSize(samples);
+	const minSamples = windowSize * 2;
+	if (samples.length < minSamples) return buildProgressResult(samples.length, minSamples);
+	return buildConvergence(getStability(samples, windowSize));
+}
+/** @return progress when samples insufficient */
+function buildProgressResult(currentSamples, minSamples) {
+	return {
+		converged: false,
+		confidence: currentSamples / minSamples * 100,
+		reason: `Collecting samples: ${currentSamples}/${minSamples}`
+	};
+}
+/** @return stability metrics between windows */
+function getStability(samples, windowSize) {
+	const recent = samples.slice(-windowSize);
+	const previous = samples.slice(-windowSize * 2, -windowSize);
+	const recentMs = recent.map((s) => s / msToNs);
+	const previousMs = previous.map((s) => s / msToNs);
+	const medianRecent = percentile$1(recentMs, .5);
+	const medianPrevious = percentile$1(previousMs, .5);
+	const medianDrift = Math.abs(medianRecent - medianPrevious) / medianPrevious;
+	const impactRecent = getOutlierImpact(recentMs);
+	const impactPrevious = getOutlierImpact(previousMs);
+	const impactDrift = Math.abs(impactRecent.ratio - impactPrevious.ratio);
+	return {
+		medianDrift,
+		impactDrift,
+		medianStable: medianDrift < stability,
+		impactStable: impactDrift < stability
+	};
+}
+/** @return convergence from stability metrics */
+function buildConvergence(metrics) {
+	const { medianDrift, impactDrift, medianStable, impactStable } = metrics;
+	if (medianStable && impactStable) return {
+		converged: true,
+		confidence: 100,
+		reason: "Stable performance pattern"
+	};
+	const confidence = Math.min(100, (1 - medianDrift / stability) * 50 + (1 - impactDrift / stability) * 50);
+	const reason = medianDrift > impactDrift ? `Median drifting: ${(medianDrift * 100).toFixed(1)}%` : `Outlier impact changing: ${(impactDrift * 100).toFixed(1)}%`;
+	return {
+		converged: false,
+		confidence: Math.max(0, confidence),
+		reason
+	};
+}
+/** @return window size scaled to execution time */
+function getWindowSize(samples) {
+	if (samples.length < 20) return windowSize;
+	const recentMedian = percentile$1(samples.slice(-20).map((s) => s / msToNs), .5);
+	if (recentMedian < .01) return 200;
+	if (recentMedian < .1) return 100;
+	if (recentMedian < 1) return 50;
+	if (recentMedian < 10) return 30;
+	return 20;
+}
+
+//#endregion
+//#region src/runners/BenchRunner.ts
+/** Execute benchmark with optional parameters */
+function executeBenchmark(benchmark, params) {
+	benchmark.fn(params);
+}
+
+//#endregion
+//#region src/runners/BasicRunner.ts
+/**
+* Wait time after gc() for V8 to stabilize (ms).
+*
+* V8 has 4 compilation tiers: Ignition (interpreter) -> Sparkplug (baseline) ->
+* Maglev (mid-tier optimizer) -> TurboFan (full optimizer). Tiering thresholds:
+*   - Ignition -> Sparkplug: 8 invocations
+*   - Sparkplug -> Maglev: 500 invocations
+*   - Maglev -> TurboFan: 6000 invocations
+*
+* Optimization compilation happens on background threads and requires idle time
+* on the main thread to complete. Without sufficient warmup + settle time,
+* benchmarks exhibit bimodal timing: slow Sparkplug samples (~30% slower) mixed
+* with fast optimized samples.
+*
+* The warmup iterations trigger the optimization decision, then gcSettleTime
+* provides idle time for background compilation to finish before measurement.
+*
+* @see https://v8.dev/blog/sparkplug
+* @see https://v8.dev/blog/maglev
+* @see https://v8.dev/blog/background-compilation
+*/
+const gcSettleTime = 1e3;
+/** @return runner with time and iteration limits */
+var BasicRunner = class {
+	async runBench(benchmark, options, params) {
+		const collected = await collectSamples({
+			benchmark,
+			params,
+			...defaultCollectOptions,
+			...options
+		});
+		return [buildMeasuredResults(benchmark.name, collected)];
+	}
+};
+const defaultCollectOptions = {
+	maxTime: 5e3,
+	maxIterations: 1e6,
+	warmup: 0,
+	traceOpt: false,
+	noSettle: false
+};
+function buildMeasuredResults(name, c) {
+	const time = computeStats(c.samples);
+	const convergence = checkConvergence(c.samples.map((s) => s * msToNs));
+	return {
+		name,
+		samples: c.samples,
+		warmupSamples: c.warmupSamples,
+		heapSamples: c.heapSamples,
+		timestamps: c.timestamps,
+		time,
+		heapSize: {
+			avg: c.heapGrowth,
+			min: c.heapGrowth,
+			max: c.heapGrowth
+		},
+		convergence,
+		optStatus: c.optStatus,
+		optSamples: c.optSamples,
+		pausePoints: c.pausePoints
+	};
+}
+/** @return timing samples and amortized allocation from benchmark execution */
+async function collectSamples(p) {
+	if (!p.maxIterations && !p.maxTime) throw new Error(`At least one of maxIterations or maxTime must be set`);
+	const warmupSamples = p.skipWarmup ? [] : await runWarmup(p);
+	const heapBefore = process.memoryUsage().heapUsed;
+	const { samples, heapSamples, timestamps, optStatuses, pausePoints } = await runSampleLoop(p);
+	const heapGrowth = Math.max(0, process.memoryUsage().heapUsed - heapBefore) / 1024 / samples.length;
+	if (samples.length === 0) throw new Error(`No samples collected for benchmark: ${p.benchmark.name}`);
+	return {
+		samples,
+		warmupSamples,
+		heapGrowth,
+		heapSamples,
+		timestamps,
+		optStatus: p.traceOpt ? analyzeOptStatus(samples, optStatuses) : void 0,
+		optSamples: p.traceOpt && optStatuses.length > 0 ? optStatuses : void 0,
+		pausePoints
+	};
+}
+/** Run warmup iterations with gc + settle time for V8 optimization */
+async function runWarmup(p) {
+	const gc = gcFunction();
+	const samples = new Array(p.warmup);
+	for (let i = 0; i < p.warmup; i++) {
+		const start = performance.now();
+		executeBenchmark(p.benchmark, p.params);
+		samples[i] = performance.now() - start;
+	}
+	gc();
+	if (!p.noSettle) {
+		await new Promise((r) => setTimeout(r, gcSettleTime));
+		gc();
+	}
+	return samples;
+}
+/** Estimate sample count for pre-allocation */
+function estimateSampleCount(maxTime, maxIterations) {
+	return maxIterations || Math.ceil(maxTime / .1);
+}
+/** Pre-allocate arrays to reduce GC pressure during measurement */
+function createSampleArrays(n, trackHeap, trackOpt) {
+	const arr = (track) => track ? new Array(n) : [];
+	return {
+		samples: new Array(n),
+		timestamps: new Array(n),
+		heapSamples: arr(trackHeap),
+		optStatuses: arr(trackOpt),
+		pausePoints: []
+	};
+}
+/** Trim arrays to actual sample count */
+function trimArrays(a, count, trackHeap, trackOpt) {
+	a.samples.length = a.timestamps.length = count;
+	if (trackHeap) a.heapSamples.length = count;
+	if (trackOpt) a.optStatuses.length = count;
+}
+/** Collect timing samples with periodic pauses for V8 optimization */
+async function runSampleLoop(p) {
+	const { maxTime, maxIterations, pauseFirst, pauseInterval = 0, pauseDuration = 100 } = p;
+	const trackHeap = true;
+	const getOptStatus = p.traceOpt ? createOptStatusGetter() : void 0;
+	const a = createSampleArrays(estimateSampleCount(maxTime, maxIterations), trackHeap, !!getOptStatus);
+	let count = 0;
+	let elapsed = 0;
+	let totalPauseTime = 0;
+	const loopStart = performance.now();
+	while ((!maxIterations || count < maxIterations) && (!maxTime || elapsed < maxTime)) {
+		const start = performance.now();
+		executeBenchmark(p.benchmark, p.params);
+		const end = performance.now();
+		a.samples[count] = end - start;
+		a.timestamps[count] = Number(process.hrtime.bigint() / 1000n);
+		a.heapSamples[count] = getHeapStatistics().used_heap_size;
+		if (getOptStatus) a.optStatuses[count] = getOptStatus(p.benchmark.fn);
+		count++;
+		if (shouldPause(count, pauseFirst, pauseInterval)) {
+			a.pausePoints.push({
+				sampleIndex: count - 1,
+				durationMs: pauseDuration
+			});
+			const pauseStart = performance.now();
+			await new Promise((r) => setTimeout(r, pauseDuration));
+			totalPauseTime += performance.now() - pauseStart;
+		}
+		elapsed = performance.now() - loopStart - totalPauseTime;
+	}
+	trimArrays(a, count, trackHeap, !!getOptStatus);
+	return {
+		samples: a.samples,
+		heapSamples: a.heapSamples,
+		timestamps: a.timestamps,
+		optStatuses: a.optStatuses,
+		pausePoints: a.pausePoints
+	};
+}
+/** Check if we should pause at this iteration for V8 optimization */
+function shouldPause(iter, first, interval) {
+	if (first !== void 0 && iter === first) return true;
+	if (interval <= 0) return false;
+	if (first === void 0) return iter % interval === 0;
+	return (iter - first) % interval === 0;
+}
+/** @return percentiles and basic statistics */
+function computeStats(samples) {
+	const sorted = [...samples].sort((a, b) => a - b);
+	const avg = samples.reduce((sum, s) => sum + s, 0) / samples.length;
+	return {
+		min: sorted[0],
+		max: sorted[sorted.length - 1],
+		avg,
+		p50: percentile(sorted, .5),
+		p75: percentile(sorted, .75),
+		p99: percentile(sorted, .99),
+		p999: percentile(sorted, .999)
+	};
+}
+/** @return percentile value with linear interpolation */
+function percentile(sortedArray, p) {
+	const index = (sortedArray.length - 1) * p;
+	const lower = Math.floor(index);
+	const upper = Math.ceil(index);
+	const weight = index % 1;
+	if (upper >= sortedArray.length) return sortedArray[sortedArray.length - 1];
+	return sortedArray[lower] * (1 - weight) + sortedArray[upper] * weight;
+}
+/** @return runtime gc() function, or no-op if unavailable */
+function gcFunction() {
+	const gc = globalThis.gc || globalThis.__gc;
+	if (gc) return gc;
+	console.warn("gc() not available, run node/bun with --expose-gc");
+	return () => {};
+}
+/** @return function to get V8 optimization status (requires --allow-natives-syntax) */
+function createOptStatusGetter() {
+	try {
+		const getter = new Function("f", "return %GetOptimizationStatus(f)");
+		getter(() => {});
+		return getter;
+	} catch {
+		return;
+	}
+}
+/**
+* V8 optimization status bit meanings:
+*   Bit 0 (1): is_function
+*   Bit 4 (16): is_optimized (TurboFan)
+*   Bit 5 (32): is_optimized (Maglev)
+*   Bit 7 (128): is_baseline (Sparkplug)
+*   Bit 3 (8): maybe_deoptimized
+*/
+const statusNames = {
+	1: "interpreted",
+	129: "sparkplug",
+	17: "turbofan",
+	33: "maglev",
+	49: "turbofan+maglev",
+	32769: "optimized"
+};
+/** @return analysis of V8 optimization status per sample */
+function analyzeOptStatus(samples, statuses) {
+	if (statuses.length === 0 || statuses[0] === void 0) return void 0;
+	const byStatusCode = /* @__PURE__ */ new Map();
+	let deoptCount = 0;
+	for (let i = 0; i < samples.length; i++) {
+		const status = statuses[i];
+		if (status === void 0) continue;
+		if (status & 8) deoptCount++;
+		if (!byStatusCode.has(status)) byStatusCode.set(status, []);
+		byStatusCode.get(status).push(samples[i]);
+	}
+	const byTier = {};
+	for (const [status, times] of byStatusCode) {
+		const name = statusNames[status] || `status=${status}`;
+		const sorted = [...times].sort((a, b) => a - b);
+		const median = sorted[Math.floor(sorted.length / 2)];
+		byTier[name] = {
+			count: times.length,
+			medianMs: median
+		};
+	}
+	return {
+		byTier,
+		deoptCount
+	};
+}
+
+//#endregion
+//#region src/runners/CreateRunner.ts
+/** @return benchmark runner */
+async function createRunner(_runnerName) {
+	return new BasicRunner();
+}
+
+//#endregion
+//#region src/runners/GcStats.ts
+/** Parse a single --trace-gc-nvp stderr line */
+function parseGcLine(line) {
+	if (!line.includes("pause=")) return void 0;
+	const fields = parseNvpFields(line);
+	if (!fields.gc) return void 0;
+	const int = (k) => Number.parseInt(fields[k] || "0", 10);
+	const type = parseGcType(fields.gc);
+	const pauseMs = Number.parseFloat(fields.pause || "0");
+	const allocated = int("allocated");
+	const promoted = int("promoted");
+	const survived = int("new_space_survived") || int("survived");
+	const startSize = int("start_object_size");
+	const endSize = int("end_object_size");
+	const collected = startSize > endSize ? startSize - endSize : 0;
+	if (Number.isNaN(pauseMs)) return void 0;
+	return {
+		type,
+		pauseMs,
+		allocated,
+		collected,
+		promoted,
+		survived
+	};
+}
+/** Parse name=value pairs from trace-gc-nvp line */
+function parseNvpFields(line) {
+	const fields = {};
+	const matches = line.matchAll(/(\w+)=([^\s,]+)/g);
+	for (const [, key, value] of matches) fields[key] = value;
+	return fields;
+}
+/** Map V8 gc type codes to our types */
+function parseGcType(gcField) {
+	if (gcField === "s" || gcField === "scavenge") return "scavenge";
+	if (gcField === "mc" || gcField === "ms" || gcField === "mark-compact") return "mark-compact";
+	if (gcField === "mmc" || gcField === "minor-mc" || gcField === "minor-ms") return "minor-ms";
+	return "unknown";
+}
+/** Aggregate GC events into summary stats */
+function aggregateGcStats(events) {
+	let scavenges = 0;
+	let markCompacts = 0;
+	let gcPauseTime = 0;
+	let totalCollected = 0;
+	let hasNodeFields = false;
+	let totalAllocated = 0;
+	let totalPromoted = 0;
+	let totalSurvived = 0;
+	for (const e of events) {
+		if (e.type === "scavenge" || e.type === "minor-ms") scavenges++;
+		else if (e.type === "mark-compact") markCompacts++;
+		gcPauseTime += e.pauseMs;
+		totalCollected += e.collected;
+		if (e.allocated != null) {
+			hasNodeFields = true;
+			totalAllocated += e.allocated;
+			totalPromoted += e.promoted ?? 0;
+			totalSurvived += e.survived ?? 0;
+		}
+	}
+	return {
+		scavenges,
+		markCompacts,
+		totalCollected,
+		gcPauseTime,
+		...hasNodeFields && {
+			totalAllocated,
+			totalPromoted,
+			totalSurvived
+		}
+	};
+}
+
+//#endregion
+//#region src/runners/TimingUtils.ts
+const debugWorkerTiming = false;
+/** Get current time or 0 if debugging disabled */
+function getPerfNow() {
+	return 0;
+}
+/** Calculate elapsed milliseconds between marks */
+function getElapsed(startMark, endMark) {
+	return 0;
+}
+
+//#endregion
+//#region src/runners/RunnerOrchestrator.ts
+const logTiming = debugWorkerTiming ? (message) => console.log(`[RunnerOrchestrator] ${message}`) : () => {};
+/** Execute benchmarks directly or in worker process */
+async function runBenchmark({ spec, runner, options, useWorker = false, params }) {
+	if (!useWorker) {
+		const resolvedSpec = spec.modulePath ? await resolveModuleSpec(spec, params) : {
+			spec,
+			params
+		};
+		const base = await createRunner(runner);
+		return (options.adaptive ? createAdaptiveWrapper(base, options) : base).runBench(resolvedSpec.spec, options, resolvedSpec.params);
+	}
+	return runInWorker({
+		spec,
+		runner,
+		options,
+		params
+	});
+}
+/** Resolve modulePath/exportName to a real function for non-worker mode */
+async function resolveModuleSpec(spec, params) {
+	const module = await import(spec.modulePath);
+	const fn = spec.exportName ? module[spec.exportName] : module.default || module;
+	if (typeof fn !== "function") {
+		const name = spec.exportName || "default";
+		throw new Error(`Export '${name}' from ${spec.modulePath} is not a function`);
+	}
+	let resolvedParams = params;
+	if (spec.setupExportName) {
+		const setupFn = module[spec.setupExportName];
+		if (typeof setupFn !== "function") {
+			const msg = `Setup export '${spec.setupExportName}' from ${spec.modulePath} is not a function`;
+			throw new Error(msg);
+		}
+		resolvedParams = await setupFn(params);
+	}
+	return {
+		spec: {
+			...spec,
+			fn
+		},
+		params: resolvedParams
+	};
+}
+/** Run benchmark in isolated worker process */
+async function runInWorker(workerParams) {
+	const { spec, runner, options, params } = workerParams;
+	const msg = createRunMessage(spec, runner, options, params);
+	return runWorkerWithMessage(spec.name, options, msg);
+}
+/** Create worker process with timing logs */
+function createWorkerWithTiming(gcStats) {
+	const workerStart = getPerfNow();
+	const gcEvents = [];
+	const worker = createWorkerProcess(gcStats);
+	const createTime = getPerfNow();
+	if (gcStats && worker.stdout) setupGcCapture(worker, gcEvents);
+	logTiming(`Worker process created in ${getElapsed(workerStart, createTime).toFixed(1)}ms`);
+	return {
+		worker,
+		createTime,
+		gcEvents
+	};
+}
+/** Capture and parse GC lines from stdout (V8's --trace-gc-nvp outputs to stdout) */
+function setupGcCapture(worker, gcEvents) {
+	let buffer = "";
+	worker.stdout.on("data", (data) => {
+		buffer += data.toString();
+		const lines = buffer.split("\n");
+		buffer = lines.pop() || "";
+		for (const line of lines) {
+			const event = parseGcLine(line);
+			if (event) gcEvents.push(event);
+			else if (line.trim()) process.stdout.write(line + "\n");
+		}
+	});
+}
+/** Spawn worker, wire handlers, send message, return results */
+function runWorkerWithMessage(name, options, message) {
+	const startTime = getPerfNow();
+	const collectGcStats = options.gcStats ?? false;
+	logTiming(`Starting worker for ${name}`);
+	return new Promise((resolve, reject) => {
+		const { worker, createTime, gcEvents } = createWorkerWithTiming(collectGcStats);
+		setupWorkerHandlers(worker, name, createWorkerHandlers(name, startTime, gcEvents, resolve, reject));
+		sendWorkerMessage(worker, message, createTime);
+	});
+}
+/** Send message to worker with timing log */
+function sendWorkerMessage(worker, message, createTime) {
+	const messageTime = getPerfNow();
+	worker.send(message);
+	logTiming(`Message sent to worker in ${getElapsed(createTime, messageTime).toFixed(1)}ms`);
+}
+/** Setup worker event handlers with cleanup */
+function setupWorkerHandlers(worker, specName, handlers) {
+	const { resolve, reject } = handlers;
+	const cleanup = createCleanup(worker, specName, reject);
+	worker.on("message", createMessageHandler(specName, cleanup, resolve, reject));
+	worker.on("error", createErrorHandler(specName, cleanup, reject));
+	worker.on("exit", createExitHandler(specName, cleanup, reject));
+}
+/** Handle worker messages (results or errors) */
+function createMessageHandler(specName, cleanup, resolve, reject) {
+	return (msg) => {
+		cleanup();
+		if (msg.type === "result") resolve(msg.results, msg.heapProfile);
+		else if (msg.type === "error") {
+			const error = /* @__PURE__ */ new Error(`Benchmark "${specName}" failed: ${msg.error}`);
+			if (msg.stack) error.stack = msg.stack;
+			reject(error);
+		}
+	};
+}
+/** Handle worker process errors */
+function createErrorHandler(specName, cleanup, reject) {
+	return (error) => {
+		cleanup();
+		reject(/* @__PURE__ */ new Error(`Worker process failed for benchmark "${specName}": ${error.message}`));
+	};
+}
+/** Handle worker process exit */
+function createExitHandler(specName, cleanup, reject) {
+	return (code, _signal) => {
+		if (code !== 0 && code !== null) {
+			cleanup();
+			const msg = `Worker exited with code ${code} for benchmark "${specName}"`;
+			reject(new Error(msg));
+		}
+	};
+}
+/** Create cleanup for timeout and termination */
+function createCleanup(worker, specName, reject) {
+	const timeoutId = setTimeout(() => {
+		cleanup();
+		reject(/* @__PURE__ */ new Error(`Benchmark "${specName}" timed out after 60 seconds`));
+	}, 6e4);
+	const cleanup = () => {
+		clearTimeout(timeoutId);
+		if (!worker.killed) worker.kill("SIGTERM");
+	};
+	return cleanup;
+}
+/** Create worker process with configuration */
+function createWorkerProcess(gcStats) {
+	const workerPath = path.join(import.meta.dirname, "WorkerScript.ts");
+	const execArgv = [
+		"--expose-gc",
+		"--allow-natives-syntax",
+		"--experimental-strip-types",
+		"--no-warnings=ExperimentalWarning"
+	];
+	if (gcStats) execArgv.push("--trace-gc-nvp");
+	return fork(workerPath, [], {
+		execArgv,
+		silent: gcStats,
+		env: {
+			...process.env,
+			NODE_OPTIONS: ""
+		}
+	});
+}
+/** @return handlers that attach GC stats and heap profile to results */
+function createWorkerHandlers(specName, startTime, gcEvents, resolve, reject) {
+	return {
+		resolve: (results, heapProfile) => {
+			logTiming(`Total worker time for ${specName}: ${getElapsed(startTime).toFixed(1)}ms`);
+			if (gcEvents?.length) {
+				const gcStats = aggregateGcStats(gcEvents);
+				for (const r of results) r.gcStats = gcStats;
+			}
+			if (heapProfile) for (const r of results) r.heapProfile = heapProfile;
+			resolve(results);
+		},
+		reject
+	};
+}
+/** Create message for worker execution */
+function createRunMessage(spec, runnerName, options, params) {
+	const { fn, ...rest } = spec;
+	const message = {
+		type: "run",
+		spec: rest,
+		runnerName,
+		options,
+		params
+	};
+	if (spec.modulePath) {
+		message.modulePath = spec.modulePath;
+		message.exportName = spec.exportName;
+		if (spec.setupExportName) message.setupExportName = spec.setupExportName;
+	} else message.fnCode = fn.toString();
+	return message;
+}
+/** Run a matrix variant benchmark in isolated worker process */
+async function runMatrixVariant(params) {
+	const { variantDir, variantId, caseId, caseData, casesModule, runner, options } = params;
+	const name = `${variantId}/${caseId}`;
+	return runWorkerWithMessage(name, options, {
+		type: "run",
+		spec: {
+			name,
+			fn: () => {}
+		},
+		runnerName: runner,
+		options,
+		variantDir,
+		variantId,
+		caseId,
+		caseData,
+		casesModule
+	});
+}
+
+//#endregion
+//#region src/BenchMatrix.ts
+/** @return true if variant is a StatefulVariant (has setup + run) */
+function isStatefulVariant(v) {
+	return typeof v === "object" && "setup" in v && "run" in v;
+}
+/** Run a BenchMatrix with inline variants or variantDir */
+async function runMatrix(matrix, options = {}) {
+	validateBaseline(matrix);
+	const effectiveOptions = {
+		...matrix.defaults,
+		...options
+	};
+	if (matrix.variantDir) return runMatrixWithDir(matrix, effectiveOptions);
+	if (matrix.variants) return runMatrixInline(matrix, effectiveOptions);
+	throw new Error("BenchMatrix requires either 'variants' or 'variantDir'");
+}
+/** @throws if both baselineDir and baselineVariant are set */
+function validateBaseline(matrix) {
+	const msg = "BenchMatrix cannot have both 'baselineDir' and 'baselineVariant'";
+	if (matrix.baselineDir && matrix.baselineVariant) throw new Error(msg);
+}
+function buildRunnerOptions(options) {
+	return {
+		maxIterations: options.iterations,
+		maxTime: options.maxTime ?? 1e3,
+		warmup: options.warmup ?? 0,
+		collect: options.collect,
+		cpuCounters: options.cpuCounters,
+		traceOpt: options.traceOpt,
+		noSettle: options.noSettle,
+		pauseFirst: options.pauseFirst,
+		pauseInterval: options.pauseInterval,
+		pauseDuration: options.pauseDuration,
+		gcStats: options.gcStats,
+		heapSample: options.heapSample,
+		heapInterval: options.heapInterval,
+		heapDepth: options.heapDepth
+	};
+}
+/** Load cases module and resolve filtered case IDs */
+async function resolveCases(matrix, options) {
+	const casesModule = matrix.casesModule ? await loadCasesModule(matrix.casesModule) : void 0;
+	const allCaseIds = casesModule?.cases ?? matrix.cases ?? ["default"];
+	return {
+		casesModule,
+		caseIds: options.filteredCases ?? allCaseIds
+	};
+}
+/** Run matrix with inline variants (non-worker mode) */
+async function runMatrixInline(matrix, options) {
+	const msg = "BenchMatrix with inline 'variants' cannot use 'baselineDir'. Use 'variantDir' instead.";
+	if (matrix.baselineDir) throw new Error(msg);
+	const { casesModule, caseIds } = await resolveCases(matrix, options);
+	const runner = new BasicRunner();
+	const runnerOpts = buildRunnerOptions(options);
+	const variantEntries = options.filteredVariants ? Object.entries(matrix.variants).filter(([id]) => options.filteredVariants.includes(id)) : Object.entries(matrix.variants);
+	const variants = [];
+	for (const [variantId, variant] of variantEntries) {
+		const cases = [];
+		for (const caseId of caseIds) {
+			const loaded = await loadCaseData(casesModule, caseId);
+			const measured = await runVariant(variant, casesModule || matrix.cases ? loaded.data : void 0, variantId, runner, runnerOpts);
+			cases.push({
+				caseId,
+				measured,
+				metadata: loaded.metadata
+			});
+		}
+		variants.push({
+			id: variantId,
+			cases
+		});
+	}
+	if (matrix.baselineVariant) applyBaselineVariant(variants, matrix.baselineVariant);
+	return {
+		name: matrix.name,
+		variants
+	};
+}
+/** Run matrix with variantDir (worker mode for memory isolation) */
+async function runMatrixWithDir(matrix, options) {
+	const allVariantIds = await discoverVariants(matrix.variantDir);
+	if (allVariantIds.length === 0) throw new Error(`No variants found in ${matrix.variantDir}`);
+	const variants = await runDirVariants(options.filteredVariants ?? allVariantIds, await createDirContext(matrix, options));
+	if (matrix.baselineVariant) applyBaselineVariant(variants, matrix.baselineVariant);
+	return {
+		name: matrix.name,
+		variants
+	};
+}
+/** Create context for directory-based matrix execution */
+async function createDirContext(matrix, options) {
+	const baselineIds = matrix.baselineDir ? await discoverVariants(matrix.baselineDir) : [];
+	const { casesModule, caseIds } = await resolveCases(matrix, options);
+	return {
+		matrix,
+		casesModule,
+		baselineIds,
+		caseIds,
+		runnerOpts: buildRunnerOptions(options)
+	};
+}
+/** Run all variants using worker processes */
+async function runDirVariants(variantIds, ctx) {
+	const variants = [];
+	for (const variantId of variantIds) {
+		const cases = await runDirVariantCases(variantId, ctx);
+		variants.push({
+			id: variantId,
+			cases
+		});
+	}
+	return variants;
+}
+/** Run all cases for a single variant */
+async function runDirVariantCases(variantId, ctx) {
+	const { matrix, casesModule, caseIds, runnerOpts } = ctx;
+	const cases = [];
+	for (const caseId of caseIds) {
+		const caseData = !matrix.casesModule && matrix.cases ? caseId : void 0;
+		const [measured] = await runMatrixVariant({
+			variantDir: matrix.variantDir,
+			variantId,
+			caseId,
+			caseData,
+			casesModule: matrix.casesModule,
+			runner: "basic",
+			options: runnerOpts
+		});
+		const loaded = await loadCaseData(casesModule, caseId);
+		const baseline = await runBaselineIfExists(variantId, caseId, caseData, ctx);
+		const deltaPercent = baseline ? computeDeltaPercent(baseline, measured) : void 0;
+		const metadata = loaded.metadata;
+		cases.push({
+			caseId,
+			measured,
+			metadata,
+			baseline,
+			deltaPercent
+		});
+	}
+	return cases;
+}
+/** Run baseline variant if it exists in baselineDir */
+async function runBaselineIfExists(variantId, caseId, caseData, ctx) {
+	const { matrix, baselineIds, runnerOpts } = ctx;
+	if (!matrix.baselineDir || !baselineIds.includes(variantId)) return void 0;
+	const [measured] = await runMatrixVariant({
+		variantDir: matrix.baselineDir,
+		variantId,
+		caseId,
+		caseData,
+		casesModule: matrix.casesModule,
+		runner: "basic",
+		options: runnerOpts
+	});
+	return measured;
+}
+/** Compute delta percentage: (current - baseline) / baseline * 100 */
+function computeDeltaPercent(baseline, current) {
+	const baseAvg = average(baseline.samples);
+	if (baseAvg === 0) return 0;
+	return (average(current.samples) - baseAvg) / baseAvg * 100;
+}
+/** Apply baselineVariant comparison - one variant is the reference for all others */
+function applyBaselineVariant(variants, baselineVariantId) {
+	const baselineVariant = variants.find((v) => v.id === baselineVariantId);
+	if (!baselineVariant) return;
+	const baselineByCase = /* @__PURE__ */ new Map();
+	for (const c of baselineVariant.cases) baselineByCase.set(c.caseId, c.measured);
+	for (const variant of variants) {
+		if (variant.id === baselineVariantId) continue;
+		for (const caseResult of variant.cases) {
+			const baseline = baselineByCase.get(caseResult.caseId);
+			if (baseline) {
+				caseResult.baseline = baseline;
+				caseResult.deltaPercent = computeDeltaPercent(baseline, caseResult.measured);
+			}
+		}
+	}
+}
+/** Run a single variant with case data */
+async function runVariant(variant, caseData, name, runner, options) {
+	if (isStatefulVariant(variant)) {
+		const state = await variant.setup(caseData);
+		const [result] = await runner.runBench({
+			name,
+			fn: () => variant.run(state)
+		}, options);
+		return result;
+	}
+	const [result] = await runner.runBench({
+		name,
+		fn: () => variant(caseData)
+	}, options);
+	return result;
+}
+
+//#endregion
+//#region src/table-util/Formatters.ts
+const { red: red$1, green } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? {
+	red: (str) => str,
+	green: (str) => str
+} : pico;
+/** Format percentages with custom precision */
+function percentPrecision(precision) {
+	return (x) => {
+		if (typeof x !== "number") return null;
+		return percent(x, precision);
+	};
+}
+/** Format duration in milliseconds with appropriate units */
+function duration(ms) {
+	if (typeof ms !== "number") return null;
+	if (ms < .001) return `${(ms * 1e6).toFixed(0)}ns`;
+	if (ms < 1) return `${(ms * 1e3).toFixed(1)}μs`;
+	if (ms < 1e3) return `${ms.toFixed(2)}ms`;
+	return `${(ms / 1e3).toFixed(2)}s`;
+}
+/** Format time in milliseconds, showing very small values with units */
+function timeMs(ms) {
+	if (typeof ms !== "number") return null;
+	if (ms < .001) return `${(ms * 1e6).toFixed(0)}ns`;
+	if (ms < .01) return `${(ms * 1e3).toFixed(1)}μs`;
+	if (ms >= 10) return ms.toFixed(0);
+	return ms.toFixed(2);
+}
+/** Format integer with thousand separators */
+function integer(x) {
+	if (typeof x !== "number") return null;
+	return new Intl.NumberFormat("en-US").format(Math.round(x));
+}
+/** Format fraction as percentage (0.473 → 47.3%) */
+function percent(fraction, precision = 1) {
+	if (typeof fraction !== "number") return null;
+	return `${Math.abs(fraction * 100).toFixed(precision)}%`;
+}
+/** Format percentage difference between two values */
+function diffPercent(main, base) {
+	if (typeof main !== "number" || typeof base !== "number") return " ";
+	return coloredPercent(main - base, base);
+}
+/** Format fraction as colored +/- percentage */
+function coloredPercent(numerator, denominator, positiveIsGreen = true) {
+	const fraction = numerator / denominator;
+	if (Number.isNaN(fraction) || !Number.isFinite(fraction)) return " ";
+	const positive = fraction >= 0;
+	const percentStr = `${positive ? "+" : "-"}${percent(fraction)}`;
+	return positive === positiveIsGreen ? green(percentStr) : red$1(percentStr);
+}
+/** Format bytes with appropriate units (B, KB, MB, GB) */
+function formatBytes(bytes) {
+	if (typeof bytes !== "number") return null;
+	if (bytes < 1024) return `${bytes.toFixed(0)}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+	return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}GB`;
+}
+/** Format percentage difference with confidence interval */
+function formatDiffWithCI(value) {
+	if (!isDifferenceCI(value)) return null;
+	const { percent, ci, direction } = value;
+	return colorByDirection(diffCIText(percent, ci), direction);
+}
+/** Format percentage difference with CI for throughput metrics (higher is better) */
+function formatDiffWithCIHigherIsBetter(value) {
+	if (!isDifferenceCI(value)) return null;
+	const { percent, ci, direction } = value;
+	return colorByDirection(diffCIText(-percent, [-ci[1], -ci[0]]), direction);
+}
+/** @return formatted "pct [lo, hi]" text for a diff with CI */
+function diffCIText(pct, ci) {
+	return `${formatBound(pct)} [${formatBound(ci[0])}, ${formatBound(ci[1])}]`;
+}
+/** @return text colored green for faster, red for slower */
+function colorByDirection(text, direction) {
+	if (direction === "faster") return green(text);
+	if (direction === "slower") return red$1(text);
+	return text;
+}
+/** @return signed percentage string (e.g. "+1.2%", "-3.4%") */
+function formatBound(v) {
+	return `${v >= 0 ? "+" : ""}${v.toFixed(1)}%`;
+}
+/** @return true if value is a DifferenceCI object */
+function isDifferenceCI(x) {
+	return typeof x === "object" && x !== null && "ci" in x && "direction" in x;
+}
+/** @return truncated string with ellipsis if over maxLen */
+function truncate(str, maxLen = 30) {
+	return str.length > maxLen ? str.slice(0, maxLen - 3) + "..." : str;
+}
+
+//#endregion
+//#region src/table-util/TableReport.ts
+const { bold } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? { bold: (str) => str } : pico;
+/** Build formatted table with column groups and baselines */
+function buildTable(columnGroups, resultGroups, nameKey = "name") {
+	return createTable(columnGroups, flattenGroups(columnGroups, resultGroups, nameKey));
+}
+/** Convert columns and records to formatted table */
+function createTable(groups, records) {
+	const dataRows = toRows(records, groups);
+	const { headerRows, config } = setup(groups, dataRows);
+	return table([...headerRows, ...dataRows], config);
+}
+/** Create header rows with group titles */
+function createGroupHeaders(groups, numColumns) {
+	if (!groups.some((g) => g.groupTitle)) return [];
+	return [groups.flatMap((g) => {
+		return padWithBlanks(g.groupTitle ? [bold(g.groupTitle)] : [], g.columns.length);
+	}), padWithBlanks([], numColumns)];
+}
+/** @return draw functions for horizontal/vertical table borders */
+function createLines(groups) {
+	const { sectionBorders, headerBottom } = calcBorders(groups);
+	function drawVerticalLine(index, size) {
+		return index === 0 || index === size || sectionBorders.includes(index);
+	}
+	function drawHorizontalLine(index, size) {
+		return index === 0 || index === size || index === headerBottom;
+	}
+	return {
+		drawHorizontalLine,
+		drawVerticalLine
+	};
+}
+/** @return spanning cell configs for group title headers */
+function createSectionSpans(groups) {
+	let col = 0;
+	const alignment = "center";
+	return groups.map((g) => {
+		const colSpan = g.columns.length;
+		const span = {
+			row: 0,
+			col,
+			colSpan,
+			alignment
+		};
+		col += colSpan;
+		return span;
+	});
+}
+/** @return bolded column title strings */
+function getTitles(groups) {
+	return groups.flatMap((g) => g.columns.map((c) => bold(c.title || " ")));
+}
+/** @return array padded with blank strings to the given length */
+function padWithBlanks(arr, length) {
+	if (arr.length >= length) return arr;
+	return [...arr, ...Array(length - arr.length).fill(" ")];
+}
+/** Convert records to string arrays for table */
+function toRows(records, groups) {
+	const allColumns = groups.flatMap((group) => group.columns);
+	return records.map((record) => allColumns.map((col) => {
+		const value = record[col.key];
+		return col.formatter ? col.formatter(value) : value;
+	})).map((row) => row.map((cell) => cell ?? " "));
+}
+/** Add comparison values for diff columns */
+function addComparisons(groups, mainRecord, baselineRecord) {
+	const diffColumns = groups.flatMap((g) => g.columns).filter((col) => col.diffKey);
+	const updatedMain = { ...mainRecord };
+	for (const col of diffColumns) {
+		const dcol = col;
+		const diffKey = dcol.diffKey;
+		const mainValue = mainRecord[diffKey];
+		const baselineValue = baselineRecord[diffKey];
+		const diffStr = (dcol.diffFormatter ?? diffPercent)(mainValue, baselineValue);
+		updatedMain[col.key] = diffStr;
+	}
+	return updatedMain;
+}
+/** Flatten groups with spacing */
+function flattenGroups(columnGroups, resultGroups, nameKey) {
+	return resultGroups.flatMap((group, i) => {
+		const groupRecords = addBaseline(columnGroups, group, nameKey);
+		return i === resultGroups.length - 1 ? groupRecords : [...groupRecords, {}];
+	});
+}
+/** Process results with baseline comparisons */
+function addBaseline(columnGroups, group, nameKey) {
+	const { results, baseline } = group;
+	if (!baseline) return results;
+	const diffResults = results.map((result) => addComparisons(columnGroups, result, baseline));
+	const markedBaseline = {
+		...baseline,
+		[nameKey]: `--> ${baseline[nameKey]}`
+	};
+	return [...diffResults, markedBaseline];
+}
+/** Calculate vertical lines between sections and header bottom position */
+function calcBorders(groups) {
+	if (groups.length === 0) return {
+		sectionBorders: [],
+		headerBottom: 1
+	};
+	const sectionBorders = [];
+	let border = 0;
+	for (const g of groups) {
+		border += g.columns.length;
+		sectionBorders.push(border);
+	}
+	return {
+		sectionBorders,
+		headerBottom: 3
+	};
+}
+/** Create headers and table configuration */
+function setup(groups, dataRows) {
+	const titles = getTitles(groups);
+	const numColumns = titles.length;
+	return {
+		headerRows: [...createGroupHeaders(groups, numColumns), titles],
+		config: {
+			spanningCells: createSectionSpans(groups),
+			columns: calcColumnWidths(groups, titles, dataRows),
+			...createLines(groups)
+		}
+	};
+}
+/** Calculate column widths based on content, including group titles */
+function calcColumnWidths(groups, titles, dataRows) {
+	const widths = [];
+	for (let i = 0; i < titles.length; i++) {
+		const titleW = cellWidth(titles[i]);
+		const maxDataW = dataRows.reduce((max, row) => Math.max(max, cellWidth(row[i])), 0);
+		widths.push(Math.max(titleW, maxDataW));
+	}
+	let colIndex = 0;
+	for (const group of groups) {
+		const groupW = cellWidth(group.groupTitle);
+		if (groupW > 0) {
+			const numCols = group.columns.length;
+			const separatorWidth = (numCols - 1) * 3;
+			const needed = groupW - widths.slice(colIndex, colIndex + numCols).reduce((a, b) => a + b, 0) - separatorWidth;
+			if (needed > 0) widths[colIndex + numCols - 1] += needed;
+		}
+		colIndex += group.columns.length;
+	}
+	return Object.fromEntries(widths.map((w, i) => [i, {
+		width: w,
+		wrapWord: false
+	}]));
+}
+const ansiEscapeRegex = new RegExp(String.fromCharCode(27) + "\\[[0-9;]*m", "g");
+/** Get visible length of a cell value (strips ANSI escape codes) */
+function cellWidth(value) {
+	if (value == null) return 0;
+	return String(value).replace(ansiEscapeRegex, "").length;
+}
+
+//#endregion
+//#region src/BenchmarkReport.ts
+/** @return formatted table report with optional baseline comparisons */
+function reportResults(groups, sections) {
+	const results = groups.map((group) => resultGroupValues(group, sections));
+	return buildTable(createColumnGroups(sections, results.some((g) => g.baseline)), results);
+}
+/** @return values for report group */
+function resultGroupValues(group, sections) {
+	const { reports, baseline } = group;
+	const baselineSamples = baseline?.measuredResults.samples;
+	return {
+		results: reports.map((report) => {
+			const row = {
+				name: truncate(report.name),
+				...extractReportValues(report, sections)
+			};
+			if (baselineSamples && report.measuredResults.samples) row.diffCI = bootstrapDifferenceCI(baselineSamples, report.measuredResults.samples);
+			return row;
+		}),
+		baseline: baseline && valuesForReports([baseline], sections)[0]
+	};
+}
+/** @return rows with stats from sections */
+function valuesForReports(reports, sections) {
+	return reports.map((report) => ({
+		name: truncate(report.name),
+		...extractReportValues(report, sections)
+	}));
+}
+/** @return merged statistics from all sections */
+function extractReportValues(report, sections) {
+	const { measuredResults, metadata } = report;
+	const entries = sections.flatMap((s) => Object.entries(s.extract(measuredResults, metadata)));
+	return Object.fromEntries(entries);
+}
+/** @return column groups with diff columns if baseline exists */
+function createColumnGroups(sections, hasBaseline) {
+	const nameColumn = { columns: [{
+		key: "name",
+		title: "name"
+	}] };
+	const groups = sections.flatMap((section) => section.columns());
+	return [nameColumn, ...hasBaseline ? injectDiffColumns(groups) : groups];
+}
+/** @return groups with single CI column after first comparable field */
+function injectDiffColumns(reportGroups) {
+	let ciAdded = false;
+	return reportGroups.map((group) => ({
+		groupTitle: group.groupTitle,
+		columns: group.columns.flatMap((col) => {
+			if (col.comparable && !ciAdded) {
+				ciAdded = true;
+				return [col, {
+					title: "Δ% CI",
+					key: "diffCI",
+					formatter: col.higherIsBetter ? formatDiffWithCIHigherIsBetter : formatDiffWithCI
+				}];
+			}
+			return [col];
+		})
+	}));
+}
+
+//#endregion
+//#region src/cli/CliArgs.ts
+const defaultTime = .642;
+const defaultAdaptiveMaxTime = 20;
+const defaultPauseInterval = 0;
+const defaultPauseDuration = 100;
+const cliOptions = {
+	time: {
+		type: "number",
+		default: defaultTime,
+		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: "use adaptive sampling mode"
+	},
+	"min-time": {
+		type: "number",
+		default: 1,
+		describe: "minimum time in seconds before adaptive convergence can stop"
+	},
+	convergence: {
+		type: "number",
+		default: 95,
+		describe: "confidence threshold (0-100)"
+	},
+	warmup: {
+		type: "number",
+		default: 0,
+		describe: "warmup iterations before measurement"
+	},
+	html: {
+		type: "boolean",
+		default: false,
+		describe: "generate HTML report and open in browser"
+	},
+	"export-html": {
+		type: "string",
+		requiresArg: true,
+		describe: "export HTML report to specified file"
+	},
+	json: {
+		type: "string",
+		requiresArg: true,
+		describe: "export benchmark data to JSON file"
+	},
+	perfetto: {
+		type: "string",
+		requiresArg: true,
+		describe: "export Perfetto trace file (view at ui.perfetto.dev)"
+	},
+	"trace-opt": {
+		type: "boolean",
+		default: false,
+		describe: "trace V8 optimization tiers (requires --allow-natives-syntax)"
+	},
+	"skip-settle": {
+		type: "boolean",
+		default: false,
+		describe: "skip post-warmup settle time (see V8 optimization cold start)"
+	},
+	"pause-first": {
+		type: "number",
+		describe: "iterations before first pause (then pause-interval applies)"
+	},
+	"pause-interval": {
+		type: "number",
+		default: defaultPauseInterval,
+		describe: "iterations between pauses for V8 optimization (0 to disable)"
+	},
+	"pause-duration": {
+		type: "number",
+		default: defaultPauseDuration,
+		describe: "pause duration in ms for V8 optimization"
+	},
+	batches: {
+		type: "number",
+		default: 1,
+		describe: "divide time into N batches, alternating baseline/current order"
+	},
+	iterations: {
+		type: "number",
+		requiresArg: true,
+		describe: "exact number of iterations (overrides --time)"
+	},
+	"heap-sample": {
+		type: "boolean",
+		default: false,
+		describe: "heap sampling allocation attribution (includes garbage)"
+	},
+	"heap-interval": {
+		type: "number",
+		default: 32768,
+		describe: "heap sampling interval in bytes"
+	},
+	"heap-depth": {
+		type: "number",
+		default: 64,
+		describe: "heap sampling stack depth"
+	},
+	"heap-rows": {
+		type: "number",
+		default: 20,
+		describe: "top allocation sites to show"
+	},
+	"heap-stack": {
+		type: "number",
+		default: 3,
+		describe: "call stack depth to display"
+	},
+	"heap-verbose": {
+		type: "boolean",
+		default: false,
+		describe: "verbose output with file:// paths and line numbers"
+	},
+	"heap-user-only": {
+		type: "boolean",
+		default: false,
+		describe: "filter to user code only (hide node internals)"
+	},
+	url: {
+		type: "string",
+		requiresArg: true,
+		describe: "page URL for browser profiling (enables browser mode)"
+	},
+	headless: {
+		type: "boolean",
+		default: true,
+		describe: "run browser in headless mode"
+	},
+	timeout: {
+		type: "number",
+		default: 60,
+		describe: "browser page timeout in seconds"
+	}
+};
+/** @return yargs with standard benchmark options */
+function defaultCliArgs(yargsInstance) {
+	return yargsInstance.options(cliOptions).help().strict();
+}
+/** @return parsed command line arguments */
+function parseCliArgs(args, configure = defaultCliArgs) {
+	return configure(yargs(args)).parseSync();
+}
+
+//#endregion
+//#region src/browser/BrowserGcStats.ts
+/** Parse CDP trace events (MinorGC/MajorGC) into GcEvent[] */
+function parseGcTraceEvents(traceEvents) {
+	return traceEvents.flatMap((e) => {
+		if (e.ph !== "X") return [];
+		const type = gcType(e.name);
+		if (!type) return [];
+		const durUs = e.dur ?? 0;
+		const heapBefore = e.args?.usedHeapSizeBefore ?? 0;
+		const heapAfter = e.args?.usedHeapSizeAfter ?? 0;
+		return [{
+			type,
+			pauseMs: durUs / 1e3,
+			collected: Math.max(0, heapBefore - heapAfter)
+		}];
+	});
+}
+function gcType(name) {
+	if (name === "MinorGC") return "scavenge";
+	if (name === "MajorGC") return "mark-compact";
+}
+/** Parse CDP trace events and aggregate into GcStats */
+function browserGcStats(traceEvents) {
+	return aggregateGcStats(parseGcTraceEvents(traceEvents));
+}
+
+//#endregion
+//#region src/browser/BrowserHeapSampler.ts
+/** Run browser benchmark, auto-detecting page API mode.
+*  Bench function (window.__bench): CLI controls iteration and timing.
+*  Lap mode (__start/__lap/__done): page controls the measured region. */
+async function profileBrowser(params) {
+	const { url, headless = true, timeout = 60 } = params;
+	const { gcStats: collectGc } = params;
+	const { samplingInterval = 32768 } = params.heapOptions ?? {};
+	const browser = await chromium.launch({ headless });
+	try {
+		const page = await browser.newPage();
+		page.setDefaultTimeout(timeout * 1e3);
+		const cdp = await page.context().newCDPSession(page);
+		const pageErrors = [];
+		page.on("pageerror", (err) => pageErrors.push(err.message));
+		const traceEvents = collectGc ? await startGcTracing(cdp) : [];
+		const lapMode = await setupLapMode(page, cdp, params, samplingInterval, timeout, pageErrors);
+		await page.goto(url, { waitUntil: "load" });
+		const hasBench = await page.evaluate(() => typeof globalThis.__bench === "function");
+		let result;
+		if (hasBench) {
+			lapMode.cancel();
+			lapMode.promise.catch(() => {});
+			result = await runBenchLoop(page, cdp, params, samplingInterval);
+		} else {
+			result = await lapMode.promise;
+			lapMode.cancel();
+		}
+		if (collectGc) result = {
+			...result,
+			gcStats: await collectTracing(cdp, traceEvents)
+		};
+		return result;
+	} finally {
+		await browser.close();
+	}
+}
+/** Inject __start/__lap as in-page functions, expose __done for results collection.
+*  __start/__lap are pure in-page (zero CDP overhead). First __start() triggers
+*  instrument start. __done() stops instruments and collects timing data. */
+async function setupLapMode(page, cdp, params, samplingInterval, timeout, pageErrors) {
+	const { heapSample } = params;
+	const { promise, resolve, reject } = Promise.withResolvers();
+	let instrumentsStarted = false;
+	await page.exposeFunction("__benchInstrumentStart", async () => {
+		if (instrumentsStarted) return;
+		instrumentsStarted = true;
+		if (heapSample) await cdp.send("HeapProfiler.startSampling", heapSamplingParams(samplingInterval));
+	});
+	await page.exposeFunction("__benchCollect", async (samples, wallTimeMs) => {
+		let heapProfile;
+		if (heapSample && instrumentsStarted) heapProfile = (await cdp.send("HeapProfiler.stopSampling")).profile;
+		resolve({
+			samples,
+			heapProfile,
+			wallTimeMs
+		});
+	});
+	await page.addInitScript(injectLapFunctions);
+	const timer = setTimeout(() => {
+		const lines = [`Timed out after ${timeout}s`];
+		if (pageErrors.length) lines.push("Page JS errors:", ...pageErrors.map((e) => `  ${e}`));
+		else lines.push("Page did not call __done() or define window.__bench");
+		reject(new Error(lines.join("\n")));
+	}, timeout * 1e3);
+	return {
+		promise,
+		cancel: () => clearTimeout(timer)
+	};
+}
+/** In-page timing functions injected via addInitScript (zero CDP overhead).
+*  __start/__lap collect timestamps, __done delegates to exposed __benchCollect. */
+function injectLapFunctions() {
+	const g = globalThis;
+	g.__benchSamples = [];
+	g.__benchLastTime = 0;
+	g.__benchFirstStart = 0;
+	g.__start = () => {
+		const now = performance.now();
+		g.__benchLastTime = now;
+		if (!g.__benchFirstStart) {
+			g.__benchFirstStart = now;
+			return g.__benchInstrumentStart();
+		}
+	};
+	g.__lap = () => {
+		const now = performance.now();
+		g.__benchSamples.push(now - g.__benchLastTime);
+		g.__benchLastTime = now;
+	};
+	g.__done = () => {
+		const wall = g.__benchFirstStart ? performance.now() - g.__benchFirstStart : 0;
+		return g.__benchCollect(g.__benchSamples.slice(), wall);
+	};
+}
+function heapSamplingParams(samplingInterval) {
+	return {
+		samplingInterval,
+		includeObjectsCollectedByMajorGC: true,
+		includeObjectsCollectedByMinorGC: true
+	};
+}
+/** Start CDP GC tracing, returns the event collector array. */
+async function startGcTracing(cdp) {
+	const events = [];
+	cdp.on("Tracing.dataCollected", ({ value }) => {
+		for (const e of value) events.push(e);
+	});
+	await cdp.send("Tracing.start", { traceConfig: { includedCategories: ["v8", "v8.gc"] } });
+	return events;
+}
+/** Bench function mode: run window.__bench in a timed iteration loop. */
+async function runBenchLoop(page, cdp, params, samplingInterval) {
+	const { heapSample } = params;
+	const maxTime = params.maxTime ?? 642;
+	const maxIter = params.maxIterations ?? Number.MAX_SAFE_INTEGER;
+	if (heapSample) await cdp.send("HeapProfiler.startSampling", heapSamplingParams(samplingInterval));
+	const { samples, totalMs } = await page.evaluate(async ({ maxTime, maxIter }) => {
+		const bench = globalThis.__bench;
+		const samples = [];
+		const startAll = performance.now();
+		const deadline = startAll + maxTime;
+		for (let i = 0; i < maxIter && performance.now() < deadline; i++) {
+			const t0 = performance.now();
+			await bench();
+			samples.push(performance.now() - t0);
+		}
+		return {
+			samples,
+			totalMs: performance.now() - startAll
+		};
+	}, {
+		maxTime,
+		maxIter
+	});
+	let heapProfile;
+	if (heapSample) heapProfile = (await cdp.send("HeapProfiler.stopSampling")).profile;
+	return {
+		samples,
+		heapProfile,
+		wallTimeMs: totalMs
+	};
+}
+/** Stop CDP tracing and parse GC events into GcStats. */
+async function collectTracing(cdp, traceEvents) {
+	const complete = new Promise((resolve) => cdp.once("Tracing.tracingComplete", () => resolve()));
+	await cdp.send("Tracing.end");
+	await complete;
+	return browserGcStats(traceEvents);
+}
+
+//#endregion
+//#region src/export/JsonExport.ts
+/** Export benchmark results to JSON file */
+async function exportBenchmarkJson(groups, outputPath, args, suiteName = "Benchmark Suite") {
+	const jsonData = prepareJsonData(groups, args, suiteName);
+	await writeFile(outputPath, JSON.stringify(jsonData, null, 2), "utf-8");
+	console.log(`Benchmark data exported to: ${outputPath}`);
+}
+/** Convert ReportGroup data to JSON format */
+function prepareJsonData(groups, args, suiteName) {
+	return {
+		meta: {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			version: process.env.npm_package_version || "unknown",
+			args: cleanCliArgs(args),
+			environment: {
+				node: process.version,
+				platform: process.platform,
+				arch: process.arch
+			}
+		},
+		suites: [{
+			name: suiteName,
+			groups: groups.map(convertGroup)
+		}]
+	};
+}
+/** Convert a report group, mapping each report to the JSON result format */
+function convertGroup(group) {
+	return {
+		name: "Benchmark Group",
+		baseline: group.baseline ? convertReport(group.baseline) : void 0,
+		benchmarks: group.reports.map(convertReport)
+	};
+}
+/** Extract measured stats and optional metrics into JSON result shape */
+function convertReport(report) {
+	const { name, measuredResults: m } = report;
+	const { time, heapSize, gcTime, cpu } = m;
+	const minMaxMean = (s) => s ? {
+		min: s.min,
+		max: s.max,
+		mean: s.avg
+	} : void 0;
+	return {
+		name,
+		status: "completed",
+		samples: m.samples || [],
+		time: {
+			...minMaxMean(time),
+			p50: time.p50,
+			p75: time.p75,
+			p99: time.p99,
+			p999: time.p999
+		},
+		heapSize: minMaxMean(heapSize),
+		gcTime: minMaxMean(gcTime),
+		cpu: cpu ? {
+			instructions: cpu.instructions,
+			cycles: cpu.cycles,
+			cacheMisses: m.cpuCacheMiss,
+			branchMisses: cpu.branchMisses
+		} : void 0,
+		execution: {
+			iterations: m.samples?.length || 0,
+			totalTime: m.totalTime || 0,
+			warmupRuns: void 0
+		}
+	};
+}
+/** Clean CLI args for JSON export (remove undefined values) */
+function cleanCliArgs(args) {
+	const toCamel = (k) => k.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+	const entries = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => [toCamel(k), v]);
+	return Object.fromEntries(entries);
+}
+
+//#endregion
+//#region src/export/PerfettoExport.ts
+const pid = 1;
+const tid = 1;
+/** Export benchmark results to Perfetto-compatible trace file */
+function exportPerfettoTrace(groups, outputPath, args) {
+	const absPath = resolve(outputPath);
+	writeTraceFile(absPath, mergeV8Trace(buildTraceEvents(groups, args)));
+	console.log(`Perfetto trace exported to: ${outputPath}`);
+	scheduleDeferredMerge(absPath);
+}
+/** Build trace events from benchmark results */
+function buildTraceEvents(groups, args) {
+	const meta = (name, a) => ({
+		ph: "M",
+		ts: 0,
+		pid,
+		tid,
+		name,
+		args: a
+	});
+	const events = [
+		meta("process_name", { name: "wesl-bench" }),
+		meta("thread_name", { name: "MainThread" }),
+		meta("bench_settings", cleanArgs(args))
+	];
+	for (const group of groups) for (const report of group.reports) {
+		const results = report.measuredResults;
+		events.push(...buildBenchmarkEvents(results));
+	}
+	return events;
+}
+function instant(ts, name, args) {
+	return {
+		ph: "i",
+		ts,
+		pid,
+		tid,
+		cat: "bench",
+		name,
+		s: "t",
+		args
+	};
+}
+function counter(ts, name, args) {
+	return {
+		ph: "C",
+		ts,
+		pid,
+		tid,
+		cat: "bench",
+		name,
+		args
+	};
+}
+/** Build events for a single benchmark run */
+function buildBenchmarkEvents(results) {
+	const { samples, heapSamples, timestamps, pausePoints } = results;
+	if (!timestamps?.length) return [];
+	const events = [];
+	for (let i = 0; i < samples.length; i++) {
+		const ts = timestamps[i];
+		const ms = Math.round(samples[i] * 100) / 100;
+		events.push(instant(ts, results.name, {
+			n: i,
+			ms
+		}));
+		events.push(counter(ts, "duration", { ms }));
+		if (heapSamples?.[i] !== void 0) {
+			const MB = Math.round(heapSamples[i] / 1024 / 1024 * 10) / 10;
+			events.push(counter(ts, "heap", { MB }));
+		}
+	}
+	for (const pause of pausePoints ?? []) {
+		const ts = timestamps[pause.sampleIndex];
+		if (ts) events.push(instant(ts, "pause", { ms: pause.durationMs }));
+	}
+	return events;
+}
+/** Normalize timestamps so events start at 0 */
+function normalizeTimestamps(events) {
+	const times = events.filter((e) => e.ts > 0).map((e) => e.ts);
+	if (times.length === 0) return;
+	const minTs = Math.min(...times);
+	for (const e of events) if (e.ts > 0) e.ts -= minTs;
+}
+/** Merge V8 trace events from a previous run, aligning timestamps */
+function mergeV8Trace(customEvents) {
+	const v8Events = loadV8Events(readdirSync(".").filter((f) => f.startsWith("node_trace.") && f.endsWith(".log"))[0]);
+	normalizeTimestamps(customEvents);
+	if (!v8Events) return customEvents;
+	normalizeTimestamps(v8Events);
+	return [...v8Events, ...customEvents];
+}
+/** Load V8 trace events from file, or undefined if unavailable */
+function loadV8Events(v8TracePath) {
+	if (!v8TracePath) return void 0;
+	try {
+		const v8Data = JSON.parse(readFileSync(v8TracePath, "utf-8"));
+		console.log(`Merged ${v8Data.traceEvents.length} V8 events from ${v8TracePath}`);
+		return v8Data.traceEvents;
+	} catch {
+		console.warn(`Could not parse V8 trace file: ${v8TracePath}`);
+		return;
+	}
+}
+/** Write trace events to JSON file */
+function writeTraceFile(outputPath, events) {
+	const traceFile = { traceEvents: events };
+	writeFileSync(outputPath, JSON.stringify(traceFile));
+}
+/** Clean CLI args for metadata */
+function cleanArgs(args) {
+	const skip = new Set(["_", "$0"]);
+	const entries = Object.entries(args).filter(([k, v]) => v !== void 0 && !skip.has(k));
+	return Object.fromEntries(entries);
+}
+/** Spawn a detached child to merge V8 trace after process exit */
+function scheduleDeferredMerge(outputPath) {
+	const cwd = process.cwd();
+	const mergeScript = `
+    const { readdirSync, readFileSync, writeFileSync } = require('fs');
+    function normalize(events) {
+      const times = events.filter(e => e.ts > 0).map(e => e.ts);
+      if (!times.length) return;
+      const min = Math.min(...times);
+      for (const e of events) if (e.ts > 0) e.ts -= min;
+    }
+    setTimeout(() => {
+      const traceFiles = readdirSync('.').filter(f => f.startsWith('node_trace.') && f.endsWith('.log'));
+      if (traceFiles.length === 0) process.exit(0);
+      try {
+        const v8Data = JSON.parse(readFileSync(traceFiles[0], 'utf-8'));
+        const ourData = JSON.parse(readFileSync('${outputPath}', 'utf-8'));
+        normalize(v8Data.traceEvents);
+        const merged = { traceEvents: [...v8Data.traceEvents, ...ourData.traceEvents] };
+        writeFileSync('${outputPath}', JSON.stringify(merged));
+        console.log('Merged ' + v8Data.traceEvents.length + ' V8 events into ' + '${outputPath}');
+      } catch (e) { console.error('Merge failed:', e.message); }
+    }, 100);
+  `;
+	process.on("exit", () => {
+		spawn("node", ["-e", mergeScript], {
+			detached: true,
+			stdio: "inherit",
+			cwd
+		}).unref();
+	});
+}
+
+//#endregion
+//#region src/HtmlDataPrep.ts
+/** Find higherIsBetter from first comparable column in sections */
+function findHigherIsBetter(sections) {
+	return (sections?.flatMap((s) => s.columns().flatMap((g) => g.columns)))?.find((c) => c.comparable)?.higherIsBetter ?? false;
+}
+/** Flip CI percent for metrics where higher is better (e.g., lines/sec) */
+function flipCI(ci) {
+	return {
+		percent: -ci.percent,
+		ci: [-ci.ci[1], -ci.ci[0]],
+		direction: ci.direction,
+		histogram: ci.histogram?.map((bin) => ({
+			x: -bin.x,
+			count: bin.count
+		}))
+	};
+}
+/** Prepare ReportData from benchmark results for HTML rendering */
+function prepareHtmlData(groups, options) {
+	const { cliArgs, sections, currentVersion, baselineVersion } = options;
+	const higherIsBetter = findHigherIsBetter(sections);
+	return {
+		groups: groups.map((group) => prepareGroupData(group, sections, higherIsBetter)),
+		metadata: {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			bencherVersion: process.env.npm_package_version || "unknown",
+			cliArgs,
+			gcTrackingEnabled: cliArgs?.["gc-stats"] === true,
+			currentVersion,
+			baselineVersion
+		}
+	};
+}
+/** @return group data with bootstrap CI comparisons against baseline */
+function prepareGroupData(group, sections, higherIsBetter) {
+	const baselineSamples = group.baseline?.measuredResults.samples;
+	return {
+		name: group.name,
+		baseline: group.baseline ? prepareBenchmarkData(group.baseline, sections) : void 0,
+		benchmarks: group.reports.map((report) => {
+			const samples = report.measuredResults.samples;
+			const rawCI = baselineSamples && samples ? bootstrapDifferenceCI(baselineSamples, samples) : void 0;
+			const comparisonCI = rawCI && higherIsBetter ? flipCI(rawCI) : rawCI;
+			return {
+				...prepareBenchmarkData(report, sections),
+				comparisonCI
+			};
+		})
+	};
+}
+/** @return benchmark data with samples, stats, and formatted section values */
+function prepareBenchmarkData(report, sections) {
+	const { measuredResults } = report;
+	return {
+		name: report.name,
+		samples: measuredResults.samples,
+		warmupSamples: measuredResults.warmupSamples,
+		allocationSamples: measuredResults.allocationSamples,
+		heapSamples: measuredResults.heapSamples,
+		gcEvents: measuredResults.nodeGcTime?.events,
+		optSamples: measuredResults.optSamples,
+		pausePoints: measuredResults.pausePoints,
+		stats: measuredResults.time,
+		heapSize: measuredResults.heapSize,
+		sectionStats: sections ? extractSectionStats(report, sections) : void 0
+	};
+}
+/** @return formatted stats from all sections for tooltip display */
+function extractSectionStats(report, sections) {
+	return sections.flatMap((section) => {
+		const vals = section.extract(report.measuredResults, report.metadata);
+		return section.columns().flatMap((g) => formatGroupStats(vals, g));
+	});
+}
+/** @return formatted stats for one column group, skipping undefined values */
+function formatGroupStats(values, group) {
+	return group.columns.map((c) => formatColumnStat(values, c, group.groupTitle)).filter((s) => s !== void 0);
+}
+/** @return formatted stat for a single column, or undefined if empty/placeholder */
+function formatColumnStat(values, col, groupTitle) {
+	const raw = values[col.key];
+	if (raw === void 0) return void 0;
+	const formatted = col.formatter ? col.formatter(raw) : String(raw);
+	if (!formatted || formatted === "—" || formatted === "") return void 0;
+	return {
+		label: col.title,
+		value: formatted,
+		groupTitle
+	};
+}
+
+//#endregion
+//#region src/heap-sample/HeapSampleReport.ts
+/** Sum selfSize across all nodes in profile (before any filtering) */
+function totalProfileBytes(profile) {
+	let total = 0;
+	function walk(node) {
+		total += node.selfSize;
+		for (const child of node.children || []) walk(child);
+	}
+	walk(profile.head);
+	return total;
+}
+/** Flatten profile tree into sorted list of allocation sites with call stacks */
+function flattenProfile(profile) {
+	const sites = [];
+	function walk(node, stack) {
+		const { functionName, url, lineNumber, columnNumber } = node.callFrame;
+		const fn = functionName || "(anonymous)";
+		const col = columnNumber ?? 0;
+		const frame = {
+			fn,
+			url: url || "",
+			line: lineNumber + 1,
+			col
+		};
+		const newStack = [...stack, frame];
+		if (node.selfSize > 0) sites.push({
+			...frame,
+			bytes: node.selfSize,
+			stack: newStack
+		});
+		for (const child of node.children || []) walk(child, newStack);
+	}
+	walk(profile.head, []);
+	return sites.sort((a, b) => b.bytes - a.bytes);
+}
+/** Check if site is user code (not node internals) */
+function isNodeUserCode(site) {
+	if (!site.url) return false;
+	if (site.url.startsWith("node:")) return false;
+	if (site.url.includes("(native)")) return false;
+	if (site.url.includes("internal/")) return false;
+	return true;
+}
+/** Check if site is user code (not browser internals) */
+function isBrowserUserCode(site) {
+	if (!site.url) return false;
+	if (site.url.startsWith("chrome-extension://")) return false;
+	if (site.url.startsWith("devtools://")) return false;
+	if (site.url.includes("(native)")) return false;
+	return true;
+}
+/** Filter sites to user code only */
+function filterSites(sites, isUser = isNodeUserCode) {
+	return sites.filter(isUser);
+}
+/** Aggregate sites by location (combine same file:line:col) */
+function aggregateSites(sites) {
+	const byLocation = /* @__PURE__ */ new Map();
+	for (const site of sites) {
+		const key = `${site.url}:${site.line}:${site.col}`;
+		const existing = byLocation.get(key);
+		if (existing) existing.bytes += site.bytes;
+		else byLocation.set(key, { ...site });
+	}
+	return [...byLocation.values()].sort((a, b) => b.bytes - a.bytes);
+}
+function fmtBytes(bytes) {
+	if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+	if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${bytes} B`;
+}
+/** Format heap report for console output */
+function formatHeapReport(sites, options) {
+	const { topN, stackDepth = 3, verbose = false } = options;
+	const { totalAll, totalUserCode, sampleCount } = options;
+	const isUser = options.isUserCode ?? isNodeUserCode;
+	const lines = [];
+	lines.push(`Heap allocation sites (top ${topN}, garbage included):`);
+	for (const site of sites.slice(0, topN)) if (verbose) formatVerboseSite(lines, site, stackDepth, isUser);
+	else formatCompactSite(lines, site, stackDepth, isUser);
+	lines.push("");
+	if (totalAll !== void 0) lines.push(`Total (all):       ${fmtBytes(totalAll)}`);
+	if (totalUserCode !== void 0) lines.push(`Total (user-code): ${fmtBytes(totalUserCode)}`);
+	if (sampleCount !== void 0) lines.push(`Samples: ${sampleCount.toLocaleString()}`);
+	return lines.join("\n");
+}
+/** Compact single-line format: `49 MB  fn1 <- fn2 <- fn3` */
+function formatCompactSite(lines, site, stackDepth, isUser) {
+	const bytes = fmtBytes(site.bytes).padStart(10);
+	const fns = [site.fn];
+	if (site.stack && site.stack.length > 1) {
+		const callers = site.stack.slice(0, -1).reverse().slice(0, stackDepth);
+		for (const frame of callers) {
+			if (!frame.url || !isUser(frame)) continue;
+			fns.push(frame.fn);
+		}
+	}
+	const line = `${bytes}  ${fns.join(" <- ")}`;
+	lines.push(isUser(site) ? line : pico.dim(line));
+}
+/** Verbose multi-line format with file:// paths and line numbers */
+function formatVerboseSite(lines, site, stackDepth, isUser) {
+	const bytes = fmtBytes(site.bytes).padStart(10);
+	const loc = site.url ? `${site.url}:${site.line}:${site.col}` : "(unknown)";
+	const dimFn = isUser(site) ? (s) => s : pico.dim;
+	lines.push(dimFn(`${bytes}  ${site.fn}  ${loc}`));
+	if (site.stack && site.stack.length > 1) {
+		const callers = site.stack.slice(0, -1).reverse().slice(0, stackDepth);
+		for (const frame of callers) {
+			if (!frame.url || !isUser(frame)) continue;
+			const callerLoc = `${frame.url}:${frame.line}:${frame.col}`;
+			lines.push(dimFn(`            <- ${frame.fn}  ${callerLoc}`));
+		}
+	}
+}
+
+//#endregion
+//#region src/html/HtmlTemplate.ts
+const skipArgs = new Set([
+	"_",
+	"$0",
+	"html",
+	"export-html"
+]);
+/** Format ISO date as local time with UTC: "Jan 9, 2026, 3:45 PM (2026-01-09T23:45:00Z)" */
+function formatDateWithTimezone(isoDate) {
+	const date = new Date(isoDate);
+	return `${date.toLocaleString("en-US", {
+		month: "short",
+		day: "numeric",
+		year: "numeric",
+		hour: "numeric",
+		minute: "2-digit"
+	})} (${date.toISOString().replace(".000Z", "Z")})`;
+}
+/** Format relative time: "5m ago", "2h ago", "yesterday", "3 days ago" */
+function formatRelativeTime(isoDate) {
+	const date = new Date(isoDate);
+	const diffMs = (/* @__PURE__ */ new Date()).getTime() - date.getTime();
+	const diffMins = Math.floor(diffMs / 6e4);
+	const diffHours = Math.floor(diffMs / 36e5);
+	const diffDays = Math.floor(diffMs / 864e5);
+	if (diffMins < 1) return "just now";
+	if (diffMins < 60) return `${diffMins}m ago`;
+	if (diffHours < 24) return `${diffHours}h ago`;
+	if (diffDays === 1) return "yesterday";
+	if (diffDays < 30) return `${diffDays} days ago`;
+	return date.toLocaleDateString("en-US", {
+		month: "short",
+		day: "numeric"
+	});
+}
+/** Format git version for display: "abc1234* (5m ago)" */
+function formatVersion(version) {
+	if (!version || version.hash === "unknown") return "unknown";
+	const hashDisplay = version.dirty ? `${version.hash}*` : version.hash;
+	const timeDisplay = version.date ? formatRelativeTime(version.date) : "";
+	return timeDisplay ? `${hashDisplay} (${timeDisplay})` : hashDisplay;
+}
+/** Render current/baseline version info as an HTML div */
+function versionInfoHtml(data) {
+	const { currentVersion, baselineVersion } = data.metadata;
+	if (!currentVersion && !baselineVersion) return "";
+	const parts = [];
+	if (currentVersion) parts.push(`Current: ${formatVersion(currentVersion)}`);
+	if (baselineVersion) parts.push(`Baseline: ${formatVersion(baselineVersion)}`);
+	return `<div class="version-info">${parts.join(" | ")}</div>`;
+}
+const badgeLabels = {
+	faster: "Faster",
+	slower: "Slower",
+	uncertain: "Inconclusive"
+};
+/** Render faster/slower/uncertain badge with CI plot container */
+function comparisonBadge(group, groupIndex) {
+	const ci = group.benchmarks[0]?.comparisonCI;
+	if (!ci) return "";
+	const label = badgeLabels[ci.direction];
+	return `
+    <span class="badge badge-${ci.direction}">${label}</span>
+    <div id="ci-plot-${groupIndex}" class="ci-plot-container"></div>
+  `;
+}
+const defaultArgs = {
+	worker: true,
+	time: 5,
+	warmup: 500,
+	"pause-interval": 0,
+	"pause-duration": 100
+};
+/** @return true if this CLI arg should be hidden from the report header */
+function shouldSkipArg(key, value, adaptive) {
+	if (skipArgs.has(key) || value === void 0 || value === false) return true;
+	if (defaultArgs[key] === value) return true;
+	if (!key.includes("-") && key !== key.toLowerCase()) return true;
+	if (key === "convergence" && !adaptive) return true;
+	return false;
+}
+/** Reconstruct the CLI invocation string, omitting default/internal args */
+function formatCliArgs(args) {
+	if (!args) return "bb bench";
+	const parts = ["bb bench"];
+	for (const [key, value] of Object.entries(args)) {
+		if (shouldSkipArg(key, value, args.adaptive)) continue;
+		parts.push(value === true ? `--${key}` : `--${key} ${value}`);
+	}
+	return parts.join(" ");
+}
+/** Generate complete HTML document with embedded data and visualizations */
+function generateHtmlDocument(data) {
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Benchmark Report - ${(/* @__PURE__ */ new Date()).toLocaleDateString()}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: #f5f5f5;
+      padding: 20px;
+      line-height: 1.6;
+    }
+    .header {
+      background: white;
+      padding: 10px 15px;
+      border-radius: 8px;
+      margin-bottom: 20px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    h1 { display: none; }
+    h2 {
+      color: #555;
+      margin: 30px 0 20px;
+      font-size: 20px;
+      border-bottom: 2px solid #e0e0e0;
+      padding-bottom: 10px;
+    }
+    .metadata { color: #666; font-size: 12px; }
+    .cli-args {
+      font-family: "SF Mono", Monaco, "Consolas", monospace;
+      font-size: 11px;
+      color: #555;
+      background: #f0f0f0;
+      padding: 6px 10px;
+      border-radius: 4px;
+      word-break: break-word;
+    }
+    .comparison-mode {
+      background: #fff3cd;
+      color: #856404;
+      padding: 8px 12px;
+      border-radius: 4px;
+      display: inline-block;
+      margin-top: 10px;
+      font-weight: 500;
+    }
+    .plot-grid {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 20px;
+      margin-bottom: 30px;
+    }
+    .plot-grid.second-row { grid-template-columns: 1fr; }
+    .plot-container {
+      background: white;
+      padding: 20px;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .plot-container.full-width { grid-column: 1 / -1; }
+    .plot-title { font-size: 18px; font-weight: 600; margin-bottom: 8px; color: #333; }
+    .plot-description { font-size: 14px; color: #666; margin-bottom: 15px; }
+    .plot-area {
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 300px;
+    }
+    .plot-area svg { overflow: visible; }
+    .plot-area svg g[aria-label="x-axis label"] text { font-size: 14px; }
+    .summary-stats { background: #f8f9fa; padding: 15px; border-radius: 6px; margin-top: 20px; }
+    .stats-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+      gap: 10px;
+      margin-top: 10px;
+    }
+    .stat-item { background: white; padding: 10px; border-radius: 4px; text-align: center; }
+    .stat-label { font-size: 12px; color: #666; text-transform: uppercase; letter-spacing: 0.5px; }
+    .stat-value { font-size: 18px; font-weight: 600; color: #333; margin-top: 4px; }
+    .loading { color: #666; font-style: italic; padding: 20px; text-align: center; }
+    .error { color: #d32f2f; background: #ffebee; padding: 15px; border-radius: 4px; margin: 10px 0; }
+    .ci-faster { color: #22c55e; }
+    .ci-slower { color: #ef4444; }
+    .ci-uncertain { color: #6b7280; }
+    .group-header {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      margin: 30px 0 20px;
+      padding-bottom: 10px;
+      border-bottom: 2px solid #e0e0e0;
+    }
+    .group-header h2 { margin: 0; border: none; padding: 0; }
+    .badge {
+      font-size: 12px;
+      font-weight: 600;
+      padding: 4px 10px;
+      border-radius: 12px;
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+    }
+    .badge-faster { background: #dcfce7; color: #166534; }
+    .badge-slower { background: #fee2e2; color: #991b1b; }
+    .badge-uncertain { background: #dbeafe; color: #1e40af; }
+    .version-info { font-size: 12px; color: #666; margin-top: 6px; }
+    .header-right { text-align: right; }
+    .ci-plot-container { display: inline-block; vertical-align: middle; margin-left: 8px; }
+    .ci-plot-container svg { display: block; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <div class="cli-args">${formatCliArgs(data.metadata.cliArgs)}</div>
+    <div class="header-right">
+      <div class="metadata">Generated: ${formatDateWithTimezone((/* @__PURE__ */ new Date()).toISOString())}</div>
+      ${versionInfoHtml(data)}
+    </div>
+  </div>
+
+  ${data.groups.map((group, i) => `
+    <div id="group-${i}">
+      ${group.benchmarks.length > 0 ? `
+        <div class="group-header">
+          <h2>${group.name}</h2>
+          ${comparisonBadge(group, i)}
+        </div>
+
+        <div class="plot-grid">
+          <div class="plot-container">
+            <div class="plot-title">Time per Sample</div>
+            <div class="plot-description">Execution time for each sample in collection order</div>
+            <div id="sample-timeseries-${i}" class="plot-area">
+              <div class="loading">Loading time series...</div>
+            </div>
+          </div>
+
+          <div class="plot-container">
+            <div class="plot-title">Time Distribution</div>
+            <div class="plot-description">Frequency distribution of execution times</div>
+            <div id="histogram-${i}" class="plot-area">
+              <div class="loading">Loading histogram...</div>
+            </div>
+          </div>
+        </div>
+
+        <div id="stats-${i}"></div>
+      ` : "<div class=\"error\">No benchmark data available for this group</div>"}
+    </div>
+  `).join("")}
+
+  <script type="importmap">
+    {
+      "imports": {
+        "d3": "https://cdn.jsdelivr.net/npm/d3@7/+esm",
+        "@observablehq/plot": "https://cdn.jsdelivr.net/npm/@observablehq/plot@0.6/+esm"
+      }
+    }
+  <\/script>
+  <script type="module">
+    import { renderPlots } from "./plots.js";
+    const benchmarkData = ${JSON.stringify(data, null, 2)};
+    renderPlots(benchmarkData);
+  <\/script>
+</body>
+</html>`;
+}
+
+//#endregion
+//#region src/html/HtmlReport.ts
+/** Generate HTML report from prepared data and optionally open in browser */
+async function generateHtmlReport(data, options) {
+	const html = generateHtmlDocument(data);
+	const reportDir = options.outputPath || await createReportDir();
+	await mkdir(reportDir, { recursive: true });
+	await writeFile(join(reportDir, "index.html"), html, "utf-8");
+	const plots = await loadPlotsBundle();
+	await writeFile(join(reportDir, "plots.js"), plots, "utf-8");
+	await writeLatestRedirect(reportDir);
+	let server;
+	let closeServer;
+	if (options.openBrowser) {
+		const baseDir = dirname(reportDir);
+		const reportName = reportDir.split("/").pop();
+		const result = await startReportServer(baseDir, 7979, 7978, 7977);
+		server = result.server;
+		closeServer = () => result.server.close();
+		const openUrl = `http://localhost:${result.port}/${reportName}/`;
+		await open(openUrl);
+		console.log(`Report opened in browser: ${openUrl}`);
+	} else console.log(`Report saved to: ${reportDir}/`);
+	return {
+		reportDir,
+		server,
+		closeServer
+	};
+}
+/** Start HTTP server for report directory, trying fallback ports if needed */
+async function startReportServer(baseDir, ...ports) {
+	const mimeTypes = {
+		".html": "text/html",
+		".js": "application/javascript",
+		".css": "text/css",
+		".json": "application/json"
+	};
+	const server = createServer(async (req, res) => {
+		const url = req.url || "/";
+		const filePath = join(baseDir, url.endsWith("/") ? url + "index.html" : url);
+		try {
+			const content = await readFile(filePath);
+			const mime = mimeTypes[extname(filePath)] || "application/octet-stream";
+			res.setHeader("Content-Type", mime);
+			res.end(content);
+		} catch {
+			res.statusCode = 404;
+			res.end("Not found");
+		}
+	});
+	for (const port of ports) try {
+		return await tryListen(server, port);
+	} catch {}
+	return tryListen(server, 0);
+}
+/** Listen on a port, resolving with the actual port or rejecting on error */
+function tryListen(server, port) {
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, () => {
+			server.removeListener("error", reject);
+			const addr = server.address();
+			resolve({
+				server,
+				port: typeof addr === "object" && addr ? addr.port : port
+			});
+		});
+	});
+}
+/** Create a timestamped report directory under ./bench-report/ */
+async function createReportDir() {
+	const base = "./bench-report";
+	await mkdir(base, { recursive: true });
+	return join(base, `report-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}`);
+}
+/** Read the pre-built browser plots bundle from dist/ */
+async function loadPlotsBundle() {
+	const thisDir = dirname(fileURLToPath(import.meta.url));
+	const builtPath = join(thisDir, "browser/index.js");
+	const devPath = join(thisDir, "../../dist/browser/index.js");
+	try {
+		return await readFile(builtPath, "utf-8");
+	} catch {}
+	return readFile(devPath, "utf-8");
+}
+/** Write an index.html in the parent dir that redirects to this report */
+async function writeLatestRedirect(reportDir) {
+	const baseDir = dirname(reportDir);
+	const reportName = reportDir.split("/").pop();
+	const html = `<!DOCTYPE html>
+<html><head>
+  <meta http-equiv="refresh" content="0; url=./${reportName}/">
+  <script>location.href = "./${reportName}/";<\/script>
+</head><body>
+  <a href="./${reportName}/">Latest report</a>
+</body></html>`;
+	await writeFile(join(baseDir, "index.html"), html, "utf-8");
+}
+
+//#endregion
+//#region src/matrix/MatrixFilter.ts
+/** Parse filter string: "case/variant", "case/", "/variant", or "case" */
+function parseMatrixFilter(filter) {
+	if (filter.includes("/")) {
+		const [casePart, variantPart] = filter.split("/", 2);
+		return {
+			case: casePart || void 0,
+			variant: variantPart || void 0
+		};
+	}
+	return { case: filter };
+}
+/** Apply filter to a matrix, merging with existing filters via intersection */
+async function filterMatrix(matrix, filter) {
+	if (!filter || !filter.case && !filter.variant) return matrix;
+	const caseList = await getFilteredCases(matrix, filter.case);
+	const variantList = await getFilteredVariants(matrix, filter.variant);
+	const filteredCases = caseList && matrix.filteredCases ? caseList.filter((c) => matrix.filteredCases.includes(c)) : caseList ?? matrix.filteredCases;
+	const filteredVariants = variantList && matrix.filteredVariants ? variantList.filter((v) => matrix.filteredVariants.includes(v)) : variantList ?? matrix.filteredVariants;
+	return {
+		...matrix,
+		filteredCases,
+		filteredVariants
+	};
+}
+/** Get case IDs matching filter pattern */
+async function getFilteredCases(matrix, casePattern) {
+	if (!casePattern) return void 0;
+	const caseIds = matrix.casesModule ? (await loadCasesModule(matrix.casesModule)).cases : matrix.cases;
+	if (!caseIds) return ["default"];
+	const filtered = caseIds.filter((id) => matchPattern(id, casePattern));
+	if (filtered.length === 0) throw new Error(`No cases match filter: "${casePattern}"`);
+	return filtered;
+}
+/** Get variant IDs matching filter pattern */
+async function getFilteredVariants(matrix, variantPattern) {
+	if (!variantPattern) return void 0;
+	if (matrix.variants) {
+		const ids = Object.keys(matrix.variants).filter((id) => matchPattern(id, variantPattern));
+		if (ids.length === 0) throw new Error(`No variants match filter: "${variantPattern}"`);
+		return ids;
+	}
+	if (matrix.variantDir) {
+		const filtered = (await discoverVariants(matrix.variantDir)).filter((id) => matchPattern(id, variantPattern));
+		if (filtered.length === 0) throw new Error(`No variants match filter: "${variantPattern}"`);
+		return filtered;
+	}
+	throw new Error("BenchMatrix requires 'variants' or 'variantDir'");
+}
+/** Match id against pattern (case-insensitive substring) */
+function matchPattern(id, pattern) {
+	return id.toLowerCase().includes(pattern.toLowerCase());
+}
+
+//#endregion
+//#region src/table-util/ConvergenceFormatters.ts
+const { red } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? { red: (str) => str } : pico;
+const lowConfidence = 80;
+/** @return convergence percentage with color for low values */
+function formatConvergence(v) {
+	if (typeof v !== "number") return "—";
+	const pct = `${Math.round(v)}%`;
+	return v < lowConfidence ? red(pct) : pct;
+}
+
+//#endregion
+//#region src/StandardSections.ts
+/** Section: mean, p50, p99 timing with convergence */
+const timeSection = {
+	extract: (results) => ({
+		mean: results.time?.avg,
+		p50: results.time?.p50,
+		p99: results.time?.p99,
+		convergence: results.convergence?.confidence
+	}),
+	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
+			}
+		]
+	}, { columns: [{
+		key: "convergence",
+		title: "conv%",
+		formatter: formatConvergence
+	}] }]
+};
+/** Section: GC time as fraction of total benchmark time (Node performance hooks) */
+const gcSection = {
+	extract: (results) => {
+		const { nodeGcTime, time, samples } = results;
+		if (!nodeGcTime || !time?.avg) return { gc: void 0 };
+		const totalBenchTime = time.avg * samples.length;
+		if (totalBenchTime <= 0) return { gc: void 0 };
+		const gcTime = nodeGcTime.inRun / totalBenchTime;
+		return { gc: gcTime <= 1 ? gcTime : void 0 };
+	},
+	columns: () => [{
+		groupTitle: "gc",
+		columns: [{
+			key: "gc",
+			title: "mean",
+			formatter: percent,
+			comparable: true
+		}]
+	}]
+};
+/** Section: detailed GC stats from --trace-gc-nvp (allocation, promotion, pauses) */
+const gcStatsSection = {
+	extract: (results) => {
+		const { gcStats, samples } = results;
+		if (!gcStats) return {};
+		const iterations = samples.length || 1;
+		const { totalAllocated, totalPromoted } = gcStats;
+		const promoPercent = totalAllocated && totalAllocated > 0 ? (totalPromoted ?? 0) / totalAllocated : void 0;
+		return {
+			allocPerIter: totalAllocated != null ? totalAllocated / iterations : void 0,
+			collected: gcStats.totalCollected || void 0,
+			scavenges: gcStats.scavenges,
+			fullGCs: gcStats.markCompacts,
+			promoPercent,
+			pausePerIter: gcStats.gcPauseTime / iterations
+		};
+	},
+	columns: () => [{
+		groupTitle: "gc",
+		columns: [
+			{
+				key: "allocPerIter",
+				title: "alloc/iter",
+				formatter: formatBytes
+			},
+			{
+				key: "collected",
+				title: "collected",
+				formatter: formatBytes
+			},
+			{
+				key: "scavenges",
+				title: "scav",
+				formatter: integer
+			},
+			{
+				key: "fullGCs",
+				title: "full",
+				formatter: integer
+			},
+			{
+				key: "promoPercent",
+				title: "promo%",
+				formatter: percent
+			},
+			{
+				key: "pausePerIter",
+				title: "pause/iter",
+				formatter: timeMs
+			}
+		]
+	}]
+};
+/** Browser GC section: only fields available from CDP tracing */
+const browserGcStatsSection = {
+	extract: gcStatsSection.extract,
+	columns: () => [{
+		groupTitle: "gc",
+		columns: [
+			{
+				key: "collected",
+				title: "collected",
+				formatter: formatBytes
+			},
+			{
+				key: "scavenges",
+				title: "scav",
+				formatter: integer
+			},
+			{
+				key: "fullGCs",
+				title: "full",
+				formatter: integer
+			},
+			{
+				key: "pausePerIter",
+				title: "pause",
+				formatter: timeMs
+			}
+		]
+	}]
+};
+/** Section: CPU L1 cache miss rate and stall rate (requires @mitata/counters) */
+const cpuSection = {
+	extract: (results) => ({
+		cpuCacheMiss: results.cpuCacheMiss,
+		cpuStall: results.cpuStall
+	}),
+	columns: () => [{
+		groupTitle: "cpu",
+		columns: [{
+			key: "cpuCacheMiss",
+			title: "L1 miss",
+			formatter: percent
+		}, {
+			key: "cpuStall",
+			title: "stalls",
+			formatter: percentPrecision(2)
+		}]
+	}]
+};
+/** Section: number of sample iterations */
+const runsSection = {
+	extract: (results) => ({ runs: results.samples.length }),
+	columns: () => [{ columns: [{
+		key: "runs",
+		title: "runs",
+		formatter: integer
+	}] }]
+};
+/** Section: total sampling duration in seconds (brackets if >= 30s) */
+const totalTimeSection = {
+	extract: (results) => ({ totalTime: results.totalTime }),
+	columns: () => [{ columns: [{
+		key: "totalTime",
+		title: "time",
+		formatter: (v) => {
+			if (typeof v !== "number") return "";
+			return v >= 30 ? `[${v.toFixed(1)}s]` : `${v.toFixed(1)}s`;
+		}
+	}] }]
+};
+/** Section: median, mean, p99, and convergence for adaptive mode */
+const adaptiveSection = {
+	extract: (results) => ({
+		median: results.time?.p50,
+		mean: results.time?.avg,
+		p99: results.time?.p99,
+		convergence: results.convergence?.confidence
+	}),
+	columns: () => [{
+		groupTitle: "time",
+		columns: [
+			{
+				key: "median",
+				title: "median",
+				formatter: timeMs,
+				comparable: true
+			},
+			{
+				key: "mean",
+				title: "mean",
+				formatter: timeMs,
+				comparable: true
+			},
+			{
+				key: "p99",
+				title: "p99",
+				formatter: timeMs
+			}
+		]
+	}, { columns: [{
+		key: "convergence",
+		title: "conv%",
+		formatter: formatConvergence
+	}] }]
+};
+/** Build generic sections based on CLI flags */
+function buildGenericSections(args) {
+	const sections = [];
+	if (args["gc-stats"]) sections.push(gcStatsSection);
+	sections.push(runsSection);
+	return sections;
+}
+/** Section: V8 optimization tier distribution and deopt count */
+const optSection = {
+	extract: (results) => {
+		const opt = results.optStatus;
+		if (!opt) return {};
+		const total = Object.values(opt.byTier).reduce((s, t) => s + t.count, 0);
+		return {
+			tiers: Object.entries(opt.byTier).sort((a, b) => b[1].count - a[1].count).map(([name, t]) => `${name}:${(t.count / total * 100).toFixed(0)}%`).join(" "),
+			deopt: opt.deoptCount > 0 ? opt.deoptCount : void 0
+		};
+	},
+	columns: () => [{
+		groupTitle: "v8 opt",
+		columns: [{
+			key: "tiers",
+			title: "tiers",
+			formatter: (v) => typeof v === "string" ? v : ""
+		}, {
+			key: "deopt",
+			title: "deopt",
+			formatter: (v) => typeof v === "number" ? String(v) : ""
+		}]
+	}]
+};
+
+//#endregion
+//#region src/matrix/MatrixReport.ts
+/** Format matrix results as one table per case */
+function reportMatrixResults(results, options) {
+	const tables = buildCaseTables(results, options);
+	return [`Matrix: ${results.name}`, ...tables].join("\n\n");
+}
+/** Build one table for each case showing all variants */
+function buildCaseTables(results, options) {
+	if (results.variants.length === 0) return [];
+	return results.variants[0].cases.map((c) => c.caseId).map((caseId) => buildCaseTable(results, caseId, options));
+}
+/** Build table for a single case showing all variants */
+function buildCaseTable(results, caseId, options) {
+	const caseTitle = formatCaseTitle(results, caseId);
+	if (options?.sections?.length) return buildSectionTable(results, caseId, options, caseTitle);
+	const rows = buildCaseRows(results, caseId, options?.extraColumns);
+	return `${caseTitle}\n${buildTable(buildColumns(rows.some((r) => r.diffCI), options), [{ results: rows }])}`;
+}
+/** Build table using ResultsMapper sections */
+function buildSectionTable(results, caseId, options, caseTitle) {
+	const sections = options.sections;
+	const variantTitle = options.variantTitle ?? "name";
+	const rows = [];
+	let hasBaseline = false;
+	for (const variant of results.variants) {
+		const caseResult = variant.cases.find((c) => c.caseId === caseId);
+		if (!caseResult) continue;
+		const row = { name: truncate(variant.id, 25) };
+		for (const section of sections) Object.assign(row, section.extract(caseResult.measured, caseResult.metadata));
+		if (caseResult.baseline) {
+			hasBaseline = true;
+			const { samples: base } = caseResult.baseline;
+			row.diffCI = bootstrapDifferenceCI(base, caseResult.measured.samples);
+		}
+		rows.push(row);
+	}
+	return `${caseTitle}\n${buildTable(buildSectionColumns(sections, variantTitle, hasBaseline), [{ results: rows }])}`;
+}
+/** Build column groups from ResultsMapper sections */
+function buildSectionColumns(sections, variantTitle, hasBaseline) {
+	const nameCol = { columns: [{
+		key: "name",
+		title: variantTitle
+	}] };
+	const sectionColumns = sections.flatMap((s) => s.columns());
+	return [nameCol, ...hasBaseline ? injectDiffColumns(sectionColumns) : sectionColumns];
+}
+/** Build rows for all variants for a given case */
+function buildCaseRows(results, caseId, extraColumns) {
+	return results.variants.flatMap((variant) => {
+		const caseResult = variant.cases.find((c) => c.caseId === caseId);
+		return caseResult ? [buildRow(variant.id, caseResult, extraColumns)] : [];
+	});
+}
+/** Build a single row from case result */
+function buildRow(variantId, caseResult, extraColumns) {
+	const { measured, baseline } = caseResult;
+	const samples = measured.samples;
+	const time = measured.time?.avg ?? average(samples);
+	const row = {
+		name: truncate(variantId, 25),
+		time,
+		samples: samples.length
+	};
+	if (baseline) row.diffCI = bootstrapDifferenceCI(baseline.samples, samples);
+	if (extraColumns) for (const col of extraColumns) row[col.key] = col.extract(caseResult);
+	return row;
+}
+/** Build column configuration */
+function buildColumns(hasBaseline, options) {
+	const groups = [{ columns: [{
+		key: "name",
+		title: options?.variantTitle ?? "variant"
+	}] }, { columns: [{
+		key: "time",
+		title: "time",
+		formatter: duration
+	}, ...hasBaseline ? [{
+		key: "diffCI",
+		title: "Δ% CI",
+		formatter: formatDiff
+	}] : []] }];
+	const extraColumns = options?.extraColumns;
+	if (extraColumns?.length) {
+		const byGroup = /* @__PURE__ */ new Map();
+		for (const col of extraColumns) {
+			const group = byGroup.get(col.groupTitle) ?? [];
+			group.push(col);
+			byGroup.set(col.groupTitle, group);
+		}
+		for (const [groupTitle, cols] of byGroup) groups.push({
+			groupTitle,
+			columns: cols.map((col) => ({
+				key: col.key,
+				title: col.title,
+				formatter: col.formatter ?? String
+			}))
+		});
+	}
+	return groups;
+}
+/** Format diff with CI, or "baseline" marker */
+function formatDiff(value) {
+	if (!value) return null;
+	return formatDiffWithCI(value);
+}
+/** Format case title with metadata if available */
+function formatCaseTitle(results, caseId) {
+	const metadata = (results.variants[0]?.cases.find((c) => c.caseId === caseId))?.metadata;
+	if (metadata && Object.keys(metadata).length > 0) return `${caseId} (${Object.entries(metadata).map(([k, v]) => `${v} ${k}`).join(", ")})`;
+	return caseId;
+}
+/** GC statistics columns - derived from gcStatsSection for consistency */
+const gcStatsColumns = gcStatsSection.columns()[0].columns.map((col) => ({
+	key: col.key,
+	title: col.title,
+	groupTitle: "GC",
+	extract: (r) => gcStatsSection.extract(r.measured)[col.key],
+	formatter: (v) => col.formatter?.(v) ?? "-"
+}));
+/** Format bytes with fallback to "-" for missing values */
+function formatBytesOrDash(value) {
+	return formatBytes(value) ?? "-";
+}
+/** GC pause time column */
+const gcPauseColumn = {
+	key: "gcPause",
+	title: "pause",
+	groupTitle: "GC",
+	extract: (r) => r.measured.gcStats?.gcPauseTime,
+	formatter: (v) => v != null ? `${v.toFixed(1)}ms` : "-"
+};
+/** Heap sampling total bytes column */
+const heapTotalColumn = {
+	key: "heapTotal",
+	title: "heap",
+	extract: (r) => {
+		const profile = r.measured.heapProfile;
+		if (!profile?.head) return void 0;
+		return totalProfileBytes(profile);
+	},
+	formatter: formatBytesOrDash
+};
+
+//#endregion
+//#region src/cli/FilterBenchmarks.ts
+/** Filter benchmarks by name pattern */
+function filterBenchmarks(suite, filter, removeEmpty = true) {
+	if (!filter) return suite;
+	const regex = createFilterRegex(filter);
+	const groups = suite.groups.map((group) => ({
+		...group,
+		benchmarks: group.benchmarks.filter((bench) => regex.test(stripCaseSuffix(bench.name))),
+		baseline: group.baseline && regex.test(stripCaseSuffix(group.baseline.name)) ? group.baseline : void 0
+	})).filter((group) => !removeEmpty || group.benchmarks.length > 0);
+	validateFilteredSuite(groups, filter);
+	return {
+		name: suite.name,
+		groups
+	};
+}
+/** Create regex from filter (literal unless regex-like) */
+function createFilterRegex(filter) {
+	if (filter.startsWith("/") && filter.endsWith("/") || filter.includes("*") || filter.includes("?") || filter.includes("[") || filter.includes("|") || filter.startsWith("^") || filter.endsWith("$")) {
+		const pattern = filter.startsWith("/") && filter.endsWith("/") ? filter.slice(1, -1) : filter;
+		try {
+			return new RegExp(pattern, "i");
+		} catch {
+			return new RegExp(escapeRegex(filter), "i");
+		}
+	}
+	return new RegExp("^" + escapeRegex(filter), "i");
+}
+/** Strip case suffix like " [large]" from benchmark name for filtering */
+function stripCaseSuffix(name) {
+	return name.replace(/ \[.*?\]$/, "");
+}
+/** Escape regex special characters */
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Ensure at least one benchmark matches filter */
+function validateFilteredSuite(groups, filter) {
+	if (groups.every((g) => g.benchmarks.length === 0)) throw new Error(`No benchmarks match filter: "${filter}"`);
+}
+
+//#endregion
+//#region src/cli/RunBenchCLI.ts
+/** Validate CLI argument combinations */
+function validateArgs(args) {
+	if (args["gc-stats"] && !args.worker && !args.url) throw new Error("--gc-stats requires worker mode (the default). Remove --no-worker flag.");
+}
+/** Warn about Node-only flags that are ignored in browser mode. */
+function warnBrowserFlags(args) {
+	const ignored = [];
+	if (!args.worker) ignored.push("--no-worker");
+	if (args.cpu) ignored.push("--cpu");
+	if (args["trace-opt"]) ignored.push("--trace-opt");
+	if (args.collect) ignored.push("--collect");
+	if (args.adaptive) ignored.push("--adaptive");
+	if (args.batches > 1) ignored.push("--batches");
+	if (ignored.length) console.warn(yellow(`Ignored in browser mode: ${ignored.join(", ")}`));
+}
+/** Parse CLI with custom configuration */
+function parseBenchArgs(configureArgs) {
+	return parseCliArgs(hideBin(process.argv), configureArgs);
+}
+/** Run suite with CLI arguments */
+async function runBenchmarks(suite, args) {
+	validateArgs(args);
+	const { filter, worker: useWorker, batches = 1 } = args;
+	const options = cliToRunnerOptions(args);
+	return runSuite({
+		suite: filterBenchmarks(suite, filter),
+		runner: "basic",
+		options,
+		useWorker,
+		batches
+	});
+}
+/** Execute all groups in suite */
+async function runSuite(params) {
+	const { suite, runner, options, useWorker, batches } = params;
+	const results = [];
+	for (const group of suite.groups) results.push(await runGroup(group, runner, options, useWorker, batches));
+	return results;
+}
+/** Execute group with shared setup, optionally batching to reduce ordering bias */
+async function runGroup(group, runner, options, useWorker, batches = 1) {
+	const { name, benchmarks, baseline, setup, metadata } = group;
+	const setupParams = await setup?.();
+	validateBenchmarkParameters(group);
+	const runParams = {
+		runner,
+		options,
+		useWorker,
+		params: setupParams,
+		metadata
+	};
+	if (batches === 1) return runSingleBatch(name, benchmarks, baseline, runParams);
+	return runMultipleBatches(name, benchmarks, baseline, runParams, batches);
+}
+/** Run benchmarks in a single batch */
+async function runSingleBatch(name, benchmarks, baseline, runParams) {
+	const baselineReport = baseline ? await runSingleBenchmark(baseline, runParams) : void 0;
+	return {
+		name,
+		reports: await serialMap(benchmarks, (b) => runSingleBenchmark(b, runParams)),
+		baseline: baselineReport
+	};
+}
+/** Run benchmarks in multiple batches, alternating order to reduce bias */
+async function runMultipleBatches(name, benchmarks, baseline, runParams, batches) {
+	const timePerBatch = (runParams.options.maxTime || 5e3) / batches;
+	const batchParams = {
+		...runParams,
+		options: {
+			...runParams.options,
+			maxTime: timePerBatch
+		}
+	};
+	const baselineBatches = [];
+	const benchmarkBatches = /* @__PURE__ */ new Map();
+	for (let i = 0; i < batches; i++) await runBatchIteration(benchmarks, baseline, batchParams, i % 2 === 1, baselineBatches, benchmarkBatches);
+	const meta = runParams.metadata;
+	return mergeBatchResults(name, benchmarks, baseline, baselineBatches, benchmarkBatches, meta);
+}
+/** Run one batch iteration in either order */
+async function runBatchIteration(benchmarks, baseline, runParams, reverseOrder, baselineBatches, benchmarkBatches) {
+	const runBaseline = async () => {
+		if (baseline) {
+			const r = await runSingleBenchmark(baseline, runParams);
+			baselineBatches.push(r.measuredResults);
+		}
+	};
+	const runBenches = async () => {
+		for (const b of benchmarks) {
+			const r = await runSingleBenchmark(b, runParams);
+			appendToMap(benchmarkBatches, b.name, r.measuredResults);
+		}
+	};
+	if (reverseOrder) {
+		await runBenches();
+		await runBaseline();
+	} else {
+		await runBaseline();
+		await runBenches();
+	}
+}
+/** Merge batch results into final ReportGroup */
+function mergeBatchResults(name, benchmarks, baseline, baselineBatches, benchmarkBatches, metadata) {
+	const mergedBaseline = baseline ? {
+		name: baseline.name,
+		measuredResults: mergeResults(baselineBatches),
+		metadata
+	} : void 0;
+	return {
+		name,
+		reports: benchmarks.map((b) => ({
+			name: b.name,
+			measuredResults: mergeResults(benchmarkBatches.get(b.name) || []),
+			metadata
+		})),
+		baseline: mergedBaseline
+	};
+}
+/** Run single benchmark and create report */
+async function runSingleBenchmark(spec, runParams) {
+	const { runner, options, useWorker, params, metadata } = runParams;
+	const [result] = await runBenchmark({
+		spec,
+		runner,
+		options,
+		useWorker,
+		params
+	});
+	return {
+		name: spec.name,
+		measuredResults: result,
+		metadata
+	};
+}
+/** Warn if parameterized benchmarks lack setup */
+function validateBenchmarkParameters(group) {
+	const { name, setup, benchmarks, baseline } = group;
+	if (setup) return;
+	const allBenchmarks = baseline ? [...benchmarks, baseline] : benchmarks;
+	for (const benchmark of allBenchmarks) if (benchmark.fn.length > 0) console.warn(`Benchmark "${benchmark.name}" in group "${name}" expects parameters but no setup() provided.`);
+}
+/** Merge multiple batch results into a single MeasuredResults */
+function mergeResults(results) {
+	if (results.length === 0) throw new Error("Cannot merge empty results array");
+	if (results.length === 1) return results[0];
+	const allSamples = results.flatMap((r) => r.samples);
+	const allWarmup = results.flatMap((r) => r.warmupSamples || []);
+	const time = computeStats(allSamples);
+	const convergence = checkConvergence(allSamples.map((s) => s * msToNs));
+	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),
+		convergence,
+		pausePoints: allPausePoints.length ? allPausePoints : void 0
+	};
+}
+function appendToMap(map, key, value) {
+	if (!map.has(key)) map.set(key, []);
+	map.get(key).push(value);
+}
+/** Generate table with standard sections */
+function defaultReport(groups, args) {
+	const { adaptive, "gc-stats": gcStats, "trace-opt": traceOpt } = args;
+	const hasCpu = hasField(groups, "cpu");
+	const hasOpt = hasField(groups, "optStatus");
+	return reportResults(groups, buildReportSections(adaptive, gcStats, hasCpu, traceOpt && hasOpt));
+}
+/** Build report sections based on CLI options */
+function buildReportSections(adaptive, gcStats, hasCpuData, hasOptData) {
+	const sections = adaptive ? [
+		adaptiveSection,
+		runsSection,
+		totalTimeSection
+	] : [timeSection, runsSection];
+	if (gcStats) sections.push(gcStatsSection);
+	if (hasCpuData) sections.push(cpuSection);
+	if (hasOptData) sections.push(optSection);
+	return sections;
+}
+/** Run benchmarks, display table, and optionally generate HTML report */
+async function benchExports(suite, args) {
+	const results = await runBenchmarks(suite, args);
+	const report = defaultReport(results, args);
+	console.log(report);
+	await finishReports(results, args, suite.name);
+}
+/** Run browser profiling via Playwright + CDP, report with standard pipeline */
+async function browserBenchExports(args) {
+	warnBrowserFlags(args);
+	const url = args.url;
+	const { iterations, time } = args;
+	const result = await profileBrowser({
+		url,
+		heapSample: args["heap-sample"],
+		heapOptions: {
+			samplingInterval: args["heap-interval"],
+			stackDepth: args["heap-depth"]
+		},
+		headless: args.headless,
+		timeout: args.timeout,
+		gcStats: args["gc-stats"],
+		maxTime: iterations ? Number.MAX_SAFE_INTEGER : time * 1e3,
+		maxIterations: iterations
+	});
+	const name = new URL(url).pathname.split("/").pop() || "browser";
+	const hasSamples = result.samples && result.samples.length > 0;
+	const results = browserResultGroups(name, result);
+	if (hasSamples || result.wallTimeMs != null) console.log(reportResults(results, [timeSection, runsSection]));
+	if (result.gcStats) console.log(reportResults(results, [browserGcStatsSection]));
+	if (result.heapProfile) printHeapReports(results, {
+		...cliHeapReportOptions(args),
+		isUserCode: isBrowserUserCode
+	});
+	await exportReports({
+		results,
+		args
+	});
+}
+/** Wrap browser profile result as ReportGroup[] for the standard pipeline */
+function browserResultGroups(name, result) {
+	const { gcStats, heapProfile } = result;
+	let measured;
+	if (result.samples && result.samples.length > 0) {
+		const { samples } = result;
+		const totalTime = result.wallTimeMs ? result.wallTimeMs / 1e3 : void 0;
+		measured = {
+			name,
+			samples,
+			time: computeStats(samples),
+			totalTime,
+			gcStats,
+			heapProfile
+		};
+	} else {
+		const wallMs = result.wallTimeMs ?? 0;
+		measured = {
+			name,
+			samples: [wallMs],
+			time: {
+				min: wallMs,
+				max: wallMs,
+				avg: wallMs,
+				p50: wallMs,
+				p75: wallMs,
+				p99: wallMs,
+				p999: wallMs
+			},
+			gcStats,
+			heapProfile
+		};
+	}
+	return [{
+		name,
+		reports: [{
+			name,
+			measuredResults: measured
+		}]
+	}];
+}
+/** Print heap allocation reports for benchmarks with heap profiles */
+function printHeapReports(groups, options) {
+	for (const group of groups) {
+		const allReports = group.baseline ? [...group.reports, group.baseline] : group.reports;
+		for (const report of allReports) {
+			const { heapProfile } = report.measuredResults;
+			if (!heapProfile) continue;
+			console.log(dim(`\n─── Heap profile: ${report.name} ───`));
+			const totalAll = totalProfileBytes(heapProfile);
+			const sites = flattenProfile(heapProfile);
+			const userSites = filterSites(sites, options.isUserCode);
+			const totalUserCode = userSites.reduce((sum, s) => sum + s.bytes, 0);
+			const aggregated = aggregateSites(options.userOnly ? userSites : sites);
+			const extra = {
+				totalAll,
+				totalUserCode,
+				sampleCount: heapProfile.samples?.length
+			};
+			console.log(formatHeapReport(aggregated, {
+				...options,
+				...extra
+			}));
+		}
+	}
+}
+/** Run benchmarks and display table. Suite is optional with --url (browser mode). */
+async function runDefaultBench(suite, configureArgs) {
+	const args = parseBenchArgs(configureArgs);
+	if (args.url) await browserBenchExports(args);
+	else if (suite) await benchExports(suite, args);
+	else throw new Error("Either --url or a BenchSuite is required.");
+}
+/** Convert CLI args to runner options */
+function cliToRunnerOptions(args) {
+	const { profile, collect, iterations } = args;
+	if (profile) return {
+		maxIterations: iterations ?? 1,
+		warmupTime: 0,
+		collect
+	};
+	if (args.adaptive) return createAdaptiveOptions(args);
+	return {
+		maxTime: iterations ? Number.POSITIVE_INFINITY : args.time * 1e3,
+		maxIterations: iterations,
+		...cliCommonOptions(args)
+	};
+}
+/** Create options for adaptive mode */
+function createAdaptiveOptions(args) {
+	return {
+		minTime: (args["min-time"] ?? 1) * 1e3,
+		maxTime: defaultAdaptiveMaxTime * 1e3,
+		targetConfidence: args.convergence,
+		adaptive: true,
+		...cliCommonOptions(args)
+	};
+}
+/** Runner/matrix options shared across all CLI modes */
+function cliCommonOptions(args) {
+	const { collect, cpu, warmup } = args;
+	const { "trace-opt": traceOpt, "skip-settle": noSettle } = args;
+	const { "pause-first": pauseFirst, "pause-interval": pauseInterval } = args;
+	const { "pause-duration": pauseDuration, "gc-stats": gcStats } = args;
+	const { "heap-sample": heapSample, "heap-interval": heapInterval } = args;
+	const { "heap-depth": heapDepth } = args;
+	return {
+		collect,
+		cpuCounters: cpu,
+		warmup,
+		traceOpt,
+		noSettle,
+		pauseFirst,
+		pauseInterval,
+		pauseDuration,
+		gcStats,
+		heapSample,
+		heapInterval,
+		heapDepth
+	};
+}
+const { yellow, dim } = process.env.NODE_ENV === "test" || process.env.VITEST === "true" ? {
+	yellow: (s) => s,
+	dim: (s) => s
+} : pico;
+/** Log V8 optimization tier distribution and deoptimizations */
+function reportOptStatus(groups) {
+	const optData = groups.flatMap(({ reports, baseline }) => {
+		return (baseline ? [...reports, baseline] : reports).filter((r) => r.measuredResults.optStatus).map((r) => ({
+			name: r.name,
+			opt: r.measuredResults.optStatus,
+			samples: r.measuredResults.samples.length
+		}));
+	});
+	if (optData.length === 0) return;
+	console.log(dim("\nV8 optimization:"));
+	for (const { name, opt, samples } of optData) {
+		const total = Object.values(opt.byTier).reduce((s, t) => s + t.count, 0);
+		const tierParts = Object.entries(opt.byTier).sort((a, b) => b[1].count - a[1].count).map(([tier, info]) => `${tier} ${(info.count / total * 100).toFixed(0)}%`).join(", ");
+		console.log(`  ${name}: ${tierParts} ${dim(`(${samples} samples)`)}`);
+	}
+	const totalDeopts = optData.reduce((s, d) => s + d.opt.deoptCount, 0);
+	if (totalDeopts > 0) console.log(yellow(`  ⚠ ${totalDeopts} deoptimization${totalDeopts > 1 ? "s" : ""} detected`));
+}
+/** @return true if any result has the specified field with a defined value */
+function hasField(results, field) {
+	return results.some(({ reports, baseline }) => {
+		return (baseline ? [...reports, baseline] : reports).some(({ measuredResults }) => measuredResults[field] !== void 0);
+	});
+}
+/** Print heap reports (if enabled) and export results */
+async function finishReports(results, args, suiteName, exportOptions) {
+	if (args["heap-sample"]) printHeapReports(results, cliHeapReportOptions(args));
+	await exportReports({
+		results,
+		args,
+		suiteName,
+		...exportOptions
+	});
+}
+/** Export reports (HTML, JSON, Perfetto) based on CLI args */
+async function exportReports(options) {
+	const { results, args, sections, suiteName } = options;
+	const { currentVersion, baselineVersion } = options;
+	const openInBrowser = args.html && !args["export-html"];
+	let closeServer;
+	if (args.html || args["export-html"]) closeServer = (await generateHtmlReport(prepareHtmlData(results, {
+		cliArgs: args,
+		sections,
+		currentVersion,
+		baselineVersion
+	}), {
+		openBrowser: openInBrowser,
+		outputPath: args["export-html"]
+	})).closeServer;
+	if (args.json) await exportBenchmarkJson(results, args.json, args, suiteName);
+	if (args.perfetto) exportPerfettoTrace(results, args.perfetto, args);
+	if (openInBrowser) {
+		await waitForCtrlC();
+		closeServer?.();
+	}
+}
+/** Wait for Ctrl+C before exiting */
+function waitForCtrlC() {
+	return new Promise((resolve) => {
+		console.log(dim("\nPress Ctrl+C to exit"));
+		process.on("SIGINT", () => {
+			console.log();
+			resolve();
+		});
+	});
+}
+/** Run matrix suite with CLI arguments.
+*  no options ==> defaultCases/defaultVariants, --filter ==> subset of defaults,
+*  --all --filter ==> subset of all, --all ==> all cases/variants */
+async function runMatrixSuite(suite, args) {
+	validateArgs(args);
+	const filter = args.filter ? parseMatrixFilter(args.filter) : void 0;
+	const options = cliToMatrixOptions(args);
+	const results = [];
+	for (const matrix of suite.matrices) {
+		const casesModule = matrix.casesModule ? await loadCasesModule(matrix.casesModule) : void 0;
+		let filtered = matrix;
+		if (!args.all && casesModule) filtered = {
+			...matrix,
+			filteredCases: casesModule.defaultCases,
+			filteredVariants: casesModule.defaultVariants
+		};
+		if (filter) filtered = await filterMatrix(filtered, filter);
+		const { filteredCases, filteredVariants } = filtered;
+		results.push(await runMatrix(filtered, {
+			...options,
+			filteredCases,
+			filteredVariants
+		}));
+	}
+	return results;
+}
+/** Convert CLI args to matrix run options */
+function cliToMatrixOptions(args) {
+	const { time, iterations, worker } = args;
+	return {
+		iterations,
+		maxTime: iterations ? void 0 : time * 1e3,
+		useWorker: worker,
+		...cliCommonOptions(args)
+	};
+}
+/** Generate report for matrix results. Uses same sections as regular benchmarks. */
+function defaultMatrixReport(results, reportOptions, args) {
+	const options = args ? mergeMatrixDefaults(reportOptions, args, results) : reportOptions;
+	return results.map((r) => reportMatrixResults(r, options)).join("\n\n");
+}
+/** @return HeapReportOptions from CLI args */
+function cliHeapReportOptions(args) {
+	return {
+		topN: args["heap-rows"],
+		stackDepth: args["heap-stack"],
+		verbose: args["heap-verbose"],
+		userOnly: args["heap-user-only"]
+	};
+}
+/** Apply default sections and extra columns for matrix reports */
+function mergeMatrixDefaults(reportOptions, args, results) {
+	const result = { ...reportOptions };
+	if (!result.sections?.length) {
+		const groups = matrixToReportGroups(results);
+		result.sections = buildReportSections(args.adaptive, args["gc-stats"], hasField(groups, "cpu"), args["trace-opt"] && hasField(groups, "optStatus"));
+	}
+	return result;
+}
+/** Run matrix suite with full CLI handling (parse, run, report, export) */
+async function runDefaultMatrixBench(suite, configureArgs, reportOptions) {
+	await matrixBenchExports(suite, parseBenchArgs(configureArgs), reportOptions);
+}
+/** Convert MatrixResults to ReportGroup[] for export compatibility */
+function matrixToReportGroups(results) {
+	return results.flatMap((matrix) => matrix.variants.flatMap((variant) => variant.cases.map((c) => {
+		const { metadata } = c;
+		const report = {
+			name: variant.id,
+			measuredResults: c.measured,
+			metadata
+		};
+		const baseline = c.baseline ? {
+			name: `${variant.id} (baseline)`,
+			measuredResults: c.baseline,
+			metadata
+		} : void 0;
+		return {
+			name: `${variant.id} / ${c.caseId}`,
+			reports: [report],
+			baseline
+		};
+	})));
+}
+/** Sequential map - like Promise.all(arr.map(fn)) but runs one at a time */
+async function serialMap(arr, fn) {
+	const results = [];
+	for (const item of arr) results.push(await fn(item));
+	return results;
+}
+/** Run matrix benchmarks, display table, and generate exports */
+async function matrixBenchExports(suite, args, reportOptions, exportOptions) {
+	const results = await runMatrixSuite(suite, args);
+	const report = defaultMatrixReport(results, reportOptions, args);
+	console.log(report);
+	await finishReports(matrixToReportGroups(results), args, suite.name, exportOptions);
+}
+
+//#endregion
+//#region src/GitUtils.ts
+/** Get current git version info. For dirty repos, uses most recent modified file date. */
+function getCurrentGitVersion() {
+	try {
+		const exec = (cmd) => execSync(cmd, { encoding: "utf-8" }).trim();
+		const hash = exec("git rev-parse --short HEAD");
+		const commitDate = exec("git log -1 --format=%aI");
+		const dirty = exec("git status --porcelain").length > 0;
+		return {
+			hash,
+			date: dirty ? getMostRecentModifiedDate(".") ?? commitDate : commitDate,
+			dirty
+		};
+	} catch {
+		return;
+	}
+}
+/** Read baseline version from .baseline-version file */
+function getBaselineVersion(baselineDir = "_baseline") {
+	const versionFile = join(baselineDir, ".baseline-version");
+	if (!existsSync(versionFile)) return void 0;
+	try {
+		const content = readFileSync(versionFile, "utf-8");
+		const data = JSON.parse(content);
+		return {
+			hash: data.hash,
+			date: data.date
+		};
+	} catch {
+		return;
+	}
+}
+/** Format git version for display: "abc1234 (Jan 9, 2026, 3:45 PM)" or "abc1234*" if dirty */
+function formatGitVersion(version) {
+	return `${version.dirty ? `${version.hash}*` : version.hash} (${formatDateWithTimezone(version.date)})`;
+}
+/** Get most recent modified file date in a directory (for dirty repos) */
+function getMostRecentModifiedDate(dir) {
+	try {
+		const modifiedFiles = execSync("git status --porcelain", {
+			encoding: "utf-8",
+			cwd: dir
+		}).trim().split("\n").filter((line) => line.length > 0).map((line) => line.slice(3));
+		if (modifiedFiles.length === 0) return void 0;
+		let mostRecent = 0;
+		for (const file of modifiedFiles) try {
+			const filePath = join(dir, file);
+			if (!existsSync(filePath)) continue;
+			const mtime = statSync(filePath).mtimeMs;
+			if (mtime > mostRecent) mostRecent = mtime;
+		} catch {}
+		return mostRecent > 0 ? new Date(mostRecent).toISOString() : void 0;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { timeSection as A, parseCliArgs as B, adaptiveSection as C, gcStatsSection as D, gcSection as E, generateHtmlReport as F, truncate as G, formatBytes as H, formatDateWithTimezone as I, average as J, isStatefulVariant as K, prepareHtmlData as L, formatConvergence as M, filterMatrix as N, optSection as O, parseMatrixFilter as P, exportPerfettoTrace as R, reportMatrixResults as S, cpuSection as T, integer as U, reportResults as V, timeMs as W, loadCasesModule as X, loadCaseData as Y, runDefaultMatrixBench as _, cliToMatrixOptions as a, gcStatsColumns as b, exportReports as c, matrixToReportGroups as d, parseBenchArgs as f, runDefaultBench as g, runBenchmarks as h, benchExports as i, totalTimeSection as j, runsSection as k, hasField as l, reportOptStatus as m, getBaselineVersion as n, defaultMatrixReport as o, printHeapReports as p, runMatrix as q, getCurrentGitVersion as r, defaultReport as s, formatGitVersion as t, matrixBenchExports as u, runMatrixSuite as v, buildGenericSections as w, heapTotalColumn as x, gcPauseColumn as y, defaultCliArgs as z };
+//# sourceMappingURL=src-CGuaC3Wo.mjs.map