benchforge 0.1.11 → 0.2.4

package/dist/HeapSampler-B8dtKHn1.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"HeapSampler-B8dtKHn1.mjs","names":[],"sources":["../src/heap-sample/HeapSampler.ts"],"sourcesContent":["import { Session } from \"node:inspector/promises\";\n\nexport interface HeapSampleOptions {\n  /** Bytes between samples (default 32768) */\n  samplingInterval?: number;\n\n  /** Max stack frames (default 64) */\n  stackDepth?: number;\n\n  /** Keep objects collected by minor GC (default true) */\n  includeMinorGC?: boolean;\n\n  /** Keep objects collected by major GC (default true) */\n  includeMajorGC?: boolean;\n}\n\n/** V8 call frame location within a profiled script */\nexport interface CallFrame {\n  /** Function name (empty string for anonymous) */\n  functionName: string;\n\n  /** Script URL or file path */\n  url: string;\n\n  /** Zero-based line number */\n  lineNumber: number;\n\n  /** Zero-based column number */\n  columnNumber?: number;\n}\n\n/** Node in the V8 sampling heap profile tree */\nexport interface ProfileNode {\n  /** Call site for this allocation node */\n  callFrame: CallFrame;\n\n  /** Bytes allocated directly at this node (not children) */\n  selfSize: number;\n\n  /** Unique node ID, links to {@link HeapSample.nodeId} */\n  id: number;\n\n  /** Child nodes in the call tree */\n  children?: ProfileNode[];\n}\n\n/** Individual heap allocation sample from V8's SamplingHeapProfiler */\nexport interface HeapSample {\n  /** Links to {@link ProfileNode.id} for stack lookup */\n  nodeId: number;\n\n  /** Allocation size in bytes */\n  size: number;\n\n  /** Monotonically increasing, gives temporal ordering */\n  ordinal: number;\n}\n\n/** V8 sampling heap profile tree with optional per-allocation samples */\nexport interface HeapProfile {\n  /** Root of the profile call tree */\n  head: ProfileNode;\n\n  /** Per-allocation samples, if collected */\n  samples?: HeapSample[];\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  // V8 returns id/samples fields not in @types/node's incomplete SamplingHeapProfile\n  return profile as unknown as HeapProfile;\n}\n"],"mappings":";;;AAmEA,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;AAEnE,QAAO"}

package/dist/TimingUtils-DwOwkc8G.mjs

@@ -1,597 +0,0 @@
-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/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;
-const defaultCollectOptions = {
-	maxTime: 5e3,
-	maxIterations: 1e6,
-	warmup: 0,
-	traceOpt: false,
-	noSettle: false
-};
-/**
-* 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 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)];
-	}
-};
-/** @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$1(sorted, .5),
-		p75: percentile$1(sorted, .75),
-		p99: percentile$1(sorted, .99),
-		p999: percentile$1(sorted, .999)
-	};
-}
-/** @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
-	};
-}
-function buildMeasuredResults(name, c) {
-	const time = computeStats(c.samples);
-	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
-		},
-		optStatus: c.optStatus,
-		optSamples: c.optSamples,
-		pausePoints: c.pausePoints
-	};
-}
-/** @return percentile value with linear interpolation */
-function percentile$1(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;
-}
-/** 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;
-}
-/** 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
-	};
-}
-/** @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
-	};
-}
-/** @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;
-	}
-}
-/** 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: []
-	};
-}
-/** 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;
-}
-/** 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;
-}
-
-//#endregion
-//#region src/StatisticalUtils.ts
-const confidence = .95;
-const bootstrapSamples = 1e4;
-/** @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(samples, .5);
-	return percentile(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(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 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(baseline, .5);
-	const observedPercent = (percentile(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(resB, .5);
-		const medC = percentile(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
-	};
-}
-/** @return confidence interval [lower, upper] */
-function computeInterval(medians, confidence) {
-	const alpha = (1 - confidence) / 2;
-	return [percentile(medians, alpha), percentile(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
-	}));
-}
-
-//#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 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 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 window size scaled to execution time */
-function getWindowSize(samples) {
-	if (samples.length < 20) return windowSize;
-	const recentMedian = percentile(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;
-}
-/** @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(recentMs, .5);
-	const medianPrevious = percentile(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 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");
-}
-/** @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 outlier impact as proportion of total time */
-function getOutlierImpact(samples) {
-	if (samples.length === 0) return {
-		ratio: 0,
-		count: 0
-	};
-	const median = percentile(samples, .5);
-	const threshold = median + 1.5 * (percentile(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
-	};
-}
-/** 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 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(samples, .25) / msToNs,
-		p50: percentile(samples, .5) / msToNs,
-		p75: percentile(samples, .75) / msToNs,
-		p95: percentile(samples, .95) / msToNs,
-		p99: percentile(samples, .99) / msToNs,
-		p999: percentile(samples, .999) / msToNs
-	};
-}
-/** @return robust variability metrics */
-function getRobustMetrics(samplesMs) {
-	const impact = getOutlierImpact(samplesMs);
-	return {
-		cv: coefficientOfVariation(samplesMs),
-		mad: medianAbsoluteDeviation(samplesMs),
-		outlierRate: impact.ratio
-	};
-}
-
-//#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 { createAdaptiveWrapper as a, BasicRunner as c, variantModuleUrl as d, createRunner as i, computeStats as l, getElapsed as n, average as o, getPerfNow as r, bootstrapDifferenceCI as s, debugWorkerTiming as t, discoverVariants as u };
-//# sourceMappingURL=TimingUtils-DwOwkc8G.mjs.map