@fedify/cli 2.3.0-dev.1299 → 2.3.0-dev.1344

package/dist/bench/scenarios/mixed.js

@@ -0,0 +1,244 @@
+import "@js-temporal/polyfill";
+import { LogLinearHistogram } from "../metrics/histogram.js";
+import { actorRunner } from "./actor.js";
+import { fanoutRunner } from "./fanout.js";
+import { failureRunner } from "./failure.js";
+import { inboxRunner } from "./inbox.js";
+import { objectRunner } from "./object.js";
+import { webfingerRunner } from "./webfinger.js";
+//#region src/bench/scenarios/mixed.ts
+/**
+* The `mixed` scenario runner.
+* @since 2.3.0
+* @module
+*/
+/** The `mixed` scenario runner. */
+const mixedRunner = {
+	validate(scenario, context) {
+		if (scenario.raw.mix == null || scenario.raw.mix.length < 1) throw new Error(`Scenario "${scenario.name}": mixed requires at least one mix entry.`);
+		for (const entry of scenario.raw.mix) if (entry.weight <= 0) throw new Error(`Scenario "${scenario.name}": mix entry ${entry.scenario} has a non-positive weight.`);
+		if (scenario.load.kind === "closed" && scenario.load.concurrency < scenario.raw.mix.length) throw new Error(`Scenario "${scenario.name}": closed-loop mixed load needs at least one concurrency slot per mix entry.`);
+		const serverExpectation = Object.keys(scenario.expect).find(isServerExpectation);
+		if (serverExpectation != null) throw new Error(`Scenario "${scenario.name}": mixed server-side expectations are not supported (${JSON.stringify(serverExpectation)}).`);
+		if (context?.scenarios != null) {
+			const children = childScenarios(scenario, context.scenarios);
+			for (const child of children) runnerForChild(child.type).validate?.(child, context);
+			validateTargetQueueObservation(scenario, children);
+		}
+	},
+	async run(context) {
+		this.validate?.(context.scenario, { scenarios: context.scenarios });
+		if (context.scenarios == null) throw new Error("The mixed scenario requires the resolved scenario list.");
+		const children = childScenarios(context.scenario, context.scenarios);
+		const fetchImpl = limitedFetch(context.fetch ?? fetch, context.scenario.load.maxInFlight);
+		const results = await Promise.allSettled(children.map((child) => runnerForChild(child.type).run({
+			...context,
+			scenario: child,
+			fetch: fetchImpl,
+			assertDestinationAllowed: (url, scenario) => context.assertDestinationAllowed?.(url, scenario ?? child),
+			assertReadDestinationAllowed: (url, scenario) => context.assertReadDestinationAllowed?.(url, scenario ?? child),
+			assertActorlessDestinationAllowed: (url, scenario) => context.assertActorlessDestinationAllowed?.(url, scenario ?? child)
+		})));
+		const rejected = results.find((result) => result.status === "rejected");
+		if (rejected != null) throw rejected.reason;
+		return mergeMeasurements(results.filter((result) => result.status === "fulfilled").map((result) => result.value));
+	}
+};
+function isServerExpectation(metric) {
+	return metric.startsWith("signatureVerification.") || metric.startsWith("queueDrain.");
+}
+function validateTargetQueueObservation(scenario, children) {
+	const observers = children.filter(observesTargetQueue);
+	if (observers.length < 1) return;
+	if (children.filter(producesTargetQueue).length <= 1) return;
+	throw new Error(`Scenario "${scenario.name}": mixed scenarios cannot run queue-observing children (${observers.map((child) => child.name).join(", ")}) concurrently with other target queue producers because target queue counters are not scoped per child.`);
+}
+function observesTargetQueue(scenario) {
+	return scenario.type === "fanout" || scenario.type === "failure" && faultsOf(scenario).some(isRemoteFault);
+}
+function producesTargetQueue(scenario) {
+	return scenario.type === "inbox" || scenario.type === "fanout" || scenario.type === "failure" && faultsOf(scenario).some(isRemoteFault);
+}
+function faultsOf(scenario) {
+	return scenario.faults.length < 1 ? ["remote-404"] : scenario.faults;
+}
+function isRemoteFault(fault) {
+	return fault === "remote-404" || fault === "remote-410" || fault === "slow-inbox" || fault === "network-error";
+}
+function childScenarios(scenario, scenarios) {
+	const entries = scenario.raw.mix ?? [];
+	const totalWeight = entries.reduce((sum, entry) => sum + entry.weight, 0);
+	const closedLoads = scenario.load.kind === "closed" ? scaledClosedConcurrencies(scenario.load.concurrency, entries.map((entry) => entry.weight)) : void 0;
+	return entries.map((entry, index) => {
+		const children = scenarios.filter((candidate) => candidate.name === entry.scenario);
+		const child = children[0];
+		if (child == null) throw new Error(`Scenario "${scenario.name}": unknown mixed child ${JSON.stringify(entry.scenario)}.`);
+		if (children.length > 1) throw new Error(`Scenario "${scenario.name}": ambiguous mixed child ${JSON.stringify(entry.scenario)} matches ${children.length} scenarios.`);
+		if (child.type === "mixed") throw new Error(`Scenario "${scenario.name}": nested mixed scenarios are not supported.`);
+		const load = scaledLoad(scenario.load, entry.weight, totalWeight, closedLoads?.[index]);
+		return {
+			...child,
+			name: `${scenario.name}/${child.name}`,
+			load,
+			durationMs: scenario.durationMs,
+			warmupMs: scenario.warmupMs,
+			signing: scenario.signing,
+			signatureTimeWindow: scenario.signatureTimeWindow,
+			expect: {},
+			raw: {
+				...child.raw,
+				name: `${scenario.name}/${child.name}`,
+				load: rawLoad(load),
+				duration: `${scenario.durationMs}ms`,
+				warmup: `${scenario.warmupMs}ms`,
+				signing: scenario.signing,
+				signatureTimeWindow: scenario.signatureTimeWindow,
+				expect: {}
+			}
+		};
+	});
+}
+function scaledLoad(load, weight, totalWeight, closedConcurrency) {
+	if (load.kind === "open") return {
+		kind: "open",
+		ratePerSec: load.ratePerSec * (weight / totalWeight),
+		arrival: load.arrival
+	};
+	return {
+		kind: "closed",
+		concurrency: closedConcurrency ?? Math.max(1, Math.round(load.concurrency * weight / totalWeight))
+	};
+}
+function limitedFetch(fetchImpl, maxInFlight) {
+	if (maxInFlight == null) return fetchImpl;
+	const limiter = createLimiter(maxInFlight);
+	const limited = async (input, init) => {
+		const release = await limiter.acquire();
+		try {
+			return await fetchImpl(input, init);
+		} finally {
+			release();
+		}
+	};
+	return limited;
+}
+function createLimiter(maxInFlight) {
+	if (!Number.isInteger(maxInFlight) || maxInFlight < 1) throw new RangeError(`maxInFlight must be a positive integer; got ${maxInFlight}.`);
+	let active = 0;
+	const waiters = [];
+	return { async acquire() {
+		if (active < maxInFlight) active++;
+		else await new Promise((resolve) => waiters.push(resolve));
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			const next = waiters.shift();
+			if (next == null) active--;
+			else next();
+		};
+	} };
+}
+function scaledClosedConcurrencies(concurrency, weights) {
+	const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+	const ideal = weights.map((weight) => concurrency * weight / totalWeight);
+	const allocations = weights.map(() => 1);
+	for (let remaining = concurrency - weights.length; remaining > 0; remaining--) {
+		let best = 0;
+		for (let i = 1; i < allocations.length; i++) if (ideal[i] - allocations[i] > ideal[best] - allocations[best]) best = i;
+		allocations[best]++;
+	}
+	return allocations;
+}
+function rawLoad(load) {
+	if (load.kind === "open") return {
+		rate: load.ratePerSec,
+		arrival: load.arrival,
+		maxInFlight: load.maxInFlight
+	};
+	return {
+		concurrency: load.concurrency,
+		maxInFlight: load.maxInFlight
+	};
+}
+function runnerForChild(type) {
+	switch (type) {
+		case "inbox": return inboxRunner;
+		case "webfinger": return webfingerRunner;
+		case "actor": return actorRunner;
+		case "object": return objectRunner;
+		case "fanout": return fanoutRunner;
+		case "failure": return failureRunner;
+		default: throw new Error(`The "${type}" scenario type cannot be used inside a mixed scenario.`);
+	}
+}
+function mergeMeasurements(measurements) {
+	const total = measurements.reduce((sum, m) => sum + m.requests.total, 0);
+	const ok = measurements.reduce((sum, m) => sum + m.requests.ok, 0);
+	const histogram = mergeHistograms(measurements);
+	const deliveryThroughputs = measurements.map((m) => m.deliveryThroughputPerSec).filter((value) => value != null);
+	return {
+		requests: {
+			total,
+			ok,
+			failed: total - ok,
+			successRate: total === 0 ? 1 : ok / total
+		},
+		throughputPerSec: measurements.reduce((sum, m) => sum + m.throughputPerSec, 0),
+		...deliveryThroughputs.length < 1 ? {} : { deliveryThroughputPerSec: deliveryThroughputs.reduce((sum, value) => sum + value, 0) },
+		client: { latencyMs: histogram == null ? mergeLatencyFallback(measurements) : latencyFromHistogram(histogram) },
+		server: null,
+		errors: mergeErrors(measurements),
+		...histogram == null ? {} : { histogram: histogram.toJSON() }
+	};
+}
+function mergeHistograms(measurements) {
+	let merged = null;
+	for (const measurement of measurements) {
+		if (measurement.histogram == null) return null;
+		const histogram = LogLinearHistogram.fromJSON(measurement.histogram);
+		if (merged == null) merged = histogram;
+		else merged.merge(histogram);
+	}
+	return merged;
+}
+function latencyFromHistogram(histogram) {
+	return {
+		p50: histogram.percentile(50),
+		p95: histogram.percentile(95),
+		p99: histogram.percentile(99),
+		mean: histogram.mean,
+		max: histogram.max
+	};
+}
+function mergeLatencyFallback(measurements) {
+	const total = measurements.reduce((sum, m) => sum + m.requests.total, 0);
+	if (measurements.length < 1) return {
+		p50: 0,
+		p95: 0,
+		p99: 0,
+		mean: 0,
+		max: 0
+	};
+	return {
+		p50: Math.max(...measurements.map((m) => m.client.latencyMs.p50)),
+		p95: Math.max(...measurements.map((m) => m.client.latencyMs.p95)),
+		p99: Math.max(...measurements.map((m) => m.client.latencyMs.p99)),
+		mean: total === 0 ? 0 : measurements.reduce((sum, m) => sum + m.client.latencyMs.mean * m.requests.total, 0) / total,
+		max: Math.max(...measurements.map((m) => m.client.latencyMs.max))
+	};
+}
+function mergeErrors(measurements) {
+	const buckets = /* @__PURE__ */ new Map();
+	for (const measurement of measurements) for (const error of measurement.errors) {
+		const key = `${error.kind}|${error.status ?? ""}|${error.reason}`;
+		const existing = buckets.get(key);
+		buckets.set(key, {
+			...error,
+			count: (existing?.count ?? 0) + error.count
+		});
+	}
+	return [...buckets.values()].sort((a, b) => b.count - a.count);
+}
+//#endregion
+export { mixedRunner };

package/dist/bench/scenarios/object-discovery.js

@@ -0,0 +1,211 @@
+import "@js-temporal/polyfill";
+import { convertUrlIfHandle } from "../../webfinger/lib.js";
+import { asList } from "../scenario/coerce.js";
+//#region src/bench/scenarios/object-discovery.ts
+/**
+* Discovery helpers for actor and object benchmark scenarios.
+* @since 2.3.0
+* @module
+*/
+const ACTIVITY_JSON_ACCEPT = "application/activity+json, application/ld+json";
+const WEBFINGER_ACCEPT = "application/jrd+json, application/json";
+const MAX_COLLECTION_CRAWL_PAGES = 100;
+const MAX_ACTIVITY_UNWRAP_DEPTH = 10;
+const ACTIVITY_WRAPPER_TYPES = new Set([
+	"Accept",
+	"Add",
+	"Announce",
+	"Create",
+	"Delete",
+	"Dislike",
+	"Flag",
+	"Ignore",
+	"Invite",
+	"Join",
+	"Leave",
+	"Like",
+	"Listen",
+	"Move",
+	"Offer",
+	"Question",
+	"Read",
+	"Reject",
+	"Remove",
+	"TentativeAccept",
+	"TentativeReject",
+	"Travel",
+	"Undo",
+	"Update",
+	"View"
+]);
+/** Resolves scenario recipients into actor document URLs. */
+async function actorUrlsFromRecipients(recipients, options) {
+	const urls = [];
+	for (const recipient of recipients) urls.push(await actorUrlFromRecipient(recipient, options));
+	return urls;
+}
+/** Resolves object scenario sources into object URLs. */
+async function objectUrlsFromSource(options) {
+	const { source } = options;
+	if (source == null) return [];
+	if (typeof source === "string" || Array.isArray(source)) return asList(source).map((url) => new URL(url));
+	const limit = source.limit ?? 100;
+	const types = new Set(asList(source.type));
+	const urls = [];
+	for (const seed of asList(source.seed)) {
+		const actorUrl = await actorUrlFromRecipient(seed, options);
+		await options.assertReadDestinationAllowed?.(actorUrl);
+		const actor = await fetchJson(actorUrl, options.fetch);
+		for (const collectionName of asList(source.collection ?? "outbox")) {
+			const collectionUrl = propertyUrl(actor, collectionName, actorUrl);
+			if (collectionUrl == null) continue;
+			for await (const objectUrl of crawlCollection(collectionUrl, {
+				fetch: options.fetch,
+				assertReadDestinationAllowed: options.assertReadDestinationAllowed,
+				types,
+				limit: limit - urls.length
+			})) {
+				urls.push(objectUrl);
+				if (urls.length >= limit) return urls;
+			}
+		}
+	}
+	return urls;
+}
+async function actorUrlFromRecipient(recipient, options) {
+	const identifier = convertUrlIfHandle(recipient);
+	if (identifier.protocol !== "acct:") return identifier;
+	const url = new URL("/.well-known/webfinger", options.target);
+	url.searchParams.set("resource", identifier.href);
+	const jrd = await fetchJson(url, options.fetch, WEBFINGER_ACCEPT);
+	const self = (Array.isArray(jrd.links) ? jrd.links : []).find((link) => isRecord(link) && link.rel === "self" && typeof link.href === "string");
+	if (!isRecord(self) || typeof self.href !== "string") throw new Error(`WebFinger response for ${recipient} has no self link.`);
+	return new URL(self.href);
+}
+async function* crawlCollection(start, options) {
+	let next = start;
+	let remaining = options.limit;
+	let pages = 0;
+	const visited = /* @__PURE__ */ new Set();
+	while (next != null && remaining > 0 && pages < MAX_COLLECTION_CRAWL_PAGES) {
+		if (visited.has(next.href)) return;
+		visited.add(next.href);
+		await options.assertReadDestinationAllowed?.(next);
+		const page = await fetchJson(next, options.fetch);
+		pages++;
+		const items = arrayProperty(page, "orderedItems") ?? arrayProperty(page, "items") ?? [];
+		for (const item of items) {
+			const url = await objectUrl(item, {
+				base: next,
+				fetch: options.fetch,
+				assertReadDestinationAllowed: options.assertReadDestinationAllowed,
+				types: options.types
+			});
+			if (url == null) continue;
+			yield url;
+			remaining--;
+			if (remaining <= 0) return;
+		}
+		const first = propertyUrl(page, "first", next);
+		next = propertyUrl(page, "next", next) ?? (next.href === start.href ? first : null);
+	}
+}
+async function fetchJson(url, fetchImpl = fetch, accept = ACTIVITY_JSON_ACCEPT) {
+	const response = await fetchImpl(new Request(url, {
+		headers: { accept },
+		redirect: "manual"
+	}));
+	if (!response.ok) {
+		await response.arrayBuffer().catch(() => {});
+		throw new Error(`Failed to fetch ${url.href}: HTTP ${response.status}.`);
+	}
+	let json;
+	try {
+		json = await response.json();
+	} catch (error) {
+		throw new Error(`Failed to parse JSON from ${url.href}: ${error}`);
+	}
+	if (!isRecord(json)) throw new Error(`Expected ${url.href} to return a JSON object.`);
+	return json;
+}
+async function objectUrl(item, options) {
+	for (const candidate of objectCandidates(item)) {
+		if (typeof candidate === "string") {
+			const url = safeUrl(candidate, options.base);
+			if (url == null) continue;
+			if (options.types.size < 1) return url;
+			const typedUrl = await typedReferencedObjectUrl(url, options);
+			if (typedUrl != null) return typedUrl;
+			continue;
+		}
+		if (!isRecord(candidate)) continue;
+		if (options.types.size > 0 && !matchesType(candidate.type, options.types)) continue;
+		const url = propertyUrl(candidate, "id", options.base);
+		if (url != null) return url;
+	}
+	return null;
+}
+async function typedReferencedObjectUrl(url, options, seen = /* @__PURE__ */ new Set(), depth = 0) {
+	if (depth > MAX_ACTIVITY_UNWRAP_DEPTH) return null;
+	if (seen.has(url.href)) return null;
+	seen.add(url.href);
+	await options.assertReadDestinationAllowed?.(url);
+	let object;
+	try {
+		object = await fetchJson(url, options.fetch);
+	} catch {
+		return null;
+	}
+	for (const candidate of objectCandidates(object)) {
+		if (typeof candidate === "string") {
+			const candidateUrl = safeUrl(candidate, url);
+			if (candidateUrl == null) continue;
+			const typedUrl = await typedReferencedObjectUrl(candidateUrl, options, seen, depth + 1);
+			if (typedUrl != null) return typedUrl;
+			continue;
+		}
+		if (!isRecord(candidate)) continue;
+		if (!matchesType(candidate.type, options.types)) continue;
+		return propertyUrl(candidate, "id", url) ?? url;
+	}
+	return null;
+}
+function objectCandidates(item, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+	if (depth > MAX_ACTIVITY_UNWRAP_DEPTH) return [];
+	if (!isRecord(item) || !matchesType(item.type, ACTIVITY_WRAPPER_TYPES)) return [item];
+	if (seen.has(item)) return [];
+	seen.add(item);
+	const object = item.object;
+	if (object == null) return [];
+	if (Array.isArray(object)) return object.flatMap((entry) => entry == null ? [] : objectCandidates(entry, depth + 1, seen));
+	return objectCandidates(object, depth + 1, seen);
+}
+function matchesType(type, expected) {
+	if (typeof type === "string") return expected.has(type);
+	return Array.isArray(type) && type.some((item) => typeof item === "string" && expected.has(item));
+}
+function propertyUrl(object, key, base) {
+	const value = object[key];
+	if (typeof value === "string") return safeUrl(value, base);
+	if (isRecord(value)) {
+		if (typeof value.href === "string") return safeUrl(value.href, base);
+		if (typeof value.id === "string") return safeUrl(value.id, base);
+	}
+	return null;
+}
+function arrayProperty(object, key) {
+	const value = object[key];
+	return Array.isArray(value) ? value : null;
+}
+function isRecord(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function safeUrl(value, base) {
+	try {
+		return new URL(value, base);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { actorUrlsFromRecipients, objectUrlsFromSource };

package/dist/bench/scenarios/object.js

@@ -0,0 +1,54 @@
+import "@js-temporal/polyfill";
+import { convertUrlIfHandle } from "../../webfinger/lib.js";
+import { asList } from "../scenario/coerce.js";
+import { objectUrlsFromSource } from "./object-discovery.js";
+import { assertBareHttpUrl, isBareHttpUrl } from "./runner.js";
+import { runReadLoad } from "./read.js";
+//#region src/bench/scenarios/object.ts
+/**
+* The `object` scenario runner.
+* @since 2.3.0
+* @module
+*/
+/** The `object` scenario runner. */
+const objectRunner = {
+	validate(scenario) {
+		const { source } = scenario;
+		if (source == null) return;
+		if (typeof source === "string" || Array.isArray(source)) {
+			for (const url of asList(source)) {
+				let parsed;
+				try {
+					parsed = new URL(url);
+				} catch {
+					throw new Error(`Scenario "${scenario.name}": invalid object source URL ${JSON.stringify(url)}.`);
+				}
+				assertBareHttpUrl(scenario.name, "object source URL", parsed);
+			}
+			return;
+		}
+		for (const seed of asList(source.seed)) {
+			let url;
+			try {
+				url = convertUrlIfHandle(seed);
+			} catch {
+				throw new Error(`Scenario "${scenario.name}": invalid object source seed URL ${JSON.stringify(seed)}.`);
+			}
+			if (url.protocol !== "acct:" && !isBareHttpUrl(url)) throw new Error(`Scenario "${scenario.name}": object source seed 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 objectUrlsFromSource({
+				source: context.scenario.source,
+				target: context.target,
+				fetch: context.fetch,
+				assertReadDestinationAllowed: context.assertReadDestinationAllowed
+			}),
+			authenticated: context.scenario.authenticated
+		});
+	}
+};
+//#endregion
+export { objectRunner };

package/dist/bench/scenarios/read.js

@@ -0,0 +1,108 @@
+import "@js-temporal/polyfill";
+import { runLoad } from "../load/generator.js";
+import { aggregateSamples } from "../metrics/aggregate.js";
+import { diffSnapshots, fetchServerSnapshot, snapshotToMetrics } from "../metrics/stats-client.js";
+import { createSigningPipeline } from "../signing/pipeline.js";
+import { assertBareHttpUrl, estimateTotal, loadPlanOf, measuredWindowMs, sendRequest, withMeasuredWindowStart } from "./runner.js";
+import { signRequest } from "@fedify/fedify";
+//#region src/bench/scenarios/read.ts
+/**
+* Shared helpers for read-only benchmark scenarios.
+* @since 2.3.0
+* @module
+*/
+const READ_GATE_CONCURRENCY = 16;
+/**
+* Runs a read-only GET workload and aggregates client/server measurements.
+* @param context The scenario run context.
+* @param options Read workload options.
+* @returns The scenario measurement.
+*/
+async function runReadLoad(context, options) {
+	if (options.urls.length < 1) throw new Error(`Scenario "${context.scenario.name}" did not resolve any URLs to fetch.`);
+	const fetchImpl = context.fetch ?? fetch;
+	const actors = context.fleet?.actors ?? [];
+	if (options.authenticated && actors.length < 1) throw new Error(`Scenario "${context.scenario.name}" requires the synthetic actor server for authenticated fetches.`);
+	for (const url of options.urls) assertBareHttpUrl(context.scenario.name, "read URL", url);
+	await mapWithConcurrency(options.urls, READ_GATE_CONCURRENCY, async (url) => {
+		if (options.authenticated) await context.assertDestinationAllowed?.(url);
+		else await context.assertReadDestinationAllowed?.(url);
+	});
+	function unsignedRequest(index) {
+		const url = options.urls[index % options.urls.length];
+		return new Request(url, {
+			headers: { accept: "application/activity+json, application/ld+json" },
+			redirect: "manual"
+		});
+	}
+	let pipeline = null;
+	if (options.authenticated) {
+		let signIndex = 0;
+		pipeline = createSigningPipeline(context.scenario.signing, async () => {
+			const i = signIndex++;
+			return await signGetRequest(unsignedRequest(i), actors[i % actors.length]);
+		}, { total: estimateTotal(context.scenario) });
+	}
+	let index = 0;
+	const rawSend = async () => {
+		let request;
+		if (pipeline != null) try {
+			request = await pipeline.next();
+		} catch (error) {
+			return {
+				ok: false,
+				errorKind: "client",
+				reason: String(error)
+			};
+		}
+		else request = unsignedRequest(index++);
+		return await sendRequest(request, fetchImpl);
+	};
+	let baseline = null;
+	let baselineTaken = false;
+	const send = withMeasuredWindowStart(context.scenario.warmupMs, async () => {
+		baseline = await fetchServerSnapshot(context.target, fetchImpl);
+		baselineTaken = true;
+	}, rawSend);
+	try {
+		await pipeline?.prime();
+		const measurement = aggregateSamples((await runLoad(loadPlanOf(context.scenario, context.rng), send, context.clock, context.signal)).samples, {
+			measuredWindowMs: measuredWindowMs(context.scenario),
+			includeHistogram: true
+		});
+		const end = await fetchServerSnapshot(context.target, fetchImpl);
+		const server = baselineTaken && baseline != null && end != null ? snapshotToMetrics(diffSnapshots(baseline, end)) : null;
+		return {
+			...measurement,
+			server
+		};
+	} finally {
+		await pipeline?.close();
+	}
+}
+async function mapWithConcurrency(items, concurrency, callback) {
+	let next = 0;
+	let firstError;
+	let hasError = false;
+	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+		while (next < items.length && !hasError) {
+			const item = items[next++];
+			try {
+				await callback(item);
+			} catch (error) {
+				if (!hasError) {
+					hasError = true;
+					firstError = error;
+				}
+			}
+		}
+	});
+	await Promise.all(workers);
+	if (hasError) throw firstError;
+}
+async function signGetRequest(request, actor) {
+	if (actor.keys?.rsa == null || actor.rsaKeyId == null) throw new TypeError("Actor is missing the RSA key required for authenticated fetch signing.");
+	return await signRequest(request, actor.keys.rsa.privateKey, actor.rsaKeyId, { spec: actor.httpStandard });
+}
+//#endregion
+export { runReadLoad };

package/dist/bench/scenarios/registry.js

@@ -1,9 +1,22 @@
 import "@js-temporal/polyfill";
+import { actorRunner } from "./actor.js";
+import { fanoutRunner } from "./fanout.js";
+import { failureRunner } from "./failure.js";
 import { inboxRunner } from "./inbox.js";
+import { objectRunner } from "./object.js";
 import { webfingerRunner } from "./webfinger.js";
+import { mixedRunner } from "./mixed.js";
 //#region src/bench/scenarios/registry.ts
 /** The scenario types that have runners in this version. */
-const IMPLEMENTED_SCENARIO_TYPES = ["inbox", "webfinger"];
+const IMPLEMENTED_SCENARIO_TYPES = [
+	"inbox",
+	"webfinger",
+	"actor",
+	"object",
+	"fanout",
+	"failure",
+	"mixed"
+];
 /**
 * Returns the runner for a scenario type.
 * @param type The scenario type.
@@ -14,6 +27,11 @@ function runnerFor(type) {
 	switch (type) {
 		case "inbox": return inboxRunner;
 		case "webfinger": return webfingerRunner;
+		case "actor": return actorRunner;
+		case "object": return objectRunner;
+		case "fanout": return fanoutRunner;
+		case "failure": return failureRunner;
+		case "mixed": return mixedRunner;
 		default: throw new Error(`The "${type}" scenario type is not implemented in this version of fedify bench; supported types: ${IMPLEMENTED_SCENARIO_TYPES.join(", ")}.`);
 	}
 }

package/dist/bench/scenarios/runner.js

@@ -46,6 +46,26 @@ function estimateTotal(scenario) {
 	if (scenario.load.kind !== "open") return void 0;
 	return Math.ceil(scenario.load.ratePerSec * (scenario.durationMs / 1e3));
 }
+/** Returns whether a URL is fetchable by benchmark runners without surprises. */
+function isBareHttpUrl(url) {
+	return (url.protocol === "http:" || url.protocol === "https:") && url.hostname !== "" && url.username === "" && url.password === "";
+}
+/** Rejects URLs that are not bare http(s) URLs with a host and no credentials. */
+function assertBareHttpUrl(scenarioName, label, url) {
+	if (isBareHttpUrl(url)) return;
+	throw new Error(`Scenario "${scenarioName}": ${label} must be a bare http(s) URL with a host and no credentials; got ${JSON.stringify(url.href)}.`);
+}
+/** Validates an inbox selector or explicit inbox URL. */
+function validateInboxSelector(scenarioName, inbox) {
+	if (inbox == null || inbox === "shared" || inbox === "personal") return;
+	let url;
+	try {
+		url = new URL(inbox);
+	} catch {
+		throw new Error(`Scenario "${scenarioName}": inbox must be "shared", "personal", or an http(s) URL; got ${JSON.stringify(inbox)}.`);
+	}
+	assertBareHttpUrl(scenarioName, "inbox URL", url);
+}
 /**
 * Wraps a send function so that `onMeasuredWindowStart` runs exactly once, at
 * the warm-up boundary, and *every* measured request waits for it to settle
@@ -73,4 +93,4 @@ function withMeasuredWindowStart(warmupMs, onMeasuredWindowStart, send) {
 	};
 }
 //#endregion
-export { estimateTotal, loadPlanOf, measuredWindowMs, sendRequest, withMeasuredWindowStart };
+export { assertBareHttpUrl, estimateTotal, isBareHttpUrl, loadPlanOf, measuredWindowMs, sendRequest, validateInboxSelector, withMeasuredWindowStart };