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

package/dist/bench/action.js

@@ -1,10 +1,9 @@
 import "@js-temporal/polyfill";
-import { describeError } from "../utils.js";
 import { getContextLoader, getDocumentLoader } from "../docloader.js";
+import { describeError } from "../utils.js";
 import { buildFleet } from "./actor/fleet.js";
 import { convertUrlIfHandle } from "../webfinger/lib.js";
 import { discoverInbox, selectInbox } from "./discovery/discover.js";
-import { actorUrlsFromRecipients, objectUrlsFromSource } from "./scenarios/object-discovery.js";
 import { validateExpectBlock } from "./result/expect/evaluate.js";
 import { buildReport, buildScenarioResult, configHash, detectEnvironment } from "./result/build.js";
 import { probeBenchmarkMode } from "./discovery/probe.js";
@@ -14,11 +13,13 @@ import { normalizeSuite } from "./scenario/normalize.js";
 import { validateSuite } from "./scenario/validate.js";
 import { UnsafeTargetError, assertInboxDestinationAllowed, assertTargetAllowed, assertUnsafeOverrideAllowed } from "./safety/gate.js";
 import { classifyResolvedTarget } from "./safety/tiers.js";
-import { resolveAdvertiseHost, spawnSyntheticServer } from "./server/synthetic.js";
 import { runnerFor } from "./scenarios/registry.js";
-import process from "node:process";
+import { resolveAdvertiseHost, spawnSyntheticServer } from "./server/synthetic.js";
 import { writeFile } from "node:fs/promises";
+import process from "node:process";
 //#region src/bench/action.ts
+/** The scenario types that need the synthetic actor/key server. */
+const SIGNED_TYPES = new Set(["inbox"]);
 /**
 * Runs the `fedify bench` command: load and validate the suite, gate the
 * target, run each scenario, and render the report.  The process exits 0 when
@@ -33,10 +34,7 @@ async function runBench(command, deps = {}) {
 	});
 	const writeOutput = deps.writeOutput ?? defaultWriteOutput;
 	const log = deps.log ?? ((message) => process.stderr.write(`${message}\n`));
-	const signal = deps.signal;
-	const fetchImpl = withUserAgent(withAbortSignal(deps.fetch ?? fetch, signal), command.userAgent);
-	const explicitCliTarget = command.explicitCliTarget ?? command.target != null;
-	throwIfAborted(signal);
+	const fetchImpl = withUserAgent(deps.fetch ?? fetch, command.userAgent);
 	let validated;
 	let suite;
 	try {
@@ -47,12 +45,11 @@ async function runBench(command, deps = {}) {
 		exit(2);
 		return;
 	}
-	throwIfAborted(signal);
 	let runners;
 	try {
 		runners = suite.scenarios.map((scenario) => {
 			const runner = runnerFor(scenario.type);
-			runner.validate?.(scenario, { scenarios: suite.scenarios });
+			runner.validate?.(scenario);
 			validateExpectBlock(scenario.expect);
 			return runner;
 		});
@@ -62,17 +59,14 @@ async function runBench(command, deps = {}) {
 		exit(2);
 		return;
 	}
-	throwIfAborted(signal);
 	const tier = await classifyResolvedTarget(suite.target, deps.resolveTargetAddresses);
-	throwIfAborted(signal);
 	const probe = await probeBenchmarkMode(suite.target, fetchImpl);
-	throwIfAborted(signal);
 	try {
 		if (!command.dryRun) assertUnsafeOverrideAllowed({
 			tier,
 			benchmarkMode: probe.benchmarkMode,
 			allowUnsafe: command.allowUnsafeTarget,
-			explicitCliTarget,
+			explicitCliTarget: command.target != null,
 			scenarios: unsafeOverrideScenarios(validated)
 		});
 		assertTargetAllowed({
@@ -112,35 +106,17 @@ async function runBench(command, deps = {}) {
 			targetOrigin: suite.target.origin,
 			targetBenchmarkMode: probe.benchmarkMode,
 			allowUnsafe: command.allowUnsafeTarget,
-			explicitCliTarget,
-			destinationTier,
-			defaults: validated.defaults
-		});
-	};
-	const assertDestinationWithoutSyntheticServerAllowed = async (url, scenario, loadDescription) => {
-		const sameOrigin = url.origin === suite.target.origin;
-		const destinationTier = sameOrigin ? tier : await classifyResolvedTarget(url, deps.resolveTargetAddresses);
-		const inheritsTargetGate = sameOrigin && probe.benchmarkMode;
-		if (destinationTier === "public" && !inheritsTargetGate && !command.allowUnsafeTarget) throw new UnsafeTargetError(`Refusing to send ${loadDescription} to ${url.href}: it is public and not part of the benchmarked target.  Pass --allow-unsafe-target to override.`);
-		assertPublicDestinationOverrideAllowed(url, scenario, {
-			targetOrigin: suite.target.origin,
-			targetBenchmarkMode: probe.benchmarkMode,
-			allowUnsafe: command.allowUnsafeTarget,
-			explicitCliTarget,
+			explicitCliTarget: command.target != null,
 			destinationTier,
 			defaults: validated.defaults
 		});
 	};
-	const assertReadDestinationAllowed = (url, scenario) => assertDestinationWithoutSyntheticServerAllowed(url, scenario, "benchmark read load");
-	const assertActorlessDestinationAllowed = (url, scenario) => assertDestinationWithoutSyntheticServerAllowed(url, scenario, "benchmark load");
 	if (command.dryRun) try {
 		await writeOutput(await renderPlan(suite, {
 			documentLoader,
 			contextLoader,
 			allowPrivateAddress,
-			fetch: fetchImpl,
-			assertDestinationAllowed,
-			assertReadDestinationAllowed
+			assertDestinationAllowed
 		}), command.output);
 		exit(0);
 		return;
@@ -149,42 +125,30 @@ async function runBench(command, deps = {}) {
 		exit(2);
 		return;
 	}
-	if (tier !== "loopback" && command.advertiseHost == null && suite.scenarios.some((scenario) => scenarioNeedsReachableLocalServer(scenario, suite.scenarios))) {
-		log("Some scenarios need benchmark-owned local servers to be reachable from the target.  A loopback target reaches them automatically; for a non-loopback target, pass --advertise-host with an address the target can reach, or use a scenario that does not need local benchmark servers such as webfinger.");
+	if (tier !== "loopback" && command.advertiseHost == null && suite.scenarios.some((s) => SIGNED_TYPES.has(s.type))) {
+		log("Signed scenarios (inbox) need the benchmark's synthetic actor server to be reachable from the target.  A loopback target reaches it automatically; for a non-loopback target, pass --advertise-host with an address the target can reach (the synthetic server then binds all interfaces), or use a read scenario such as webfinger.");
 		exit(2);
 		return;
 	}
 	let fleet;
 	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 	try {
-		throwIfAborted(signal);
-		if (suite.scenarios.some((scenario) => scenarioNeedsSyntheticServer(scenario, suite.scenarios))) fleet = await spawnSyntheticServer(await buildFleet(suite.actors), { advertiseHost: command.advertiseHost });
+		if (suite.scenarios.some((s) => SIGNED_TYPES.has(s.type))) fleet = await spawnSyntheticServer(await buildFleet(suite.actors), { advertiseHost: command.advertiseHost });
 		const results = [];
 		for (let i = 0; i < suite.scenarios.length; i++) {
 			const scenario = suite.scenarios[i];
-			const measurements = [];
-			for (let run = 1; run <= scenario.runs; run++) {
-				throwIfAborted(signal);
-				const suffix = scenario.runs === 1 ? "" : ` run ${run}/${scenario.runs}`;
-				log(`Running scenario "${scenario.name}" (${scenario.type})${suffix}…`);
-				measurements.push(await runners[i].run({
-					scenario,
-					scenarios: suite.scenarios,
-					target: suite.target,
-					documentLoader,
-					contextLoader,
-					allowPrivateAddress,
-					fleet: fleet ?? null,
-					advertiseHost: command.advertiseHost,
-					fetch: fetchImpl,
-					assertDestinationAllowed: (url, gateScenario) => assertDestinationAllowed(url, gateScenario ?? scenario),
-					assertReadDestinationAllowed: (url, gateScenario) => assertReadDestinationAllowed(url, gateScenario ?? scenario),
-					assertActorlessDestinationAllowed: (url, gateScenario) => assertActorlessDestinationAllowed(url, gateScenario ?? scenario),
-					signal
-				}));
-				throwIfAborted(signal);
-			}
-			results.push(buildScenarioResult(scenario, measurements));
+			log(`Running scenario "${scenario.name}" (${scenario.type})…`);
+			const measurement = await runners[i].run({
+				scenario,
+				target: suite.target,
+				documentLoader,
+				contextLoader,
+				allowPrivateAddress,
+				fleet: fleet ?? null,
+				fetch: fetchImpl,
+				assertDestinationAllowed: (url) => assertDestinationAllowed(url, scenario)
+			});
+			results.push(buildScenarioResult(scenario, measurement));
 		}
 		const report = buildReport({
 			scenarios: results,
@@ -246,22 +210,6 @@ function withUserAgent(fetchImpl, userAgent) {
 		});
 	});
 }
-function withAbortSignal(fetchImpl, signal) {
-	if (signal == null) return fetchImpl;
-	return ((input, init) => {
-		if (signal.aborted) return Promise.reject(abortReason(signal));
-		return fetchImpl(input, {
-			...init,
-			signal
-		});
-	});
-}
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw abortReason(signal);
-}
-function abortReason(signal) {
-	return signal.reason ?? /* @__PURE__ */ new Error("Benchmark run aborted.");
-}
 async function defaultWriteOutput(content, outputPath) {
 	if (outputPath == null) {
 		process.stdout.write(content.endsWith("\n") ? content : `${content}\n`);
@@ -284,34 +232,12 @@ async function renderPlan(suite, context) {
 	return `${lines.join("\n")}\n`;
 }
 function describePlan(scenario) {
-	const load = scenario.load.kind === "open" ? `open-loop ${scenario.load.ratePerSec}/s ${scenario.load.arrival}` : `closed-loop concurrency ${scenario.load.concurrency}`;
-	const totalDurationMs = scenario.durationMs * scenario.runs;
-	const volume = describePlannedRequestVolume(scenario);
-	return [
-		load,
-		`duration ${scenario.durationMs}ms`,
-		`runs ${scenario.runs}`,
-		`total duration ${totalDurationMs}ms`,
-		...volume == null ? [] : [volume],
-		`signing ${scenario.signing}`
-	].join(", ");
-}
-function describePlannedRequestVolume(scenario) {
-	if (scenario.load.kind !== "open") return null;
-	return `estimated scheduled requests ${formatPlanNumber(scenario.load.ratePerSec * (scenario.durationMs / 1e3) * scenario.runs)}`;
-}
-function formatPlanNumber(value) {
-	if (Number.isInteger(value)) return String(value);
-	const formatted = value.toFixed(2).replace(/\.?0+$/, "");
-	return formatted === "" ? "0" : formatted;
+	return `${scenario.load.kind === "open" ? `open-loop ${scenario.load.ratePerSec}/s ${scenario.load.arrival}` : `closed-loop concurrency ${scenario.load.concurrency}`}, duration ${scenario.durationMs}ms, signing ${scenario.signing}`;
 }
 async function describeDiscoveryPlan(scenario, suite, context) {
 	switch (scenario.type) {
 		case "inbox": return await describeInboxDiscoveryPlan(scenario, context);
 		case "webfinger": return describeWebFingerPlan(scenario, suite.target);
-		case "actor": return await describeActorPlan(scenario, suite, context);
-		case "object": return await describeObjectPlan(scenario, suite, context);
-		case "mixed": return describeMixedPlan(scenario);
 		default: return ["  discovery: not available for this scenario type"];
 	}
 }
@@ -343,59 +269,15 @@ function describeWebFingerPlan(scenario, target) {
 		return `  webfinger ${resource}: GET ${url.href}`;
 	});
 }
-async function describeActorPlan(scenario, suite, context) {
+async function describeDestinationSafety(inbox, scenario, context) {
 	try {
-		const urls = await actorUrlsFromRecipients(scenario.recipients, {
-			target: suite.target,
-			fetch: context.fetch
-		});
-		const lines = [];
-		for (const url of urls) {
-			lines.push(`  actor: GET ${url.href}`);
-			lines.push(`  destination safety: ${await describeDestinationSafety(url, scenario, context)}`);
-		}
-		return lines;
-	} catch (error) {
-		return [`  actor discovery failed (${describeError(error)})`];
-	}
-}
-async function describeObjectPlan(scenario, suite, context) {
-	try {
-		const urls = await objectUrlsFromSource({
-			source: scenario.source,
-			target: suite.target,
-			fetch: context.fetch,
-			assertReadDestinationAllowed: (url) => context.assertReadDestinationAllowed(url, scenario)
-		});
-		const lines = [`  objects: ${urls.length} URL(s) resolved`];
-		for (const url of urls.slice(0, 10)) {
-			lines.push(`  object: GET ${url.href}`);
-			lines.push(`  destination safety: ${await describeDestinationSafety(url, scenario, context)}`);
-		}
-		if (urls.length > 10) lines.push(`  ... ${urls.length - 10} more`);
-		return lines;
-	} catch (error) {
-		return [`  object discovery failed (${describeError(error)})`];
-	}
-}
-function describeMixedPlan(scenario) {
-	const entries = scenario.raw.mix ?? [];
-	if (entries.length < 1) return ["  mix: no child scenarios"];
-	return entries.map((entry) => `  mix: ${entry.scenario} weight ${entry.weight}`);
-}
-async function describeDestinationSafety(url, scenario, context) {
-	try {
-		if (usesReadDestinationGate(scenario)) await context.assertReadDestinationAllowed(url, scenario);
-		else await context.assertDestinationAllowed(url, scenario);
+		await context.assertDestinationAllowed(inbox, scenario);
 		return "allowed";
 	} catch (error) {
 		if (error instanceof UnsafeTargetError) return `would be refused: ${error.message}`;
 		throw error;
 	}
 }
-function usesReadDestinationGate(scenario) {
-	return (scenario.type === "actor" || scenario.type === "object") && !scenario.authenticated;
-}
 function assertPublicDestinationOverrideAllowed(url, scenario, context) {
 	const inheritsTargetGate = url.origin === context.targetOrigin && context.targetBenchmarkMode;
 	if (context.destinationTier !== "public" || inheritsTargetGate || !context.allowUnsafe) return;
@@ -413,57 +295,15 @@ function unsafeOverrideScenarios(suite) {
 function unsafeOverrideScenario(scenario, defaults) {
 	const defaultDuration = defaults?.duration != null;
 	const defaultLoad = hasExplicitLoad(defaults?.load);
-	const defaultRuns = defaults?.runs != null;
 	const raw = "raw" in scenario ? scenario.raw : scenario;
 	return {
 		name: scenario.name,
 		explicitDuration: raw.duration != null || defaultDuration,
-		explicitLoad: hasExplicitLoad(raw.load) || defaultLoad,
-		explicitRuns: raw.runs != null || defaultRuns
+		explicitLoad: hasExplicitLoad(raw.load) || defaultLoad
 	};
 }
 function hasExplicitLoad(load) {
 	return load != null && typeof load === "object" && ("rate" in load && load.rate != null || "concurrency" in load && load.concurrency != null);
 }
-function scenarioNeedsSyntheticServer(scenario, scenarios, seen = /* @__PURE__ */ new Set()) {
-	if (seen.has(scenario.name)) return false;
-	const nextSeen = new Set(seen).add(scenario.name);
-	switch (scenario.type) {
-		case "inbox": return true;
-		case "actor":
-		case "object": return scenario.authenticated;
-		case "failure": return failureFaultsOf(scenario).some(isInboundFailureFault);
-		case "mixed": return mixedChildrenOf(scenario, scenarios).some((child) => scenarioNeedsSyntheticServer(child, scenarios, nextSeen));
-		default: return false;
-	}
-}
-function scenarioNeedsReachableLocalServer(scenario, scenarios, seen = /* @__PURE__ */ new Set()) {
-	if (scenario.type === "fanout") return scenario.raw.sinkBase == null;
-	if (scenario.type === "failure") {
-		const faults = failureFaultsOf(scenario);
-		return faults.includes("invalid-signature") || scenario.raw.sinkBase == null && faults.some(isRemoteFailureFault);
-	}
-	if (scenario.type === "mixed") {
-		if (seen.has(scenario.name)) return false;
-		const nextSeen = new Set(seen).add(scenario.name);
-		return mixedChildrenOf(scenario, scenarios).some((child) => scenarioNeedsReachableLocalServer(child, scenarios, nextSeen));
-	}
-	return scenarioNeedsSyntheticServer(scenario, scenarios, seen);
-}
-function failureFaultsOf(scenario) {
-	return scenario.faults.length < 1 ? ["remote-404"] : scenario.faults;
-}
-function mixedChildrenOf(scenario, scenarios) {
-	return (scenario.raw.mix ?? []).flatMap((entry) => {
-		const child = scenarios.find((candidate) => candidate.name === entry.scenario);
-		return child == null ? [] : [child];
-	});
-}
-function isInboundFailureFault(fault) {
-	return fault === "invalid-signature" || fault === "missing-actor";
-}
-function isRemoteFailureFault(fault) {
-	return fault === "remote-404" || fault === "remote-410" || fault === "slow-inbox" || fault === "network-error";
-}
 //#endregion
 export { runBench as default };

package/dist/bench/command.js

@@ -1,7 +1,7 @@
 import "@js-temporal/polyfill";
 import { configContext } from "../config.js";
 import { userAgentOption } from "../options.js";
-import { argument, choice, command, constant, flag, group, merge, message, object, option, optional, or, string, withDefault } from "@optique/core";
+import { argument, choice, command, constant, flag, group, merge, message, object, option, optional, string, withDefault } from "@optique/core";
 import { bindConfig } from "@optique/config";
 //#region src/bench/command.ts
 const formatOption = bindConfig(option("-f", "--format", choice([
@@ -16,57 +16,27 @@ const formatOption = bindConfig(option("-f", "--format", choice([
 const allowUnsafeTarget = withDefault(flag("--allow-unsafe-target", { description: message`Allow benchmarking a public target that does not advertise \
 benchmark mode.  Must be given on the command line for each run; it cannot be \
 set in a configuration file.` }), false);
-const outputOption = optional(option("-o", "--output", string({ metavar: "OUTPUT_PATH" }), { description: message`Write the report to a file instead of standard output.` }));
-const targetOption = optional(option("-t", "--target", string({ metavar: "URL" }), { description: message`Override the target URL declared in the suite.` }));
-const advertiseHostOption = optional(option("--advertise-host", string({ metavar: "HOST" }), { description: message`Host (name or IP) a non-loopback target can reach the \
-benchmark's synthetic actor server at.  Required for signed scenarios against a \
-non-loopback target; binds the synthetic server on all interfaces and uses this \
-host in the actor and key URLs the target dereferences.` }));
-const runParser = merge("Benchmark options", object({
+const benchCommand = command("bench", merge("Benchmark options", object({
 	command: constant("bench"),
-	mode: constant("run"),
 	scenario: group("Arguments", argument(string({ metavar: "SCENARIO_FILE" }), { description: message`Path to the benchmark suite file (YAML or JSON).` })),
-	target: targetOption,
+	target: optional(option("-t", "--target", string({ metavar: "URL" }), { description: message`Override the target URL declared in the suite.` })),
 	format: formatOption,
-	output: outputOption,
+	output: optional(option("-o", "--output", string({ metavar: "OUTPUT_PATH" }), { description: message`Write the report to a file instead of standard output.` })),
 	dryRun: withDefault(flag("--dry-run", { description: message`Resolve discovery and print the benchmark plan without \
 sending load.` }), false),
-	advertiseHost: advertiseHostOption,
-	allowUnsafeTarget
-}), userAgentOption);
-const benchOptions = or(command("compare", merge("Compare options", object({
-	command: constant("bench"),
-	mode: constant("compare"),
-	base: option("--base", string({ metavar: "REF" }), { description: message`The base git ref to benchmark.` }),
-	head: option("--head", string({ metavar: "REF" }), { description: message`The head git ref to benchmark.` }),
-	file: option("--file", string({ metavar: "SCENARIO_FILE" }), { description: message`Path to the benchmark suite file (YAML or JSON).` }),
-	startCommand: option("--start-command", string({ metavar: "COMMAND" }), { description: message`Shell command that starts the target application in each \
-checked-out worktree.` }),
-	readyUrl: option("--ready-url", string({ metavar: "URL" }), { description: message`URL that returns success when the started target is ready.` }),
-	readyTimeout: withDefault(option("--ready-timeout", string({ metavar: "DURATION" }), { description: message`How long to wait for --ready-url.` }), "30s"),
-	maxRegression: option("--max-regression", string({ metavar: "PERCENT" }), { description: message`Maximum regression tolerated after the measured noise band.` }),
-	target: targetOption,
-	format: formatOption,
-	output: outputOption,
-	dryRun: constant(false),
-	advertiseHost: advertiseHostOption,
+	advertiseHost: optional(option("--advertise-host", string({ metavar: "HOST" }), { description: message`Host (name or IP) a non-loopback target can reach the \
+benchmark's synthetic actor server at.  Required for signed scenarios against a \
+non-loopback target; binds the synthetic server on all interfaces and uses this \
+host in the actor and key URLs the target dereferences.` })),
 	allowUnsafeTarget
 }), userAgentOption), {
-	brief: message`Compare base and head benchmark runs.`,
-	description: message`Run the same benchmark suite against two git revisions on the \
-same runner, then fail when the head revision regresses beyond the configured \
-tolerance and measured noise band.`
-}), runParser);
-const benchMetadata = {
 	brief: message`Benchmark a Fedify federation workload.`,
 	description: message`Run an ActivityPub-specific load benchmark against a \
 cooperative Fedify target running in benchmark mode.
 
-The suite file declares the target, actors, and scenarios.  This version \
-executes the \`inbox\`, \`webfinger\`, \`actor\`, \`object\`, \`fanout\`, \
-\`failure\`, and \`mixed\` scenario types; \`collection\` remains reserved by \
-the suite format.`
-};
-command("bench", benchOptions, benchMetadata);
+The suite file declares the target, actors, and scenarios.  Only the \`inbox\` \
+and \`webfinger\` scenario types are executed in this version; the format \
+itself can express every scenario type.`
+});
 //#endregion
-export { benchMetadata, benchOptions };
+export { benchCommand };

package/dist/bench/load/clock.js

@@ -4,30 +4,12 @@ import "@js-temporal/polyfill";
 function systemClock() {
 	return {
 		now: () => performance.now(),
-		sleepUntil(timeMs, signal) {
-			if (signal?.aborted) return Promise.reject(abortReason(signal));
+		sleepUntil(timeMs) {
 			const remaining = timeMs - performance.now();
 			if (remaining <= 0) return Promise.resolve();
-			return new Promise((resolve, reject) => {
-				const timer = setTimeout(() => {
-					cleanup();
-					resolve();
-				}, remaining);
-				const onAbort = () => {
-					clearTimeout(timer);
-					cleanup();
-					reject(abortReason(signal));
-				};
-				const cleanup = () => {
-					signal?.removeEventListener("abort", onAbort);
-				};
-				signal?.addEventListener("abort", onAbort, { once: true });
-			});
+			return new Promise((resolve) => setTimeout(resolve, remaining));
 		}
 	};
 }
-function abortReason(signal) {
-	return signal.reason ?? /* @__PURE__ */ new Error("Operation aborted.");
-}
 //#endregion
 export { systemClock };

package/dist/bench/load/generator.js

@@ -9,10 +9,10 @@ import { systemClock } from "./clock.js";
 * @param clock The clock (overridable for tests); defaults to the system clock.
 * @returns The recorded samples and run metadata.
 */
-function runLoad(plan, send, clock = systemClock(), signal) {
-	return plan.load.kind === "open" ? runOpenLoop(plan, plan.load, send, clock, signal) : runClosedLoop(plan, plan.load, send, clock, signal);
+function runLoad(plan, send, clock = systemClock()) {
+	return plan.load.kind === "open" ? runOpenLoop(plan, plan.load, send, clock) : runClosedLoop(plan, plan.load, send, clock);
 }
-async function runOpenLoop(plan, load, send, clock, signal) {
+async function runOpenLoop(plan, load, send, clock) {
 	const arrivals = scheduleArrivals({
 		ratePerSec: load.ratePerSec,
 		durationMs: plan.durationMs,
@@ -25,13 +25,8 @@ async function runOpenLoop(plan, load, send, clock, signal) {
 	const start = clock.now();
 	const active = /* @__PURE__ */ new Set();
 	for (const offset of arrivals) {
-		throwIfAborted(signal);
-		await clock.sleepUntil(start + offset, signal);
-		if (await slots.acquire(signal)) saturated = true;
-		if (signal?.aborted) {
-			slots.release();
-			throw abortReason(signal);
-		}
+		await clock.sleepUntil(start + offset);
+		if (await slots.acquire()) saturated = true;
 		const dispatched = dispatch(send, offset, start, plan.warmupMs, clock, samples).finally(() => {
 			slots.release();
 			active.delete(dispatched);
@@ -45,7 +40,7 @@ async function runOpenLoop(plan, load, send, clock, signal) {
 		wallDurationMs: clock.now() - start
 	};
 }
-async function runClosedLoop(plan, load, send, clock, signal) {
+async function runClosedLoop(plan, load, send, clock) {
 	const samples = [];
 	const slots = createSemaphore(load.maxInFlight);
 	let saturated = false;
@@ -53,12 +48,7 @@ async function runClosedLoop(plan, load, send, clock, signal) {
 	const deadline = start + plan.durationMs;
 	async function worker() {
 		while (clock.now() < deadline) {
-			throwIfAborted(signal);
-			if (await slots.acquire(signal)) saturated = true;
-			if (signal?.aborted) {
-				slots.release();
-				throw abortReason(signal);
-			}
+			if (await slots.acquire()) saturated = true;
 			if (clock.now() >= deadline) {
 				slots.release();
 				break;
@@ -104,29 +94,12 @@ function createSemaphore(max) {
 	let count = 0;
 	const queue = [];
 	return {
-		acquire(signal) {
-			throwIfAborted(signal);
+		acquire() {
 			if (count < max) {
 				count++;
 				return Promise.resolve(false);
 			}
-			return new Promise((resolve, reject) => {
-				const waiter = () => {
-					cleanup();
-					resolve(true);
-				};
-				const onAbort = () => {
-					const index = queue.indexOf(waiter);
-					if (index >= 0) queue.splice(index, 1);
-					cleanup();
-					reject(abortReason(signal));
-				};
-				const cleanup = () => {
-					signal?.removeEventListener("abort", onAbort);
-				};
-				signal?.addEventListener("abort", onAbort, { once: true });
-				queue.push(waiter);
-			});
+			return new Promise((resolve) => queue.push(() => resolve(true)));
 		},
 		release() {
 			const next = queue.shift();
@@ -135,11 +108,5 @@ function createSemaphore(max) {
 		}
 	};
 }
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw abortReason(signal);
-}
-function abortReason(signal) {
-	return signal.reason ?? /* @__PURE__ */ new Error("Benchmark load aborted.");
-}
 //#endregion
 export { runLoad };

package/dist/bench/metrics/stats-client.js

@@ -36,13 +36,9 @@ function parseServerSnapshot(snapshot) {
 			const values = depth.dataPoints.map((p) => p.value).filter(isFiniteNumber);
 			if (values.length > 0) queueDepthMax = Math.max(...values);
 		}
-		const queueTasks = parseQueueTasks(metrics);
-		const deliveryPermanentFailures = sumMetric(metrics, "activitypub.delivery.permanent_failure");
 		return {
 			signature,
-			queueDepthMax,
-			...queueTasks == null ? {} : { queueTasks },
-			...deliveryPermanentFailures == null ? {} : { deliveryPermanentFailures }
+			queueDepthMax
 		};
 	} catch {
 		return null;
@@ -60,13 +56,9 @@ function parseServerSnapshot(snapshot) {
 * @returns The windowed snapshot.
 */
 function diffSnapshots(baseline, end) {
-	const queueTasks = diffQueueTasks(baseline.queueTasks ?? null, end.queueTasks ?? null);
-	const deliveryPermanentFailures = diffCounter(baseline.deliveryPermanentFailures ?? null, end.deliveryPermanentFailures ?? null);
 	return {
 		signature: diffHistogram(baseline.signature, end.signature),
-		queueDepthMax: end.queueDepthMax,
-		...queueTasks == null ? {} : { queueTasks },
-		...deliveryPermanentFailures == null ? {} : { deliveryPermanentFailures }
+		queueDepthMax: end.queueDepthMax
 	};
 }
 /**
@@ -103,21 +95,6 @@ async function fetchServerSnapshot(target, fetchImpl = fetch) {
 		return null;
 	}
 }
-/**
-* Returns the remaining queue task backlog represented by a diffed snapshot.
-* @param snapshot The server snapshot to inspect, usually already diffed
-* against a baseline.
-* @param baselineRemaining Queue tasks that were already outstanding when the
-* diff baseline was taken.  These must drain before diffed completions can be
-* attributed to newly enqueued tasks.
-* @returns `Math.max(0, baselineRemaining + enqueued - completed - failed)`,
-* or `null` when the snapshot has no queue task counters.
-*/
-function queueTaskRemaining(snapshot, baselineRemaining = 0) {
-	if (snapshot?.queueTasks == null) return null;
-	const { enqueued, completed, failed } = snapshot.queueTasks;
-	return Math.max(0, baselineRemaining + enqueued - completed - failed);
-}
 function isFiniteNumber(value) {
 	return typeof value === "number" && Number.isFinite(value);
 }
@@ -148,28 +125,6 @@ function mergeHistogram(dataPoints) {
 		counts
 	} : null;
 }
-function parseQueueTasks(metrics) {
-	const enqueued = sumMetric(metrics, "fedify.queue.task.enqueued");
-	const completed = sumMetric(metrics, "fedify.queue.task.completed");
-	const failed = sumMetric(metrics, "fedify.queue.task.failed");
-	return enqueued == null && completed == null && failed == null ? null : {
-		enqueued: enqueued ?? 0,
-		completed: completed ?? 0,
-		failed: failed ?? 0
-	};
-}
-function sumMetric(metrics, name) {
-	let total = 0;
-	let found = false;
-	for (const metric of metrics) {
-		if (metric.name !== name || !Array.isArray(metric.dataPoints)) continue;
-		for (const point of metric.dataPoints) if (isRecord(point) && isFiniteNumber(point["value"])) {
-			total += point["value"];
-			found = true;
-		}
-	}
-	return found ? total : null;
-}
 function diffHistogram(baseline, end) {
 	if (end == null) return null;
 	if (baseline == null) return end;
@@ -180,26 +135,9 @@ function diffHistogram(baseline, end) {
 		counts
 	};
 }
-function diffQueueTasks(baseline, end) {
-	if (end == null) return null;
-	if (baseline == null) return end;
-	return {
-		enqueued: Math.max(0, end.enqueued - baseline.enqueued),
-		completed: Math.max(0, end.completed - baseline.completed),
-		failed: Math.max(0, end.failed - baseline.failed)
-	};
-}
-function diffCounter(baseline, end) {
-	if (end == null) return null;
-	if (baseline == null) return end;
-	return Math.max(0, end - baseline);
-}
 function histogramsCompatible(a, b) {
 	return a.boundaries.length === b.boundaries.length && a.counts.length === b.counts.length && a.boundaries.every((boundary, i) => boundary === b.boundaries[i]);
 }
-function isRecord(value) {
-	return value != null && typeof value === "object" && !Array.isArray(value);
-}
 function histogramPercentile(histogram, p) {
 	const { boundaries, counts } = histogram;
 	const total = counts.reduce((sum, n) => sum + n, 0);
@@ -213,4 +151,4 @@ function histogramPercentile(histogram, p) {
 	return boundaries[boundaries.length - 1] ?? 0;
 }
 //#endregion
-export { diffSnapshots, fetchServerSnapshot, queueTaskRemaining, snapshotToMetrics };
+export { diffSnapshots, fetchServerSnapshot, snapshotToMetrics };