@fedify/cli 2.3.0-dev.1347 → 2.3.0-dev.1361

package/dist/bench/compare.js

@@ -1,667 +0,0 @@
-import "@js-temporal/polyfill";
-import { describeError } from "../utils.js";
-import { metricUnit } from "./result/expect/metrics.js";
-import { parseDuration } from "./scenario/units.js";
-import runBench from "./action.js";
-import { COMPARE_REPORT_SCHEMA_ID } from "./compare/schema.js";
-import process from "node:process";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-//#region src/bench/compare.ts
-const ZERO_BASE_LATENCY_ALLOWANCE_MS = 1;
-/** Runs `fedify bench compare`. */
-async function runBenchCompare(command, deps = {}) {
-	const exit = deps.exit ?? ((code) => {
-		process.exitCode = code;
-	});
-	const writeOutput = deps.writeOutput ?? defaultWriteOutput;
-	const log = deps.log ?? ((message) => process.stderr.write(`${message}\n`));
-	const createWorktree = deps.createWorktree ?? defaultCreateWorktree;
-	const removeWorktree = deps.removeWorktree ?? defaultRemoveWorktree;
-	const startTarget = deps.startTarget ?? defaultStartTarget;
-	const waitReady = deps.waitReady ?? defaultWaitReady;
-	const runBenchInWorktree = deps.runBenchInWorktree ?? ((input) => defaultRunBenchInWorktree(input, deps.benchDeps));
-	const signalTarget = deps.signalTarget ?? process;
-	let readyUrl;
-	let readyTimeoutMs;
-	let maxRegression;
-	try {
-		readyUrl = new URL(command.readyUrl);
-		readyTimeoutMs = parseDuration(command.readyTimeout);
-		maxRegression = parseRegressionTolerance(command.maxRegression);
-	} catch (error) {
-		log(describeError(error));
-		exit(2);
-		return;
-	}
-	const target = command.target ?? new URL("/", readyUrl).origin;
-	const worktrees = [];
-	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-	let activeTarget;
-	let interruptError;
-	const interruptController = new AbortController();
-	const interruptSignal = interruptController.signal;
-	let rejectInterrupt;
-	const interruptPromise = new Promise((_resolve, reject) => {
-		rejectInterrupt = reject;
-	});
-	interruptPromise.catch(() => {});
-	let interrupted = false;
-	const onSignal = (signal) => {
-		if (interrupted) return;
-		interrupted = true;
-		interruptError = new BenchmarkInterrupted(signal);
-		interruptController.abort(interruptError);
-		rejectInterrupt(interruptError);
-	};
-	signalTarget.on("SIGINT", onSignal);
-	signalTarget.on("SIGTERM", onSignal);
-	try {
-		const baseReport = await runSide("base", command.base);
-		throwIfInterrupted();
-		const headReport = await runSide("head", command.head);
-		throwIfInterrupted();
-		const report = buildCompareReport({
-			baseRef: command.base,
-			headRef: command.head,
-			baseReport,
-			headReport,
-			maxRegression,
-			startedAt,
-			finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-		});
-		throwIfInterrupted();
-		await withInterrupt(writeOutput(renderCompareReport(report, command.format), command.output));
-		throwIfInterrupted();
-		exit(report.passed ? 0 : 1);
-		return;
-	} catch (error) {
-		if (error instanceof BenchmarkInterrupted) {
-			exit(error.exitCode);
-			return;
-		}
-		log(describeError(error));
-		exit(2);
-		return;
-	} finally {
-		if (activeTarget != null) try {
-			await activeTarget.stop();
-		} catch (error) {
-			log(`Failed to stop benchmark target: ${describeError(error)}`);
-		} finally {
-			activeTarget = void 0;
-		}
-		for (let i = worktrees.length - 1; i >= 0; i--) {
-			const path = worktrees[i];
-			try {
-				await removeWorktree(path);
-			} catch (error) {
-				log(`Failed to remove benchmark worktree ${path}: ${describeError(error)}`);
-			}
-		}
-		signalTarget.off("SIGINT", onSignal);
-		signalTarget.off("SIGTERM", onSignal);
-	}
-	async function runSide(label, ref) {
-		log(`Checking out ${label} benchmark ref ${ref}…`);
-		const cwd = await createWorktree(ref, label);
-		worktrees.push(cwd);
-		throwIfInterrupted();
-		const targetProcess = await startTarget(cwd, command.startCommand);
-		activeTarget = targetProcess;
-		let stoppingTarget = false;
-		let targetExitError;
-		const targetExit = targetProcessExited(targetProcess).catch((error) => {
-			targetExitError = error;
-			if (!stoppingTarget && !interruptSignal.aborted) {
-				interruptController.abort(error);
-				throw error;
-			}
-			return new Promise(() => {});
-		});
-		const throwIfTargetExited = () => {
-			if (targetExitError != null) throw targetExitError;
-		};
-		try {
-			throwIfInterrupted();
-			await withInterrupt(Promise.race([targetExit, waitReady(readyUrl, readyTimeoutMs, interruptSignal)]));
-			await Promise.resolve();
-			throwIfTargetExited();
-			return await withInterrupt(Promise.race([targetExit, runBenchInWorktree({
-				cwd,
-				command,
-				target,
-				signal: interruptSignal
-			})]));
-		} finally {
-			try {
-				stoppingTarget = true;
-				await targetProcess.stop();
-			} finally {
-				if (activeTarget === targetProcess) activeTarget = void 0;
-			}
-		}
-	}
-	function withInterrupt(promise) {
-		return Promise.race([interruptPromise, promise]);
-	}
-	function throwIfInterrupted() {
-		if (interruptError != null) throw interruptError;
-	}
-}
-var BenchmarkInterrupted = class extends Error {
-	signal;
-	constructor(signal) {
-		super(`Interrupted by ${signal}.`);
-		this.signal = signal;
-	}
-	get exitCode() {
-		return this.signal === "SIGINT" ? 130 : 143;
-	}
-};
-function targetProcessExited(target) {
-	return target.exited ?? new Promise(() => {});
-}
-/** Parses `--max-regression`, accepting ratios or percentages. */
-function parseRegressionTolerance(value) {
-	const trimmed = value.trim();
-	const match = /^(\d+(?:\.\d+)?|\.\d+)(%)?$/.exec(trimmed);
-	const numeric = match == null ? NaN : Number(match[1]);
-	if (!Number.isFinite(numeric) || numeric < 0) throw new RangeError(`Invalid --max-regression value: ${JSON.stringify(value)}.`);
-	if (match?.[2] == null && numeric > 1) throw new RangeError(`Invalid --max-regression value: ${JSON.stringify(value)}; use a ratio between 0 and 1 or an explicit percentage.`);
-	return match?.[2] === "%" ? numeric / 100 : numeric;
-}
-/** Builds a compare report from two benchmark reports. */
-function buildCompareReport(input) {
-	const comparisons = compareReports(input.baseReport, input.headReport, input.maxRegression);
-	return {
-		$schema: COMPARE_REPORT_SCHEMA_ID,
-		schemaVersion: 1,
-		tool: input.headReport.tool,
-		environment: input.headReport.environment,
-		startedAt: input.startedAt,
-		finishedAt: input.finishedAt,
-		suite: input.headReport.suite,
-		maxRegression: input.maxRegression,
-		base: {
-			ref: input.baseRef,
-			report: input.baseReport
-		},
-		head: {
-			ref: input.headRef,
-			report: input.headReport
-		},
-		comparisons,
-		passed: input.headReport.passed && comparisons.every((c) => c.pass)
-	};
-}
-function compareReports(base, head, maxRegression) {
-	const results = [];
-	const baseByScenario = /* @__PURE__ */ new Map();
-	for (const baseScenario of base.scenarios) {
-		const key = comparisonScenarioKey(baseScenario);
-		const scenarios = baseByScenario.get(key);
-		if (scenarios == null) baseByScenario.set(key, [baseScenario]);
-		else scenarios.push(baseScenario);
-	}
-	const headCounts = /* @__PURE__ */ new Map();
-	for (const headScenario of head.scenarios) {
-		const key = comparisonScenarioKey(headScenario);
-		const occurrence = headCounts.get(key) ?? 0;
-		headCounts.set(key, occurrence + 1);
-		const baseScenario = baseByScenario.get(key)?.[occurrence];
-		if (baseScenario == null) {
-			results.push(newScenario(headScenario.name, maxRegression));
-			continue;
-		}
-		for (const metric of comparisonMetrics(headScenario)) results.push(compareMetric(baseScenario, headScenario, metric, maxRegression));
-	}
-	return results;
-}
-function comparisonScenarioKey(scenario) {
-	return `${scenario.name}\0${scenario.type}`;
-}
-function comparisonMetrics(scenario) {
-	const fromExpect = scenario.expectations.map((e) => e.metric).filter(isPerformanceMetric);
-	return [...new Set(fromExpect.length < 1 ? ["latency.p95", "throughputPerSec"] : fromExpect)];
-}
-function isPerformanceMetric(metric) {
-	const unit = metricUnit(metric);
-	return unit === "ms" || unit === "rate";
-}
-function compareMetric(baseScenario, headScenario, metric, maxRegression) {
-	const unit = metricUnit(metric);
-	const direction = unit === "rate" ? "higher-is-better" : "lower-is-better";
-	const base = metricValue(baseScenario, metric);
-	const head = metricValue(headScenario, metric);
-	const noiseBand = Math.max(relativeNoise(baseScenario, metric), relativeNoise(headScenario, metric));
-	const regression = base == null || head == null ? null : regressionRatio(base, head, direction, unit);
-	const allowedRegression = maxRegression + noiseBand;
-	return {
-		scenario: headScenario.name,
-		metric,
-		direction,
-		base,
-		head,
-		regression,
-		noiseBand,
-		allowedRegression,
-		pass: base == null && head != null || regression != null && regression <= allowedRegression
-	};
-}
-function newScenario(scenario, maxRegression) {
-	return {
-		scenario,
-		metric: "scenario",
-		direction: "lower-is-better",
-		base: null,
-		head: null,
-		regression: null,
-		noiseBand: 0,
-		allowedRegression: maxRegression,
-		pass: true
-	};
-}
-function metricValue(scenario, metric) {
-	switch (metric) {
-		case "throughputPerSec": return scenario.throughputPerSec;
-		case "deliveryThroughput": return scenario.deliveryThroughputPerSec ?? null;
-	}
-	if (metric.startsWith("latency.")) {
-		const latency = scenario.client?.latencyMs;
-		return latency == null ? null : latencyValue(latency, metric.slice(8));
-	}
-	if (metric.startsWith("signatureVerification.")) return partialValue(scenario.server?.signatureVerificationMs?.overall, metric.slice(22));
-	if (metric.startsWith("queueDrain.")) return partialValue(scenario.server?.queue?.drainMs, metric.slice(11));
-	return null;
-}
-function latencyValue(latency, field) {
-	switch (field) {
-		case "p50": return latency.p50;
-		case "p95": return latency.p95;
-		case "p99": return latency.p99;
-		case "mean": return latency.mean;
-		case "max": return latency.max;
-		default: return null;
-	}
-}
-function partialValue(latency, field) {
-	switch (field) {
-		case "p50": return latency?.p50 ?? null;
-		case "p95": return latency?.p95 ?? null;
-		case "p99": return latency?.p99 ?? null;
-		default: return null;
-	}
-}
-function regressionRatio(base, head, direction, unit) {
-	if (!Number.isFinite(base) || !Number.isFinite(head)) return null;
-	if (base < 0) return base === head ? 0 : null;
-	if (base === 0) {
-		if (base === head) return 0;
-		if (direction === "lower-is-better" && unit === "ms" && head <= ZERO_BASE_LATENCY_ALLOWANCE_MS) return 0;
-		return direction === "higher-is-better" && head > base ? 0 : null;
-	}
-	return direction === "higher-is-better" ? (base - head) / base : (head - base) / base;
-}
-function relativeNoise(scenario, metric) {
-	const values = (scenario.runs ?? []).map((run) => metricValue(run, metric)).filter((value) => value != null && Number.isFinite(value));
-	if (values.length < 2) return 0;
-	const medianValue = median(values);
-	if (medianValue <= 0) return 0;
-	return (Math.max(...values) - Math.min(...values)) / (2 * medianValue);
-}
-function median(values) {
-	const sorted = [...values].sort((a, b) => a - b);
-	const middle = Math.floor(sorted.length / 2);
-	if (sorted.length % 2 === 1) return sorted[middle];
-	return (sorted[middle - 1] + sorted[middle]) / 2;
-}
-function renderCompareReport(report, format) {
-	switch (format) {
-		case "json": return `${JSON.stringify(report, null, 2)}\n`;
-		case "markdown": return renderCompareMarkdown(report);
-		case "text": return renderCompareText(report);
-	}
-	throw new RangeError(`Unsupported benchmark report format: ${format}.`);
-}
-function renderCompareText(report) {
-	const lines = [
-		"Fedify benchmark comparison",
-		"",
-		`Base: ${report.base.ref}`,
-		`Head: ${report.head.ref}`,
-		`Maximum regression: ${formatPercent(report.maxRegression)}`,
-		""
-	];
-	for (const comparison of report.comparisons) lines.push(`[${comparison.pass ? "PASS" : "FAIL"}] ${comparison.scenario} ${comparison.metric}: base ${formatNumberOrNull(comparison.base)}, head ${formatNumberOrNull(comparison.head)}, regression ${formatNumberOrNull(comparison.regression, formatPercent)}, noise ${formatPercent(comparison.noiseBand)}`);
-	lines.push("", `Overall: ${report.passed ? "PASS" : "FAIL"}`);
-	return `${lines.join("\n")}\n`;
-}
-function renderCompareMarkdown(report) {
-	const lines = [
-		"# Fedify benchmark comparison",
-		"",
-		`**Result:** ${report.passed ? "PASS" : "FAIL"}`,
-		"",
-		`- **Base:** \`${report.base.ref}\``,
-		`- **Head:** \`${report.head.ref}\``,
-		`- **Maximum regression:** ${formatPercent(report.maxRegression)}`,
-		"",
-		"| Scenario | Metric | Base | Head | Regression | Noise | Result |",
-		"| --- | --- | --- | --- | --- | --- | --- |"
-	];
-	for (const comparison of report.comparisons) lines.push(`| ${comparison.scenario} | \`${comparison.metric}\` | ${formatNumberOrNull(comparison.base)} | ${formatNumberOrNull(comparison.head)} | ${formatNumberOrNull(comparison.regression, formatPercent)} | ${formatPercent(comparison.noiseBand)} | ${comparison.pass ? "PASS" : "FAIL"} |`);
-	return `${lines.join("\n")}\n`;
-}
-function formatNumberOrNull(value, formatter = formatNumber) {
-	return value == null ? "n/a" : formatter(value);
-}
-function formatNumber(value) {
-	if (!Number.isFinite(value)) return String(value);
-	return Number.isInteger(value) ? String(value) : value.toFixed(3);
-}
-function formatPercent(value) {
-	if (!Number.isFinite(value)) return String(value);
-	return `${(value * 100).toFixed(1)}%`;
-}
-async function defaultRunBenchInWorktree(input, benchDeps = {}) {
-	let output = "";
-	let exitCode = 0;
-	await runBench({
-		command: "bench",
-		mode: "run",
-		scenario: input.command.file,
-		target: input.target,
-		format: "json",
-		output: void 0,
-		dryRun: false,
-		advertiseHost: input.command.advertiseHost,
-		allowUnsafeTarget: input.command.allowUnsafeTarget,
-		userAgent: input.command.userAgent,
-		explicitCliTarget: input.command.target != null
-	}, {
-		...benchDeps,
-		signal: input.signal,
-		exit: (code) => {
-			exitCode = code;
-		},
-		writeOutput: (content) => {
-			output = content;
-			return Promise.resolve();
-		}
-	});
-	if (exitCode === 2 || output.trim() === "") throw new Error(`Benchmark run failed for ${input.cwd}.`);
-	return JSON.parse(output);
-}
-function defaultCreateWorktree(ref, label) {
-	return createBenchmarkWorktree(ref, label);
-}
-/** Creates a detached Git worktree for one side of a benchmark comparison. */
-async function createBenchmarkWorktree(ref, label, deps = {}) {
-	const createTempDir = deps.createTempDir ?? mkdtemp;
-	const removePath = deps.removePath ?? rm;
-	const run = deps.runGit ?? runGit;
-	const path = await createTempDir(join(tmpdir(), `fedify-bench-${label}-`));
-	try {
-		await run([
-			"worktree",
-			"add",
-			"--detach",
-			path,
-			ref
-		]);
-	} catch (error) {
-		try {
-			await run([
-				"worktree",
-				"remove",
-				"--force",
-				path
-			]);
-		} catch {}
-		try {
-			await removePath(path, {
-				recursive: true,
-				force: true
-			});
-		} catch {}
-		throw error;
-	}
-	return path;
-}
-async function defaultRemoveWorktree(path) {
-	await runGit([
-		"worktree",
-		"remove",
-		"--force",
-		path
-	]);
-}
-function runGit(args) {
-	return new Promise((resolve, reject) => {
-		const child = spawn("git", args, { stdio: "ignore" });
-		child.on("error", reject);
-		child.on("close", (code) => {
-			if (code === 0) resolve();
-			else reject(/* @__PURE__ */ new Error(`git ${args.join(" ")} exited with code ${code}`));
-		});
-	});
-}
-function defaultStartTarget(cwd, startCommand) {
-	return Promise.resolve(startBenchmarkTarget(cwd, startCommand));
-}
-/** Starts a benchmark target process. */
-function startBenchmarkTarget(cwd, startCommand, options = {}) {
-	const platform = options.platform ?? process.platform;
-	const spawnTarget = options.spawn ?? spawn;
-	const stderr = options.stderr ?? process.stderr;
-	const child = spawnTarget(startCommand, {
-		cwd,
-		detached: platform !== "win32",
-		shell: true,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		],
-		env: process.env
-	});
-	forwardTargetOutput(child, stderr);
-	const exited = createTargetExitPromise(child);
-	exited.catch(() => {});
-	return {
-		exited,
-		stop: () => stopTargetProcess(child, { platform })
-	};
-}
-function forwardTargetOutput(child, stderr) {
-	child.stdout?.on("data", (chunk) => {
-		stderr.write(chunk);
-	});
-	child.stderr?.on("data", (chunk) => {
-		stderr.write(chunk);
-	});
-}
-function createTargetExitPromise(child) {
-	return new Promise((_resolve, reject) => {
-		const onError = (error) => {
-			child.removeListener("exit", onExit);
-			reject(error);
-		};
-		const onExit = (code, signal) => {
-			child.removeListener("error", onError);
-			const suffix = signal == null ? ` with code ${code ?? "<unknown>"}` : ` from ${signal}`;
-			reject(/* @__PURE__ */ new Error(`Benchmark target process ${child.pid ?? "<unknown>"} exited${suffix} before benchmark completion.`));
-		};
-		child.once("error", onError);
-		child.once("exit", onExit);
-	});
-}
-/** Stops a benchmark target process. */
-function stopTargetProcess(child, options = {}) {
-	const platform = options.platform ?? process.platform;
-	const killWindowsProcessTree = options.killWindowsProcessTree ?? defaultKillWindowsProcessTree;
-	const killProcessGroup = options.killProcessGroup ?? ((pid, signal) => process.kill(pid, signal));
-	const forceTimeoutMs = options.forceTimeoutMs ?? 5e3;
-	const forceKillTimeoutMs = options.forceKillTimeoutMs ?? forceTimeoutMs;
-	return new Promise((resolve, reject) => {
-		if (child.pid == null || child.exitCode != null || child.signalCode != null) {
-			resolve();
-			return;
-		}
-		let settled = false;
-		let forceKillTimer;
-		const clearTimers = () => {
-			clearTimeout(forceTimer);
-			if (forceKillTimer != null) clearTimeout(forceKillTimer);
-		};
-		const onExit = () => {
-			if (settled) return;
-			settled = true;
-			clearTimers();
-			resolve();
-		};
-		const rejectStop = (error) => {
-			if (settled) return;
-			settled = true;
-			clearTimers();
-			child.removeListener("exit", onExit);
-			reject(error);
-		};
-		const forceTimer = setTimeout(() => {
-			try {
-				killTargetProcess(child, "SIGKILL", {
-					platform,
-					killWindowsProcessTree,
-					killProcessGroup
-				});
-			} catch (error) {
-				rejectStop(error);
-				return;
-			}
-			forceKillTimer = setTimeout(() => {
-				rejectStop(/* @__PURE__ */ new Error(`Benchmark target process ${child.pid ?? "<unknown>"} did not exit after SIGKILL.`));
-			}, forceKillTimeoutMs);
-		}, forceTimeoutMs);
-		child.once("exit", onExit);
-		try {
-			killTargetProcess(child, "SIGTERM", {
-				platform,
-				killWindowsProcessTree,
-				killProcessGroup
-			});
-		} catch (error) {
-			rejectStop(error);
-		}
-	});
-}
-function killTargetProcess(child, signal, options) {
-	if (child.pid == null) {
-		child.kill(signal);
-		return;
-	}
-	if (options.platform === "win32") {
-		options.killWindowsProcessTree(child.pid, signal);
-		return;
-	}
-	try {
-		options.killProcessGroup(-child.pid, signal);
-	} catch {
-		child.kill(signal);
-	}
-}
-function defaultKillWindowsProcessTree(pid, signal) {
-	spawn("taskkill", windowsTaskkillArgs(pid, signal), {
-		stdio: "ignore",
-		windowsHide: true
-	}).on("error", () => {});
-}
-/** Builds the Windows `taskkill` arguments used for target cleanup. */
-function windowsTaskkillArgs(pid, signal) {
-	const args = [
-		"/pid",
-		String(pid),
-		"/T"
-	];
-	if (signal === "SIGKILL") args.push("/F");
-	return args;
-}
-async function defaultWaitReady(url, timeoutMs, signal) {
-	return await waitReadyUrl(url, timeoutMs, { signal });
-}
-/** Waits until a benchmark target readiness URL responds successfully. */
-async function waitReadyUrl(url, timeoutMs, deps = {}) {
-	const fetchReady = deps.fetch ?? fetch;
-	const sleep = deps.sleep ?? ((ms, signal) => abortableSleep(ms, signal));
-	const signal = deps.signal;
-	const deadline = Date.now() + timeoutMs;
-	let lastError;
-	while (Date.now() <= deadline) {
-		throwIfAborted(signal);
-		const remainingMs = deadline - Date.now();
-		if (remainingMs <= 0) break;
-		const controller = new AbortController();
-		const onAbort = () => {
-			controller.abort(abortReason(signal));
-		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-		const timer = setTimeout(() => {
-			controller.abort(/* @__PURE__ */ new Error(`ready URL timed out after ${timeoutMs}ms`));
-		}, remainingMs);
-		try {
-			const response = await fetchReady(url, { signal: controller.signal });
-			response.body?.cancel?.().catch(() => {});
-			if (response.status >= 200 && response.status < 400) return;
-			lastError = /* @__PURE__ */ new Error(`ready URL returned ${response.status}`);
-		} catch (error) {
-			if (signal?.aborted) throw abortReason(signal);
-			if (controller.signal.aborted) {
-				lastError = controller.signal.reason ?? error;
-				break;
-			}
-			lastError = error;
-		} finally {
-			signal?.removeEventListener("abort", onAbort);
-			clearTimeout(timer);
-		}
-		const delayMs = Math.min(250, deadline - Date.now());
-		if (delayMs > 0) await sleep(delayMs, signal);
-	}
-	throw new Error(`Timed out waiting for ${url.href}: ${describeError(lastError)}.`);
-}
-function abortableSleep(ms, signal) {
-	if (signal?.aborted) return Promise.reject(abortReason(signal));
-	if (ms <= 0) return Promise.resolve();
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			cleanup();
-			resolve();
-		}, ms);
-		const onAbort = () => {
-			clearTimeout(timer);
-			cleanup();
-			reject(abortReason(signal));
-		};
-		const cleanup = () => {
-			signal?.removeEventListener("abort", onAbort);
-		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw abortReason(signal);
-}
-function abortReason(signal) {
-	return signal.reason ?? /* @__PURE__ */ new Error("Benchmark comparison aborted.");
-}
-async function defaultWriteOutput(content, outputPath) {
-	if (outputPath == null) {
-		process.stdout.write(content.endsWith("\n") ? content : `${content}\n`);
-		return;
-	}
-	await writeFile(outputPath, content, { encoding: "utf-8" });
-}
-//#endregion
-export { runBenchCompare };

package/dist/bench/scenarios/actor.js

@@ -1,38 +0,0 @@
-import "@js-temporal/polyfill";
-import { convertUrlIfHandle } from "../../webfinger/lib.js";
-import { actorUrlsFromRecipients } from "./object-discovery.js";
-import { isBareHttpUrl } from "./runner.js";
-import { runReadLoad } from "./read.js";
-//#region src/bench/scenarios/actor.ts
-/**
-* The `actor` scenario runner.
-* @since 2.3.0
-* @module
-*/
-/** The `actor` scenario runner. */
-const actorRunner = {
-	validate(scenario) {
-		if (scenario.recipients.length < 1) throw new Error("The actor scenario requires a recipient.");
-		for (const recipient of scenario.recipients) {
-			let url;
-			try {
-				url = convertUrlIfHandle(recipient);
-			} catch {
-				throw new Error(`Scenario "${scenario.name}": invalid actor recipient ${JSON.stringify(recipient)}.`);
-			}
-			if (url.protocol !== "acct:" && !isBareHttpUrl(url)) throw new Error(`Scenario "${scenario.name}": actor recipient must be an acct: handle or a bare http(s) URL with a host and no credentials; got ${JSON.stringify(url.href)}.`);
-		}
-	},
-	async run(context) {
-		this.validate?.(context.scenario);
-		return await runReadLoad(context, {
-			urls: await actorUrlsFromRecipients(context.scenario.recipients, {
-				target: context.target,
-				fetch: context.fetch
-			}),
-			authenticated: context.scenario.authenticated
-		});
-	}
-};
-//#endregion
-export { actorRunner };