benchforge 0.1.2 → 0.1.4

package/dist/{TimingUtils-D4z1jpp2.mjs → TimingUtils-ClclVQ7E.mjs}

@@ -13,6 +13,261 @@ 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;
+/** @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);
+	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 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$1(sorted, .5),
+		p75: percentile$1(sorted, .75),
+		p99: percentile$1(sorted, .99),
+		p999: percentile$1(sorted, .999)
+	};
+}
+/** @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;
+}
+/** @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/StatisticalUtils.ts
 const bootstrapSamples = 1e4;
@@ -25,8 +280,8 @@ function coefficientOfVariation(samples) {
 }
 /** @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);
+	const median = percentile(samples, .5);
+	return percentile(samples.map((x) => Math.abs(x - median)), .5);
 }
 /** @return mean of values */
 function average(values) {
@@ -40,7 +295,7 @@ function standardDeviation(samples) {
 	return Math.sqrt(variance);
 }
 /** @return value at percentile p (0-1) */
-function percentile$1(values, p) {
+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)];
@@ -54,7 +309,7 @@ function createResample(samples) {
 /** @return confidence interval [lower, upper] */
 function computeInterval(medians, confidence) {
 	const alpha = (1 - confidence) / 2;
-	return [percentile$1(medians, alpha), percentile$1(medians, 1 - alpha)];
+	return [percentile(medians, alpha), percentile(medians, 1 - alpha)];
 }
 /** Bin values into histogram for compact visualization */
 function binValues(values, binCount = 30) {
@@ -79,14 +334,14 @@ function binValues(values, binCount = 30) {
 /** @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 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$1(resB, .5);
-		const medC = percentile$1(resC, .5);
+		const medB = percentile(resB, .5);
+		const medC = percentile(resC, .5);
 		diffs.push((medC - medB) / medB * 100);
 	}
 	const ci = computeInterval(diffs, conf);
@@ -220,12 +475,12 @@ function getMinMaxSum(samples) {
 /** @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
+		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 */
@@ -243,8 +498,8 @@ function getOutlierImpact(samples) {
 		ratio: 0,
 		count: 0
 	};
-	const median = percentile$1(samples, .5);
-	const threshold = median + 1.5 * (percentile$1(samples, .75) - median);
+	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) {
@@ -278,8 +533,8 @@ function getStability(samples, 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 medianRecent = percentile(recentMs, .5);
+	const medianPrevious = percentile(previousMs, .5);
 	const medianDrift = Math.abs(medianRecent - medianPrevious) / medianPrevious;
 	const impactRecent = getOutlierImpact(recentMs);
 	const impactPrevious = getOutlierImpact(previousMs);
@@ -310,7 +565,7 @@ function buildConvergence(metrics) {
 /** @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);
+	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;
@@ -318,263 +573,6 @@ function getWindowSize(samples) {
 	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 */
@@ -595,5 +593,5 @@ function getElapsed(startMark, endMark) {
 }
 
 //#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
+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-ClclVQ7E.mjs.map