benchforge 0.1.0 → 0.1.1

package/dist/HeapSampler-BX3de22o.mjs

@@ -0,0 +1,54 @@
+import { Session } from "node:inspector/promises";
+
+//#region src/heap-sample/HeapSampler.ts
+const defaultOptions = {
+	samplingInterval: 32768,
+	stackDepth: 64,
+	includeMinorGC: true,
+	includeMajorGC: true
+};
+/** Run a function while sampling heap allocations, return profile */
+async function withHeapSampling(options, fn) {
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	const session = new Session();
+	session.connect();
+	try {
+		await startSampling(session, opts);
+		return {
+			result: await fn(),
+			profile: await stopSampling(session)
+		};
+	} finally {
+		session.disconnect();
+	}
+}
+/** Start heap sampling, falling back if include-collected params aren't supported */
+async function startSampling(session, opts) {
+	const { samplingInterval, stackDepth } = opts;
+	const base = {
+		samplingInterval,
+		stackDepth
+	};
+	const params = {
+		...base,
+		includeObjectsCollectedByMinorGC: opts.includeMinorGC,
+		includeObjectsCollectedByMajorGC: opts.includeMajorGC
+	};
+	try {
+		await session.post("HeapProfiler.startSampling", params);
+	} catch {
+		console.warn("HeapProfiler: include-collected params not supported, falling back");
+		await session.post("HeapProfiler.startSampling", base);
+	}
+}
+async function stopSampling(session) {
+	const { profile } = await session.post("HeapProfiler.stopSampling");
+	return profile;
+}
+
+//#endregion
+export { withHeapSampling };
+//# sourceMappingURL=HeapSampler-BX3de22o.mjs.map

package/dist/HeapSampler-BX3de22o.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeapSampler-BX3de22o.mjs","names":[],"sources":["../src/heap-sample/HeapSampler.ts"],"sourcesContent":["import { Session } from \"node:inspector/promises\";\n\nexport interface HeapSampleOptions {\n  samplingInterval?: number; // bytes between samples, default 32768\n  stackDepth?: number; // max stack frames, default 64\n  includeMinorGC?: boolean; // keep objects collected by minor GC, default true\n  includeMajorGC?: boolean; // keep objects collected by major GC, default true\n}\n\nexport interface ProfileNode {\n  callFrame: {\n    functionName: string;\n    url: string;\n    lineNumber: number;\n    columnNumber?: number;\n  };\n  selfSize: number;\n  children?: ProfileNode[];\n}\n\nexport interface HeapProfile {\n  head: ProfileNode;\n  samples?: number[]; // sample IDs (length = number of samples taken)\n}\n\nconst defaultOptions: Required<HeapSampleOptions> = {\n  samplingInterval: 32768,\n  stackDepth: 64,\n  includeMinorGC: true,\n  includeMajorGC: true,\n};\n\n/** Run a function while sampling heap allocations, return profile */\nexport async function withHeapSampling<T>(\n  options: HeapSampleOptions,\n  fn: () => Promise<T> | T,\n): Promise<{ result: T; profile: HeapProfile }> {\n  const opts = { ...defaultOptions, ...options };\n  const session = new Session();\n  session.connect();\n\n  try {\n    await startSampling(session, opts);\n    const result = await fn();\n    const profile = await stopSampling(session);\n    return { result, profile };\n  } finally {\n    session.disconnect();\n  }\n}\n\n/** Start heap sampling, falling back if include-collected params aren't supported */\nasync function startSampling(\n  session: Session,\n  opts: Required<HeapSampleOptions>,\n): Promise<void> {\n  const { samplingInterval, stackDepth } = opts;\n  const base = { samplingInterval, stackDepth };\n  const params = {\n    ...base,\n    includeObjectsCollectedByMinorGC: opts.includeMinorGC,\n    includeObjectsCollectedByMajorGC: opts.includeMajorGC,\n  };\n\n  try {\n    await session.post(\"HeapProfiler.startSampling\", params);\n  } catch {\n    console.warn(\n      \"HeapProfiler: include-collected params not supported, falling back\",\n    );\n    await session.post(\"HeapProfiler.startSampling\", base);\n  }\n}\n\nasync function stopSampling(session: Session): Promise<HeapProfile> {\n  const { profile } = await session.post(\"HeapProfiler.stopSampling\");\n  return profile as HeapProfile;\n}\n"],"mappings":";;;AAyBA,MAAM,iBAA8C;CAClD,kBAAkB;CAClB,YAAY;CACZ,gBAAgB;CAChB,gBAAgB;CACjB;;AAGD,eAAsB,iBACpB,SACA,IAC8C;CAC9C,MAAM,OAAO;EAAE,GAAG;EAAgB,GAAG;EAAS;CAC9C,MAAM,UAAU,IAAI,SAAS;AAC7B,SAAQ,SAAS;AAEjB,KAAI;AACF,QAAM,cAAc,SAAS,KAAK;AAGlC,SAAO;GAAE,QAFM,MAAM,IAAI;GAER,SADD,MAAM,aAAa,QAAQ;GACjB;WAClB;AACR,UAAQ,YAAY;;;;AAKxB,eAAe,cACb,SACA,MACe;CACf,MAAM,EAAE,kBAAkB,eAAe;CACzC,MAAM,OAAO;EAAE;EAAkB;EAAY;CAC7C,MAAM,SAAS;EACb,GAAG;EACH,kCAAkC,KAAK;EACvC,kCAAkC,KAAK;EACxC;AAED,KAAI;AACF,QAAM,QAAQ,KAAK,8BAA8B,OAAO;SAClD;AACN,UAAQ,KACN,qEACD;AACD,QAAM,QAAQ,KAAK,8BAA8B,KAAK;;;AAI1D,eAAe,aAAa,SAAwC;CAClE,MAAM,EAAE,YAAY,MAAM,QAAQ,KAAK,4BAA4B;AACnE,QAAO"}

package/dist/TimingUtils-D4z1jpp2.mjs

@@ -0,0 +1,599 @@
+import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { getHeapStatistics } from "node:v8";
+
+//#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();
+}
+/** Get module URL for a variant in a directory */
+function variantModuleUrl(dirUrl, variantId) {
+	return new URL(`${variantId}.ts`, dirUrl).href;
+}
+
+//#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/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
+export { BasicRunner as a, createAdaptiveWrapper as c, bootstrapDifferenceCI as d, discoverVariants as f, createRunner as i, msToNs as l, getElapsed as n, computeStats as o, variantModuleUrl as p, getPerfNow as r, checkConvergence as s, debugWorkerTiming as t, average as u };
+//# sourceMappingURL=TimingUtils-D4z1jpp2.mjs.map