benchforge 0.1.0 → 0.1.2

package/dist/{src-CGuaC3Wo.mjs → src-D7zxOFGA.mjs}

@@ -1,14 +1,14 @@
-import fs, { mkdir, readFile, writeFile } from "node:fs/promises";
+import { a as BasicRunner, c as createAdaptiveWrapper, d as bootstrapDifferenceCI, f as discoverVariants, i as createRunner, l as msToNs, n as getElapsed, o as computeStats, r as getPerfNow, s as checkConvergence, t as debugWorkerTiming, u as average } from "./TimingUtils-D4z1jpp2.mjs";
+import { 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 { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 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";
 
@@ -30,583 +30,6 @@ async function loadCaseData(casesModule, 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 */
@@ -682,18 +105,6 @@ function aggregateGcStats(events) {
 	};
 }
 
-//#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}`) : () => {};
@@ -841,13 +252,8 @@ function createCleanup(worker, specName, reject) {
 }
 /** 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"
-	];
+	const workerPath = resolveWorkerPath();
+	const execArgv = ["--expose-gc", "--allow-natives-syntax"];
 	if (gcStats) execArgv.push("--trace-gc-nvp");
 	return fork(workerPath, [], {
 		execArgv,
@@ -858,6 +264,13 @@ function createWorkerProcess(gcStats) {
 		}
 	});
 }
+/** Resolve WorkerScript path for dev (.ts) or dist (.mjs) */
+function resolveWorkerPath() {
+	const dir = import.meta.dirname;
+	const tsPath = path.join(dir, "WorkerScript.ts");
+	if (existsSync(tsPath)) return tsPath;
+	return path.join(dir, "runners", "WorkerScript.mjs");
+}
 /** @return handlers that attach GC stats and heap profile to results */
 function createWorkerHandlers(specName, startTime, gcEvents, resolve, reject) {
 	return {
@@ -1430,14 +843,11 @@ function injectDiffColumns(reportGroups) {
 
 //#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,
+		default: .642,
 		requiresArg: true,
 		describe: "test duration in seconds"
 	},
@@ -1532,12 +942,12 @@ const cliOptions = {
 	},
 	"pause-interval": {
 		type: "number",
-		default: defaultPauseInterval,
+		default: 0,
 		describe: "iterations between pauses for V8 optimization (0 to disable)"
 	},
 	"pause-duration": {
 		type: "number",
-		default: defaultPauseDuration,
+		default: 100,
 		describe: "pause duration in ms for V8 optimization"
 	},
 	batches: {
@@ -3672,5 +3082,5 @@ function getMostRecentModifiedDate(dir) {
 }
 
 //#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
+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, loadCaseData 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 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-D7zxOFGA.mjs.map