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

package/dist/bench/scenarios/failure.js

@@ -1,363 +0,0 @@
-import "@js-temporal/polyfill";
-import { discoverInbox, selectInbox } from "../discovery/discover.js";
-import { systemClock } from "../load/clock.js";
-import { runLoad } from "../load/generator.js";
-import { aggregateSamples } from "../metrics/aggregate.js";
-import { diffSnapshots, fetchServerSnapshot, queueTaskRemaining } from "../metrics/stats-client.js";
-import { loadPlanOf, measuredWindowMs, sendRequest, validateInboxSelector } from "./runner.js";
-import { createActivityIdMinter } from "../signing/activity-id.js";
-import { signInboxDelivery } from "../signing/signer.js";
-import { assertSinkRecipientsAllowed, resolveSinkBase, spawnSinkServer } from "./fanout.js";
-import { Create, Note } from "@fedify/vocab";
-//#region src/bench/scenarios/failure.ts
-/**
-* The `failure` scenario runner.
-* @since 2.3.0
-* @module
-*/
-const SUPPORTED_FAULTS = [
-	"invalid-signature",
-	"missing-actor",
-	"remote-404",
-	"remote-410",
-	"slow-inbox",
-	"network-error"
-];
-const DEFAULT_DRAIN_TIMEOUT_MS = 6e4;
-const DRAIN_POLL_MS = 25;
-/** The `failure` scenario runner. */
-const failureRunner = {
-	validate(scenario) {
-		const faults = scenario.faults.length < 1 ? ["remote-404"] : scenario.faults;
-		const remoteFaults = [...new Set(faults.filter(isRemoteFault))];
-		for (const fault of faults) if (!isSupportedFault(fault)) throw new Error(`Scenario "${scenario.name}": unsupported failure fault ${JSON.stringify(fault)}; supported faults: ${SUPPORTED_FAULTS.join(", ")}.`);
-		if (faults.some(isInboundFault)) validateInboxSelector(scenario.name, scenario.inbox);
-		if (faults.some(isInboundFault) && scenario.recipients.length < 1) throw new Error(`Scenario "${scenario.name}": invalid-signature and missing-actor faults require a recipient.`);
-		if (faults.some(isRemoteFault) && scenario.sender == null) throw new Error(`Scenario "${scenario.name}": remote failure faults require a sender.`);
-		if (faults.some(isRemoteFault)) resolveSinkBase(scenario.name, scenario.raw.sinkBase);
-		if (scenario.raw.sinkBase != null && remoteFaults.includes("network-error") && remoteFaults.some((fault) => fault !== "network-error")) throw new Error(`Scenario "${scenario.name}": sinkBase cannot combine network-error with other remote failure faults because the same port cannot be both open and unreachable.`);
-	},
-	async run(context) {
-		this.validate?.(context.scenario);
-		const clock = context.clock ?? systemClock();
-		const faults = faultsOf(context);
-		const deliveryTarget = await resolveFailureDeliveryTarget(context, faults);
-		const remoteTargets = await resolveRemoteFailureTargets(context, faults);
-		const remoteActivityIds = createActivityIdMinter(context.target);
-		try {
-			await assertSinkRecipientsAllowed([...remoteTargets.values()].map((target) => target.recipient), context);
-			let index = 0;
-			const sendOne = () => sendForFault(context, faults[index++ % faults.length], deliveryTarget, remoteTargets, remoteActivityIds);
-			let send = sendOne;
-			if (faults.some(isRemoteFault)) {
-				let previous = Promise.resolve();
-				send = () => {
-					const current = previous.then(sendOne);
-					previous = current.then(() => {}, () => {});
-					return current;
-				};
-			}
-			return aggregateSamples((await runLoad(loadPlanOf(context.scenario, context.rng), send, clock, context.signal)).samples, {
-				measuredWindowMs: measuredWindowMs(context.scenario),
-				includeHistogram: true
-			});
-		} finally {
-			await Promise.all([...remoteTargets.values()].map((target) => target.close()));
-		}
-	}
-};
-function faultsOf(context) {
-	return (context.scenario.faults.length < 1 ? ["remote-404"] : context.scenario.faults).map((fault) => {
-		if (isSupportedFault(fault)) return fault;
-		throw new Error(`Scenario "${context.scenario.name}": unsupported failure fault ${JSON.stringify(fault)}.`);
-	});
-}
-function isSupportedFault(fault) {
-	return SUPPORTED_FAULTS.includes(fault);
-}
-async function resolveFailureDeliveryTarget(context, faults) {
-	if (!faults.some(isInboundFault)) return null;
-	const { scenario } = context;
-	const discovered = await discoverInbox(scenario.recipients[0], {
-		documentLoader: context.documentLoader,
-		contextLoader: context.contextLoader,
-		allowPrivateAddress: context.allowPrivateAddress
-	});
-	const inbox = selectInbox(discovered, scenario.inbox);
-	if (faults.every((fault) => fault === "missing-actor")) await context.assertActorlessDestinationAllowed?.(inbox);
-	else await context.assertDestinationAllowed?.(inbox);
-	return {
-		inbox,
-		actorUri: discovered.actorUri
-	};
-}
-function isInboundFault(fault) {
-	return fault === "invalid-signature" || fault === "missing-actor";
-}
-function isRemoteFault(fault) {
-	return fault === "remote-404" || fault === "remote-410" || fault === "slow-inbox" || fault === "network-error";
-}
-async function resolveRemoteFailureTargets(context, faults) {
-	const targets = /* @__PURE__ */ new Map();
-	try {
-		const remoteFaults = [...new Set(faults.filter(isRemoteFault))];
-		const liveFaults = remoteFaults.filter((fault) => fault !== "network-error");
-		if (liveFaults.length > 0) {
-			const sink = await spawnSinkServer({
-				followers: liveFaults.length,
-				rawBehavior: null,
-				rawBehaviors: liveFaults.map(remoteSinkBehavior),
-				advertiseHost: context.advertiseHost,
-				sinkBase: context.scenario.raw.sinkBase
-			});
-			const close = once(sink.close);
-			for (const [index, fault] of liveFaults.entries()) targets.set(fault, {
-				recipient: sink.recipients[index],
-				close
-			});
-		}
-		if (remoteFaults.includes("network-error")) {
-			const sink = await spawnSinkServer({
-				followers: 1,
-				rawBehavior: remoteSinkBehavior("network-error"),
-				advertiseHost: context.advertiseHost,
-				sinkBase: context.scenario.raw.sinkBase
-			});
-			const recipient = sink.recipients[0];
-			try {
-				await sink.close();
-				targets.set("network-error", {
-					recipient,
-					close: () => Promise.resolve()
-				});
-			} catch (error) {
-				await sink.close().catch(() => {});
-				throw error;
-			}
-		}
-		return targets;
-	} catch (error) {
-		await Promise.all([...targets.values()].map((target) => target.close()));
-		throw error;
-	}
-}
-function once(close) {
-	let closed = null;
-	return () => {
-		closed ??= close();
-		return closed;
-	};
-}
-function remoteSinkBehavior(fault) {
-	switch (fault) {
-		case "remote-404": return { status: 404 };
-		case "remote-410": return { status: 410 };
-		case "slow-inbox": return {
-			status: 202,
-			latency: "25ms"
-		};
-		case "network-error": return { status: 202 };
-	}
-}
-async function sendForFault(context, fault, deliveryTarget, remoteTargets, remoteActivityIds) {
-	switch (fault) {
-		case "invalid-signature": return await sendInvalidSignature(context, requiredTarget(deliveryTarget));
-		case "missing-actor": return await sendMissingActor(context, requiredTarget(deliveryTarget));
-		case "remote-404":
-		case "remote-410":
-		case "slow-inbox":
-		case "network-error": return await sendRemoteFailure(context, fault, requiredRemoteTarget(fault, remoteTargets), remoteActivityIds);
-	}
-}
-async function sendRemoteFailure(context, fault, target, remoteActivityIds) {
-	const fetchImpl = context.fetch ?? fetch;
-	const baseline = await fetchServerSnapshot(context.target, fetchImpl);
-	const response = await fetchImpl(new URL("/.well-known/fedify/bench/trigger", context.target), {
-		method: "POST",
-		headers: { "content-type": "application/json" },
-		redirect: "manual",
-		body: JSON.stringify({
-			sender: { identifier: requiredSender(context) },
-			recipients: [target.recipient],
-			activity: buildRemoteFailureActivity(context, remoteActivityIds.next())
-		})
-	});
-	await response.arrayBuffer().catch(() => {});
-	if (!response.ok) return {
-		ok: false,
-		status: response.status,
-		reason: `status_${response.status}`
-	};
-	const observation = await waitForRemoteFault({
-		target: context.target,
-		fetch: fetchImpl,
-		baseline,
-		fault,
-		clock: context.clock ?? systemClock(),
-		signal: context.signal,
-		timeoutMs: context.scenario.queueDrainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS
-	});
-	if (observation == null) return {
-		ok: false,
-		errorKind: "server",
-		reason: "stats_unavailable"
-	};
-	if (observation.timedOut) return {
-		ok: false,
-		errorKind: "server",
-		reason: "expected_remote_failure_not_observed"
-	};
-	return expectedRemoteFailure(fault);
-}
-function buildRemoteFailureActivity(context, id) {
-	const objectId = new URL(`/objects/${crypto.randomUUID()}`, context.target);
-	return {
-		"@context": "https://www.w3.org/ns/activitystreams",
-		type: "Create",
-		id: id.href,
-		actor: new URL(`/users/${requiredSender(context)}`, context.target).href,
-		object: {
-			type: "Note",
-			id: objectId.href,
-			content: "Benchmark failure activity."
-		}
-	};
-}
-async function waitForRemoteFault(options) {
-	if (options.baseline == null) return null;
-	const baselineRemaining = queueTaskRemaining(options.baseline) ?? 0;
-	const deadline = options.clock.now() + options.timeoutMs;
-	do {
-		throwIfAborted(options.signal);
-		const snapshot = await fetchServerSnapshot(options.target, options.fetch);
-		throwIfAborted(options.signal);
-		if (snapshot != null) {
-			const diff = diffSnapshots(options.baseline, snapshot);
-			const queueTasks = diff.queueTasks;
-			if (options.fault === "remote-404" || options.fault === "remote-410") {
-				if ((diff.deliveryPermanentFailures ?? 0) > 0) return { timedOut: false };
-			} else if (queueTasks != null) {
-				const remaining = queueTaskRemaining(diff, baselineRemaining);
-				if (remaining != null) {
-					if (options.fault === "slow-inbox") {
-						if (queueTasks.completed > 0 && remaining === 0) return { timedOut: false };
-					} else if (options.fault === "network-error") {
-						if (queueTasks.failed > 0 || queueTasks.completed > 0 && remaining > 0) return { timedOut: false };
-					}
-				}
-			}
-		}
-		const now = options.clock.now();
-		if (now >= deadline) break;
-		await options.clock.sleepUntil(Math.min(deadline, now + DRAIN_POLL_MS), options.signal);
-	} while (options.clock.now() < deadline);
-	return { timedOut: true };
-}
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw abortReason(signal);
-}
-function abortReason(signal) {
-	return signal.reason ?? /* @__PURE__ */ new Error("Operation aborted.");
-}
-function expectedRemoteFailure(fault) {
-	switch (fault) {
-		case "remote-404": return {
-			ok: true,
-			status: 404
-		};
-		case "remote-410": return {
-			ok: true,
-			status: 410
-		};
-		case "slow-inbox": return {
-			ok: true,
-			status: 202
-		};
-		case "network-error": return {
-			ok: true,
-			errorKind: "network",
-			reason: "expected_network_error"
-		};
-	}
-}
-async function sendInvalidSignature(context, deliveryTarget) {
-	const request = await signedFailureRequest(context, "invalid-signature", deliveryTarget);
-	const body = await request.arrayBuffer();
-	const headers = new Headers(request.headers);
-	invalidateSignedDate(headers);
-	return expectedFailure(await sendRequest(new Request(request.url, {
-		method: request.method,
-		headers,
-		body,
-		redirect: "manual"
-	}), context.fetch ?? fetch), 401);
-}
-function invalidateSignedDate(headers) {
-	const timestamp = Date.parse(headers.get("date") ?? "");
-	const shifted = Number.isNaN(timestamp) ? /* @__PURE__ */ new Date() : new Date(timestamp + 1e3);
-	headers.set("date", shifted.toUTCString());
-}
-async function sendMissingActor(context, deliveryTarget) {
-	return expectedFailure(await sendRequest(await signedFailureRequest(context, "missing-actor", deliveryTarget), context.fetch ?? fetch), 401);
-}
-async function signedFailureRequest(context, fault, deliveryTarget) {
-	const { fleet, scenario } = context;
-	if (fleet == null || fleet.actors.length < 1) throw new Error("The failure scenario requires the synthetic actor server.");
-	if (scenario.recipients.length < 1) throw new Error("The invalid-signature and missing-actor faults require a recipient.");
-	const actor = fault === "missing-actor" ? missingActor(fleet.actors[0], context.target) : fleet.actors[0];
-	const id = createActivityIdMinter(fleet.url).next();
-	const note = new Note({
-		id: new URL(`/objects/${crypto.randomUUID()}`, fleet.url),
-		attribution: actor.id,
-		content: "Benchmark failure activity.",
-		to: deliveryTarget.actorUri
-	});
-	const activity = new Create({
-		id,
-		actor: actor.id,
-		object: note,
-		to: deliveryTarget.actorUri
-	});
-	return await signInboxDelivery({
-		actor,
-		inbox: deliveryTarget.inbox,
-		activity,
-		contextLoader: context.contextLoader
-	});
-}
-function requiredTarget(target) {
-	if (target == null) throw new Error("The invalid-signature and missing-actor faults require discovery.");
-	return target;
-}
-function requiredRemoteTarget(fault, targets) {
-	const target = targets.get(fault);
-	if (target == null) throw new Error(`The ${fault} fault requires a benchmark sink.`);
-	return target;
-}
-function requiredSender(context) {
-	const sender = context.scenario.sender;
-	if (sender == null) throw new Error("Remote failure faults require a sender.");
-	return sender;
-}
-function missingActor(actor, target) {
-	const id = new URL(`/__fedify_bench/missing/${crypto.randomUUID()}`, target);
-	return {
-		...actor,
-		id,
-		rsaKeyId: actor.rsaKeyId == null ? void 0 : new URL("#main-key", id),
-		ed25519KeyId: actor.ed25519KeyId == null ? void 0 : new URL("#ed25519-key", id)
-	};
-}
-function expectedFailure(outcome, expectedStatus) {
-	if (outcome.status === expectedStatus) return {
-		ok: true,
-		status: outcome.status
-	};
-	return {
-		...outcome,
-		ok: false,
-		reason: outcome.reason ?? "expected_failure_not_observed"
-	};
-}
-//#endregion
-export { failureRunner };

package/dist/bench/scenarios/fanout.js

@@ -1,261 +0,0 @@
-import "@js-temporal/polyfill";
-import { parseDuration } from "../scenario/units.js";
-import { systemClock } from "../load/clock.js";
-import { runLoad } from "../load/generator.js";
-import { LogLinearHistogram } from "../metrics/histogram.js";
-import { aggregateSamples } from "../metrics/aggregate.js";
-import { diffSnapshots, fetchServerSnapshot, queueTaskRemaining } from "../metrics/stats-client.js";
-import { loadPlanOf, measuredWindowMs } from "./runner.js";
-import { createActivityIdMinter } from "../signing/activity-id.js";
-import { resolveAdvertiseHost } from "../server/synthetic.js";
-import { serve } from "srvx";
-//#region src/bench/scenarios/fanout.ts
-/**
-* The `fanout` scenario runner.
-* @since 2.3.0
-* @module
-*/
-const DEFAULT_FOLLOWERS = 5;
-const DEFAULT_DRAIN_TIMEOUT_MS = 6e4;
-const DRAIN_POLL_MS = 25;
-/** The `fanout` scenario runner. */
-const fanoutRunner = {
-	validate(scenario) {
-		if (triggerKind(scenario.raw.trigger) !== "benchmark-hook") throw new Error(`Scenario "${scenario.name}": fanout currently supports only trigger.kind: "benchmark-hook".`);
-		resolveSinkBase(scenario.name, scenario.raw.sinkBase);
-	},
-	async run(context) {
-		if (context.scenario.sender == null) throw new Error("The fanout scenario requires a sender.");
-		this.validate?.(context.scenario);
-		const clock = context.clock ?? systemClock();
-		const fetchImpl = context.fetch ?? fetch;
-		const sink = await spawnSinkServer({
-			followers: context.scenario.followers ?? DEFAULT_FOLLOWERS,
-			rawBehavior: context.scenario.raw.sinkBehavior,
-			advertiseHost: context.advertiseHost,
-			sinkBase: context.scenario.raw.sinkBase
-		});
-		const minter = createActivityIdMinter(context.target);
-		const drainHistogram = new LogLinearHistogram();
-		let delivered = 0;
-		try {
-			await assertSinkRecipientsAllowed(sink.recipients, context);
-			const sendOne = async (scheduledAtMs) => {
-				const baseline = await fetchServerSnapshot(context.target, fetchImpl);
-				const started = Date.now();
-				const response = await fetchImpl(new URL("/.well-known/fedify/bench/trigger", context.target), {
-					method: "POST",
-					headers: { "content-type": "application/json" },
-					redirect: "manual",
-					body: JSON.stringify({
-						sender: { identifier: context.scenario.sender },
-						recipients: sink.recipients,
-						activity: buildActivity(context, minter.next())
-					})
-				});
-				await response.arrayBuffer().catch(() => {});
-				if (!response.ok) return {
-					ok: false,
-					status: response.status,
-					reason: `status_${response.status}`
-				};
-				const drain = await waitForDrain({
-					target: context.target,
-					fetch: fetchImpl,
-					baseline,
-					clock,
-					signal: context.signal,
-					timeoutMs: context.scenario.queueDrainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS
-				});
-				if (drain == null) return {
-					ok: false,
-					errorKind: "server",
-					reason: "stats_unavailable"
-				};
-				if (drain.timedOut) return {
-					ok: false,
-					errorKind: "server",
-					reason: "queue_drain_timeout"
-				};
-				if (drain.failed > 0) return {
-					ok: false,
-					errorKind: "server",
-					reason: "queue_delivery_failed"
-				};
-				if (scheduledAtMs >= context.scenario.warmupMs) {
-					drainHistogram.record(Date.now() - started);
-					delivered += sink.recipients.length;
-				}
-				return {
-					ok: true,
-					status: response.status
-				};
-			};
-			let previous = Promise.resolve();
-			const send = (scheduledAtMs) => {
-				const current = previous.then(() => sendOne(scheduledAtMs));
-				previous = current.then(() => {}, () => {});
-				return current;
-			};
-			const measurement = aggregateSamples((await runLoad(loadPlanOf(context.scenario, context.rng), send, clock, context.signal)).samples, {
-				measuredWindowMs: measuredWindowMs(context.scenario),
-				includeHistogram: true
-			});
-			const server = addQueueDrain(measurement.server, drainHistogram);
-			const deliveryThroughputPerSec = delivered / (Math.max(measuredWindowMs(context.scenario), 1) / 1e3);
-			return {
-				...measurement,
-				deliveryThroughputPerSec,
-				server
-			};
-		} finally {
-			await sink.close();
-		}
-	}
-};
-function triggerKind(trigger) {
-	if (trigger == null) return "benchmark-hook";
-	if (typeof trigger !== "object" || Array.isArray(trigger)) return "";
-	const kind = trigger.kind;
-	return typeof kind === "string" ? kind : "benchmark-hook";
-}
-function buildActivity(context, id) {
-	const objectId = new URL(`/objects/${crypto.randomUUID()}`, context.target);
-	return {
-		"@context": "https://www.w3.org/ns/activitystreams",
-		type: "Create",
-		id: id.href,
-		actor: new URL(`/users/${context.scenario.sender}`, context.target).href,
-		object: {
-			type: "Note",
-			id: objectId.href,
-			content: "Benchmark fanout activity."
-		}
-	};
-}
-async function assertSinkRecipientsAllowed(recipients, context) {
-	for (const recipient of recipients) {
-		if (typeof recipient.inbox !== "string") continue;
-		await context.assertActorlessDestinationAllowed?.(new URL(recipient.inbox), context.scenario);
-	}
-}
-async function spawnSinkServer(options) {
-	const sinkBase = resolveSinkBase("benchmark sink", options.sinkBase);
-	const advertised = options.advertiseHost == null ? null : resolveAdvertiseHost(options.advertiseHost);
-	const behaviors = Array.from({ length: options.followers }, (_, i) => parseSinkBehavior(options.rawBehaviors?.[i] ?? options.rawBehavior));
-	const server = serve({
-		port: sinkBase?.port ?? 0,
-		hostname: sinkBase?.bindHost ?? advertised?.bindHost ?? "127.0.0.1",
-		silent: true,
-		async fetch(request) {
-			const match = /^\/inbox\/(\d+)(?:\/|$)/.exec(new URL(request.url).pathname);
-			if (match != null) {
-				const behavior = behaviors[Number(match[1])] ?? parseSinkBehavior(options.rawBehavior);
-				await request.arrayBuffer().catch(() => {});
-				if (behavior.latencyMs > 0) await new Promise((resolve) => setTimeout(resolve, behavior.latencyMs));
-				return new Response("accepted", { status: behavior.status });
-			}
-			return new Response("Not found", { status: 404 });
-		}
-	});
-	await server.ready();
-	const bound = new URL(server.url);
-	const base = sinkBase?.base ?? (advertised == null ? bound : new URL(`http://${advertised.urlHost}:${bound.port}/`));
-	return {
-		recipients: Array.from({ length: options.followers }, (_, i) => ({
-			"@context": "https://www.w3.org/ns/activitystreams",
-			type: "Service",
-			id: new URL(`/actors/${i}`, base).href,
-			inbox: new URL(`/inbox/${i}`, base).href
-		})),
-		close: () => server.close(true)
-	};
-}
-function resolveSinkBase(scenarioName, value) {
-	if (value == null) return null;
-	let url;
-	try {
-		url = new URL(value);
-	} catch {
-		throw new Error(`Scenario "${scenarioName}": sinkBase must be an http URL with an explicit port; got ${JSON.stringify(value)}.`);
-	}
-	const port = Number(url.port);
-	if (url.protocol !== "http:" || url.hostname === "" || url.username !== "" || url.password !== "" || url.port === "" || !Number.isInteger(port) || port < 1 || url.pathname !== "/" || url.search !== "" || url.hash !== "") throw new Error(`Scenario "${scenarioName}": sinkBase must be an http URL with a host, an explicit non-zero port, no credentials, and no path, query, or fragment; got ${JSON.stringify(value)}.`);
-	const advertised = resolveAdvertiseHost(url.hostname);
-	return {
-		base: new URL(`http://${advertised.urlHost}:${url.port}/`),
-		bindHost: advertised.bindHost,
-		port
-	};
-}
-function parseSinkBehavior(raw) {
-	if (raw == null || typeof raw !== "object" || Array.isArray(raw)) return {
-		latencyMs: 0,
-		status: 202
-	};
-	const record = raw;
-	const latency = record.latency;
-	const status = record.status;
-	let latencyMs = 0;
-	if (typeof latency === "string") try {
-		latencyMs = parseDuration(latency);
-	} catch {
-		latencyMs = 0;
-	}
-	return {
-		latencyMs,
-		status: typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599 ? status : 202
-	};
-}
-async function waitForDrain(options) {
-	if (options.baseline == null) return null;
-	const baselineRemaining = queueTaskRemaining(options.baseline) ?? 0;
-	const deadline = options.clock.now() + options.timeoutMs;
-	do {
-		throwIfAborted(options.signal);
-		const snapshot = await fetchServerSnapshot(options.target, options.fetch);
-		throwIfAborted(options.signal);
-		if (snapshot != null) {
-			const diff = diffSnapshots(options.baseline, snapshot);
-			const queueTasks = diff.queueTasks;
-			const remaining = queueTaskRemaining(diff, baselineRemaining);
-			if (queueTasks != null && queueTasks.enqueued > 0 && remaining != null && remaining === 0) return {
-				timedOut: false,
-				failed: queueTasks.failed
-			};
-		}
-		const now = options.clock.now();
-		if (now >= deadline) break;
-		await options.clock.sleepUntil(Math.min(deadline, now + DRAIN_POLL_MS), options.signal);
-	} while (options.clock.now() < deadline);
-	return {
-		timedOut: true,
-		failed: 0
-	};
-}
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw abortReason(signal);
-}
-function abortReason(signal) {
-	return signal.reason ?? /* @__PURE__ */ new Error("Operation aborted.");
-}
-function addQueueDrain(server, histogram) {
-	if (histogram.count < 1) return server;
-	const queue = {
-		...server?.queue ?? {},
-		drainMs: partialFromHistogram(histogram)
-	};
-	return {
-		...server ?? {},
-		queue
-	};
-}
-function partialFromHistogram(histogram) {
-	return {
-		p50: histogram.percentile(50),
-		p95: histogram.percentile(95),
-		p99: histogram.percentile(99)
-	};
-}
-//#endregion
-export { assertSinkRecipientsAllowed, fanoutRunner, resolveSinkBase, spawnSinkServer };