@fedify/fedify 2.3.0-dev.994 → 2.3.0-pr.809.37

package/dist/{middleware-K1g6bEkV.mjs → middleware-Cg4EyWsq.mjs}

@@ -1,32 +1,36 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as RouterError } from "./router-CrMLXoOr.mjs";
-import { n as version, t as name } from "./deno-XBVlKnOX.mjs";
+import { n as version, t as name } from "./deno-BID9qTPk.mjs";
+import { a as instrumentDocumentLoader, b as recordWebFingerHandle, c as recordCircuitBreakerStateChange, d as recordCollectionRequest, f as recordCollectionTotalItems, g as recordInboxActivity, h as recordFanoutRecipients, i as getRemoteHost, l as recordCollectionDispatchDuration, n as getDurationMs, o as isAbortError, r as getFederationMetrics, u as recordCollectionPageItems, v as recordOutboxActivity, x as registerQueueDepthGauge, y as recordOutboxEnqueue } from "./metrics-ColY3QKj.mjs";
 import { t as formatAcceptSignature } from "./accept-CPkZzmGN.mjs";
-import { a as importJwk, o as validateCryptoKey, t as exportJwk } from "./key-Bzx--sHD.mjs";
-import { l as verifyRequest, o as parseRfc9421SignatureInput, u as verifyRequestDetailed } from "./http-CSlLA54v.mjs";
-import { t as getAuthenticatedDocumentLoader } from "./docloader-DPp-X6gk.mjs";
-import { n as kvCache } from "./kv-cache-U__xU4qR.mjs";
-import { a as signJsonLd, i as hasSignatureLike, o as verifyJsonLd, r as detachSignature } from "./ld-DR78beiv.mjs";
-import { n as getKeyOwner, t as doesActorOwnKey } from "./owner-C-tqfvxn.mjs";
-import { r as normalizeOutgoingActivityJsonLd } from "./outgoing-jsonld-CNmZLixq.mjs";
-import { i as verifyObject, n as hasProofLike, r as signObject } from "./proof-BlmRPzrK.mjs";
-import { t as getNodeInfo } from "./client-D_1QpnWt.mjs";
+import { a as importJwk, o as validateCryptoKey, t as exportJwk } from "./key-Dqdlo3mG.mjs";
+import { l as verifyRequest, o as parseRfc9421SignatureInput, u as verifyRequestDetailed } from "./http-CO59u1Yk.mjs";
+import { t as getAuthenticatedDocumentLoader } from "./docloader-BYFuVwwi.mjs";
+import { n as kvCache } from "./kv-cache-DhLkLv0P.mjs";
+import { _ as wrapContextLoaderForJsonLd, a as compactJsonLd, c as getNormalizationContextLoader, d as isClearlyMalformedContextReference, f as isInvalidUrlTypeError, l as hasSignature, m as verifyCompactJsonLd, p as signJsonLd, r as assertSafeJsonLd, s as detachSignature, t as InvalidContextReferenceError, u as hasSignatureLike } from "./ld-JbCByP5P.mjs";
+import { n as getKeyOwner, t as doesActorOwnKey } from "./owner-B4LgOmzV.mjs";
+import { r as normalizeOutgoingActivityJsonLd } from "./outgoing-jsonld-L_DbOaFe.mjs";
+import { i as verifyObject, n as hasProofLike, r as signObject } from "./proof-BoSGOq9q.mjs";
+import { t as getNodeInfo } from "./client-ByXmQhYD.mjs";
 import { t as nodeInfoToJson } from "./types-J53Kw7so.mjs";
-import { t as FederationBuilderImpl } from "./builder-yAlpiIqP.mjs";
-import { t as buildCollectionSynchronizationHeader } from "./collection-D-HqUuA2.mjs";
-import { t as KvKeyCache } from "./keycache-EGATflN-.mjs";
-import { t as acceptsJsonLd } from "./negotiation-SQvQgUqe.mjs";
-import { t as createExponentialBackoffPolicy } from "./retry-bMXBL97A.mjs";
-import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "./send-05pJLcb6.mjs";
+import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "./send-ByK1Q7DK.mjs";
+import { n as FederationBuilderImpl, t as ACTOR_ALIAS_PREFIX } from "./builder-Dl5Sdmc9.mjs";
+import { t as CircuitBreaker } from "./circuit-breaker-CSWsyoef.mjs";
+import { t as buildCollectionSynchronizationHeader } from "./collection-Cc3DVAhE.mjs";
+import { t as KvKeyCache } from "./keycache-BeU0LCII.mjs";
+import { t as acceptsJsonLd } from "./negotiation-DDstyBvc.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "./temporal-LpjyAjKb.mjs";
+import { t as createExponentialBackoffPolicy } from "./retry-CXg_MBI-.mjs";
+import { getLogger, withContext } from "@logtape/logtape";
+import { RouterError } from "@fedify/uri-template";
 import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, Tombstone, getTypeId, lookupObject, traverseCollection } from "@fedify/vocab";
 import { lookupWebFinger } from "@fedify/webfinger";
-import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
-import { uniq } from "es-toolkit";
+import { SpanKind, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
 import { FetchError, getDocumentLoader } from "@fedify/vocab-runtime";
-import { getLogger, withContext } from "@logtape/logtape";
 import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_HEADER, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_URL_FULL } from "@opentelemetry/semantic-conventions";
+import { uniq } from "es-toolkit";
+import { DataPointType, MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
 import { domainToASCII } from "node:url";
 //#region src/compat/transformers.ts
 const logger$1 = getLogger([
@@ -153,8 +157,203 @@ function handleNodeInfoJrd(_request, context) {
 	return Promise.resolve(response);
 }
 //#endregion
+//#region src/federation/bench.ts
+/**
+* Metric reader owned by `benchmarkMode`.
+* @since 2.3.0
+*/
+var BenchmarkMetricReader = class extends MetricReader {
+	onShutdown() {
+		return Promise.resolve();
+	}
+	onForceFlush() {
+		return Promise.resolve();
+	}
+};
+/**
+* Creates the in-process OpenTelemetry meter provider used by benchmark mode.
+* @returns The meter provider and the metric reader attached to it.
+* @since 2.3.0
+*/
+function createBenchmarkMeterProvider() {
+	const reader = new BenchmarkMetricReader();
+	return {
+		meterProvider: new MeterProvider$1({ readers: [reader] }),
+		reader
+	};
+}
+/**
+* Collects and serializes benchmark-mode metrics from a benchmark reader.
+* @param reader The benchmark metric reader to collect from.
+* @returns A server metric snapshot with any collection errors stringified.
+* @since 2.3.0
+*/
+async function collectBenchmarkMetrics(reader) {
+	const result = await reader.collect();
+	return {
+		version: 1,
+		source: "server",
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		scopeMetrics: serializeScopeMetrics(result.resourceMetrics),
+		errors: result.errors.map((error) => String(error))
+	};
+}
+/**
+* Handles `GET /.well-known/fedify/bench/stats`.
+* @param request The HTTP request to handle.
+* @param reader The benchmark metric reader to collect from.
+* @returns A JSON metric snapshot response, or `405 Method Not Allowed`.
+* @since 2.3.0
+*/
+async function handleBenchmarkStats(request, reader) {
+	if (request.method !== "GET") return new Response("Method not allowed", {
+		status: 405,
+		headers: { "Allow": "GET" }
+	});
+	return jsonResponse(await collectBenchmarkMetrics(reader));
+}
+/**
+* Handles `POST /.well-known/fedify/bench/trigger`.
+*
+* The handler validates a benchmark trigger request, checks recipients against
+* server-controlled trigger options, and calls `Context.sendActivity()` to use
+* the target's normal outbox path.
+* @param request The HTTP request to handle.
+* @param context The Fedify context used to resolve actors and send activity.
+* @param options Server-controlled benchmark trigger delivery options.
+* @returns A JSON response describing the sent activity, or a validation error.
+* @since 2.3.0
+*/
+async function handleBenchmarkTrigger(request, context, options = {}) {
+	if (request.method !== "POST") return new Response("Method not allowed", {
+		status: 405,
+		headers: { "Allow": "POST" }
+	});
+	let json;
+	try {
+		json = await request.json();
+	} catch {
+		return jsonResponse({ error: "Invalid JSON request body." }, 400);
+	}
+	try {
+		const body = asRecord(json, "request body");
+		const sender = parseSender(body.sender);
+		const recipients = await parseRecipients(body.recipients, context);
+		const activity = await parseActivity(body.activity, context);
+		if (activity.id == null) throw new BenchmarkTriggerError("activity must have an id.");
+		const activityId = activity.id.href;
+		const inboxes = extractInboxes({ recipients });
+		const inboxUrls = Object.keys(inboxes);
+		if (inboxUrls.length < 1) throw new BenchmarkTriggerError("No valid recipient inboxes found. The recipients list must not be empty.");
+		const unsafeInboxes = options.allowUnsafeRecipients ? [] : inboxUrls.filter((inbox) => !options.sinks?.has(inbox));
+		if (unsafeInboxes.length > 0) return jsonResponse({
+			error: "unsafe_recipient",
+			unsafeInboxes
+		}, 403);
+		await context.sendActivity(sender, recipients, activity);
+		return jsonResponse({
+			version: 1,
+			activityId,
+			queueCorrelationId: activityId,
+			recipientCount: recipients.length,
+			inboxCount: inboxUrls.length
+		}, 202);
+	} catch (error) {
+		if (error instanceof BenchmarkTriggerError) return jsonResponse({ error: error.message }, error.status);
+		throw error;
+	}
+}
+var BenchmarkTriggerError = class extends Error {
+	status;
+	constructor(message, status = 400) {
+		super(message);
+		this.status = status;
+	}
+};
+function parseSender(value) {
+	const sender = asRecord(value, "sender");
+	if (typeof sender.identifier === "string") return { identifier: sender.identifier };
+	if (typeof sender.username === "string") return { username: sender.username };
+	throw new BenchmarkTriggerError("sender must be { identifier } or { username }.");
+}
+async function parseRecipients(value, context) {
+	if (!Array.isArray(value)) throw new BenchmarkTriggerError("recipients must be an array.");
+	return await Promise.all(value.map(async (item) => {
+		let object;
+		try {
+			object = await Object$1.fromJsonLd(item, {
+				documentLoader: context.documentLoader,
+				contextLoader: context.contextLoader
+			});
+		} catch (error) {
+			throw new BenchmarkTriggerError(`Invalid ActivityPub recipient: ${error}`);
+		}
+		if (!isRecipient(object)) throw new BenchmarkTriggerError("each recipient must be an ActivityPub actor.");
+		const recipient = object;
+		if (recipient.id == null || recipient.inboxId == null) throw new BenchmarkTriggerError("each recipient must have id and inbox properties.");
+		return recipient;
+	}));
+}
+function isRecipient(value) {
+	return value != null && typeof value === "object" && "id" in value && "inboxId" in value;
+}
+async function parseActivity(value, context) {
+	try {
+		return await Activity.fromJsonLd(value, {
+			documentLoader: context.documentLoader,
+			contextLoader: context.contextLoader
+		});
+	} catch (error) {
+		throw new BenchmarkTriggerError(`Invalid ActivityPub activity: ${error}`);
+	}
+}
+function asRecord(value, name) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) throw new BenchmarkTriggerError(`${name} must be an object.`);
+	return value;
+}
+function jsonResponse(body, status = 200) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+function serializeScopeMetrics(resourceMetrics) {
+	return resourceMetrics.scopeMetrics.map(serializeScope);
+}
+function serializeScope(scopeMetrics) {
+	return {
+		scope: {
+			name: scopeMetrics.scope.name,
+			version: scopeMetrics.scope.version
+		},
+		metrics: scopeMetrics.metrics.map(serializeMetric)
+	};
+}
+function serializeMetric(metric) {
+	return {
+		name: metric.descriptor.name,
+		description: metric.descriptor.description,
+		unit: metric.descriptor.unit,
+		dataPointType: serializeDataPointType(metric.dataPointType),
+		dataPoints: metric.dataPoints.map((point) => ({
+			attributes: { ...point.attributes },
+			startTime: point.startTime,
+			endTime: point.endTime,
+			value: point.value
+		}))
+	};
+}
+function serializeDataPointType(dataPointType) {
+	switch (dataPointType) {
+		case DataPointType.HISTOGRAM: return "histogram";
+		case DataPointType.EXPONENTIAL_HISTOGRAM: return "exponential_histogram";
+		case DataPointType.GAUGE: return "gauge";
+		case DataPointType.SUM: return "sum";
+	}
+}
+//#endregion
 //#region src/federation/inbox.ts
-async function routeActivity({ context: ctx, json, activity, recipient, inboxListeners, inboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, tracerProvider, idempotencyStrategy }) {
+async function routeActivity({ context: ctx, json, originalJson, normalizedActivity, ldSignatureVerified, activity, recipient, inboxListeners, inboxContextFactory, listenerInboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, meterProvider, tracerProvider, idempotencyStrategy }) {
 	const logger = getLogger([
 		"fedify",
 		"federation",
@@ -191,6 +390,7 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 				code: SpanStatusCode.UNSET,
 				message: `Activity ${activity.id?.href} has already been processed.`
 			});
+			recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
 			return "alreadyProcessed";
 		}
 	}
@@ -200,6 +400,7 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 			code: SpanStatusCode.ERROR,
 			message: "Missing actor."
 		});
+		recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
 		return "missingActor";
 	}
 	span.setAttribute("activitypub.actor.id", activity.actorId.href);
@@ -211,7 +412,9 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 				type: "inbox",
 				id: crypto.randomUUID(),
 				baseUrl: ctx.origin,
-				activity: json,
+				activity: originalJson ?? json,
+				...normalizedActivity == null ? {} : { normalizedActivity },
+				...ldSignatureVerified == null ? {} : { ldSignatureVerified },
 				identifier: recipient,
 				attempt: 0,
 				started: (/* @__PURE__ */ new Date()).toISOString(),
@@ -230,6 +433,12 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 			});
 			throw error;
 		}
+		getFederationMetrics(meterProvider).recordQueueTaskEnqueued({
+			role: "inbox",
+			queue,
+			activityType: getTypeId(activity).href
+		}, 0);
+		recordInboxActivity(meterProvider, "queued", getTypeId(activity).href);
 		logger.info("Activity {activityId} is enqueued.", {
 			activityId: activity.id?.href,
 			activity: json,
@@ -249,13 +458,21 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 				code: SpanStatusCode.UNSET,
 				message: `Unsupported activity type: ${getTypeId(activity).href}`
 			});
+			recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
 			span.end();
 			return "unsupportedActivity";
 		}
 		const { class: cls, listener } = dispatched;
 		span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
 		try {
-			await listener(inboxContextFactory(recipient, json, activity?.id?.href, getTypeId(activity).href), activity);
+			const activityType = getTypeId(activity).href;
+			const started = performance.now();
+			try {
+				const contextFactory = listenerInboxContextFactory ?? inboxContextFactory;
+				await listener(contextFactory(recipient, contextFactory === inboxContextFactory ? json : originalJson ?? json, activity.id?.href, activityType), activity);
+			} finally {
+				getFederationMetrics(meterProvider).recordInboxProcessingDuration(activityType, getDurationMs(started));
+			}
 		} catch (error) {
 			try {
 				await inboxErrorHandler?.(ctx, error);
@@ -277,9 +494,11 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 				code: SpanStatusCode.ERROR,
 				message: String(error)
 			});
+			recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
 			span.end();
 			return "error";
 		}
+		recordInboxActivity(meterProvider, "processed", getTypeId(activity).href);
 		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal.Duration.from({ days: 1 }) });
 		logger.info("Activity {activityId} has been processed.", {
 			activityId: activity.id?.href,
@@ -292,6 +511,33 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 }
 //#endregion
 //#region src/federation/handler.ts
+const rawInboxContextFactorySymbol = Symbol("fedify.rawInboxContextFactory");
+function isRemoteContextLoadingFailure$1(error) {
+	return error instanceof Error && typeof error.details === "object" && error.details != null && error.details.code === "loading remote context failed";
+}
+function isPermanentRemoteContextError$1(error) {
+	if (!(error instanceof Error) || error.name !== "jsonld.InvalidUrl") return false;
+	const details = error.details;
+	if (details?.code === "invalid remote context") return true;
+	return isRemoteContextLoadingFailure$1(error) && typeof details?.url === "string" && !URL.canParse(details.url) && isClearlyMalformedContextReference(details.url);
+}
+function isInvalidJsonLdError(error) {
+	if (!(error instanceof Error)) return false;
+	const name = error.name;
+	return name === "UnsafeJsonLdError" || error instanceof InvalidContextReferenceError || isPermanentRemoteContextError$1(error) || name === "jsonld.SyntaxError" && !isRemoteContextLoadingFailure$1(error);
+}
+function isValidationTypeError(error) {
+	return error instanceof TypeError && (/^(Invalid JSON-LD:|Invalid type:|Unexpected type:|Invalid @id:)/.test(error.message) || isInvalidUrlTypeError(error));
+}
+function isPermanentActivityParseError(error) {
+	return isInvalidJsonLdError(error) || isValidationTypeError(error);
+}
+function hasHttpSignatureHeaders(request) {
+	return request.headers.has("Signature") || request.headers.has("Signature-Input");
+}
+function hasObjectIntegrityProof(json) {
+	return typeof json === "object" && json != null && "proof" in json;
+}
 /**
 * Handles an actor request.
 * @template TContextData The context data to pass to the context.
@@ -353,6 +599,33 @@ async function handleObject(request, { values, context, objectDispatcher, author
 		Vary: "Accept"
 	} });
 }
+const BUILT_IN_COLLECTION_METRIC_KINDS = new Set([
+	"inbox",
+	"outbox",
+	"following",
+	"followers",
+	"liked",
+	"featured",
+	"featured_tags"
+]);
+function getCollectionMetricKind(name) {
+	const normalized = name.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/\s+/g, "_");
+	return BUILT_IN_COLLECTION_METRIC_KINDS.has(normalized) ? normalized : "custom";
+}
+function collectionAttributes(base, result, response) {
+	return {
+		...base,
+		result,
+		...response == null ? {} : { statusCode: response.status }
+	};
+}
+function recordCollectionMetrics(meterProvider, base, result, options = {}) {
+	const attrs = collectionAttributes(base, result, options.response);
+	recordCollectionRequest(meterProvider, attrs);
+	if (options.dispatchDurationMs != null) recordCollectionDispatchDuration(meterProvider, options.dispatchDurationMs, attrs);
+	if (options.itemCount != null) recordCollectionPageItems(meterProvider, options.itemCount, attrs);
+	if (options.totalItems != null) recordCollectionTotalItems(meterProvider, options.totalItems, attrs);
+}
 /**
 * Handles a collection request.
 * @template TItem The type of items in the collection.
@@ -363,36 +636,118 @@ async function handleObject(request, { values, context, objectDispatcher, author
 * @param parameters The parameters for handling the collection.
 * @returns A promise that resolves to an HTTP response.
 */
-async function handleCollection(request, { name: name$1, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, tracerProvider, onUnauthorized, onNotFound }) {
+async function handleCollection(request, { name: name$1, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, tracerProvider, meterProvider, onUnauthorized, onNotFound }) {
 	const spanName = name$1.trim().replace(/\s+/g, "_");
 	tracerProvider = tracerProvider ?? trace.getTracerProvider();
 	const tracer = tracerProvider.getTracer(name, version);
 	const cursor = new URL(request.url).searchParams.get("cursor");
-	if (collectionCallbacks == null) return await onNotFound(request);
-	let collection;
-	const baseUri = uriGetter(identifier);
-	if (cursor == null) {
-		const firstCursor = await collectionCallbacks.firstCursor?.(context, identifier);
-		const totalItems = filter == null ? await collectionCallbacks.counter?.(context, identifier) : void 0;
-		if (firstCursor == null) {
-			const itemsOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection ${spanName}`, {
+	const metricBase = {
+		kind: getCollectionMetricKind(name$1),
+		page: cursor != null,
+		dispatcher: "built_in"
+	};
+	let dispatchDurationMs;
+	let itemCount;
+	let totalItemCount;
+	const finish = (response, result) => {
+		recordCollectionMetrics(meterProvider, metricBase, result, {
+			response,
+			dispatchDurationMs,
+			itemCount,
+			totalItems: totalItemCount
+		});
+		return response;
+	};
+	try {
+		if (collectionCallbacks == null) return finish(await onNotFound(request), "not_found");
+		let collection;
+		const baseUri = uriGetter(identifier);
+		if (cursor == null) {
+			const firstCursor = await collectionCallbacks.firstCursor?.(context, identifier);
+			const totalItems = filter == null ? await collectionCallbacks.counter?.(context, identifier) : void 0;
+			totalItemCount = totalItems == null ? void 0 : Number(totalItems);
+			if (firstCursor == null) {
+				const itemsOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection ${spanName}`, {
+					kind: SpanKind.SERVER,
+					attributes: {
+						"activitypub.collection.id": baseUri.href,
+						"activitypub.collection.type": OrderedCollection.typeId.href
+					}
+				}, async (span) => {
+					if (totalItemCount != null) span.setAttribute("activitypub.collection.total_items", totalItemCount);
+					const started = performance.now();
+					try {
+						const page = await collectionCallbacks.dispatcher(context, identifier, null, filter);
+						dispatchDurationMs = getDurationMs(started);
+						if (page == null) {
+							span.setStatus({ code: SpanStatusCode.ERROR });
+							return await onNotFound(request);
+						}
+						const items = filterCollectionItems(page.items, name$1, filterPredicate);
+						itemCount = items.length;
+						span.setAttribute("fedify.collection.items", itemCount);
+						return items;
+					} catch (e) {
+						if (dispatchDurationMs == null) dispatchDurationMs = getDurationMs(started);
+						span.setStatus({
+							code: SpanStatusCode.ERROR,
+							message: String(e)
+						});
+						throw e;
+					} finally {
+						span.end();
+					}
+				});
+				if (itemsOrResponse instanceof Response) return finish(itemsOrResponse, "not_found");
+				collection = new OrderedCollection({
+					id: baseUri,
+					totalItems: totalItemCount ?? null,
+					items: itemsOrResponse
+				});
+			} else {
+				const lastCursor = await collectionCallbacks.lastCursor?.(context, identifier);
+				const first = new URL(context.url);
+				first.searchParams.set("cursor", firstCursor);
+				let last = null;
+				if (lastCursor != null) {
+					last = new URL(context.url);
+					last.searchParams.set("cursor", lastCursor);
+				}
+				collection = new OrderedCollection({
+					id: baseUri,
+					totalItems: totalItemCount ?? null,
+					first,
+					last
+				});
+			}
+		} else {
+			const uri = new URL(baseUri);
+			uri.searchParams.set("cursor", cursor);
+			const pageOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection_page ${name$1}`, {
 				kind: SpanKind.SERVER,
 				attributes: {
-					"activitypub.collection.id": baseUri.href,
-					"activitypub.collection.type": OrderedCollection.typeId.href
+					"activitypub.collection.id": uri.href,
+					"activitypub.collection.type": OrderedCollectionPage.typeId.href,
+					"fedify.collection.cursor": cursor
 				}
 			}, async (span) => {
-				if (totalItems != null) span.setAttribute("activitypub.collection.total_items", Number(totalItems));
+				const started = performance.now();
 				try {
-					const page = await collectionCallbacks.dispatcher(context, identifier, null, filter);
+					const page = await collectionCallbacks.dispatcher(context, identifier, cursor, filter);
+					dispatchDurationMs = getDurationMs(started);
 					if (page == null) {
 						span.setStatus({ code: SpanStatusCode.ERROR });
 						return await onNotFound(request);
 					}
-					const { items } = page;
-					span.setAttribute("fedify.collection.items", items.length);
-					return items;
+					const items = filterCollectionItems(page.items, name$1, filterPredicate);
+					itemCount = items.length;
+					span.setAttribute("fedify.collection.items", itemCount);
+					return {
+						...page,
+						items
+					};
 				} catch (e) {
+					if (dispatchDurationMs == null) dispatchDurationMs = getDurationMs(started);
 					span.setStatus({
 						code: SpanStatusCode.ERROR,
 						message: String(e)
@@ -402,87 +757,44 @@ async function handleCollection(request, { name: name$1, identifier, uriGetter,
 					span.end();
 				}
 			});
-			if (itemsOrResponse instanceof Response) return itemsOrResponse;
-			collection = new OrderedCollection({
-				id: baseUri,
-				totalItems: totalItems == null ? null : Number(totalItems),
-				items: filterCollectionItems(itemsOrResponse, name$1, filterPredicate)
-			});
-		} else {
-			const lastCursor = await collectionCallbacks.lastCursor?.(context, identifier);
-			const first = new URL(context.url);
-			first.searchParams.set("cursor", firstCursor);
-			let last = null;
-			if (lastCursor != null) {
-				last = new URL(context.url);
-				last.searchParams.set("cursor", lastCursor);
+			if (pageOrResponse instanceof Response) return finish(pageOrResponse, "not_found");
+			const { items, prevCursor, nextCursor } = pageOrResponse;
+			let prev = null;
+			if (prevCursor != null) {
+				prev = new URL(context.url);
+				prev.searchParams.set("cursor", prevCursor);
 			}
-			collection = new OrderedCollection({
-				id: baseUri,
-				totalItems: totalItems == null ? null : Number(totalItems),
-				first,
-				last
-			});
-		}
-	} else {
-		const uri = new URL(baseUri);
-		uri.searchParams.set("cursor", cursor);
-		const pageOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection_page ${name$1}`, {
-			kind: SpanKind.SERVER,
-			attributes: {
-				"activitypub.collection.id": uri.href,
-				"activitypub.collection.type": OrderedCollectionPage.typeId.href,
-				"fedify.collection.cursor": cursor
+			let next = null;
+			if (nextCursor != null) {
+				next = new URL(context.url);
+				next.searchParams.set("cursor", nextCursor);
 			}
-		}, async (span) => {
-			try {
-				const page = await collectionCallbacks.dispatcher(context, identifier, cursor, filter);
-				if (page == null) {
-					span.setStatus({ code: SpanStatusCode.ERROR });
-					return await onNotFound(request);
-				}
-				span.setAttribute("fedify.collection.items", page.items.length);
-				return page;
-			} catch (e) {
-				span.setStatus({
-					code: SpanStatusCode.ERROR,
-					message: String(e)
-				});
-				throw e;
-			} finally {
-				span.end();
-			}
-		});
-		if (pageOrResponse instanceof Response) return pageOrResponse;
-		const { items, prevCursor, nextCursor } = pageOrResponse;
-		let prev = null;
-		if (prevCursor != null) {
-			prev = new URL(context.url);
-			prev.searchParams.set("cursor", prevCursor);
+			const partOf = new URL(context.url);
+			partOf.searchParams.delete("cursor");
+			collection = new OrderedCollectionPage({
+				id: uri,
+				prev,
+				next,
+				items,
+				partOf
+			});
 		}
-		let next = null;
-		if (nextCursor != null) {
-			next = new URL(context.url);
-			next.searchParams.set("cursor", nextCursor);
+		if (collectionCallbacks.authorizePredicate != null) {
+			if (!await collectionCallbacks.authorizePredicate(context, identifier)) return finish(await onUnauthorized(request), "unauthorized");
 		}
-		const partOf = new URL(context.url);
-		partOf.searchParams.delete("cursor");
-		collection = new OrderedCollectionPage({
-			id: uri,
-			prev,
-			next,
-			items: filterCollectionItems(items, name$1, filterPredicate),
-			partOf
+		const jsonLd = await collection.toJsonLd(context);
+		return finish(new Response(JSON.stringify(jsonLd), { headers: {
+			"Content-Type": "application/activity+json",
+			Vary: "Accept"
+		} }), "served");
+	} catch (e) {
+		recordCollectionMetrics(meterProvider, metricBase, "error", {
+			dispatchDurationMs,
+			itemCount,
+			totalItems: totalItemCount
 		});
+		throw e;
 	}
-	if (collectionCallbacks.authorizePredicate != null) {
-		if (!await collectionCallbacks.authorizePredicate(context, identifier)) return await onUnauthorized(request);
-	}
-	const jsonLd = await collection.toJsonLd(context);
-	return new Response(JSON.stringify(jsonLd), { headers: {
-		"Content-Type": "application/activity+json",
-		Vary: "Accept"
-	} });
 }
 /**
 * Filters collection items based on the provided predicate.
@@ -746,7 +1058,7 @@ async function handleInbox(request, options) {
 * @returns A promise that resolves to an HTTP response.
 */
 async function handleInboxInternal(request, parameters, span) {
-	const { recipient, context: ctx, inboxContextFactory, kv, kvPrefixes, queue, actorDispatcher, inboxListeners, inboxErrorHandler, unverifiedActivityHandler, onNotFound, signatureTimeWindow, skipSignatureVerification, inboxChallengePolicy, tracerProvider } = parameters;
+	const { recipient, context: ctx, inboxContextFactory, kv, kvPrefixes, queue, actorDispatcher, inboxListeners, inboxErrorHandler, unverifiedActivityHandler, onNotFound, signatureTimeWindow, skipSignatureVerification, inboxChallengePolicy, meterProvider, tracerProvider } = parameters;
 	const logger = getLogger([
 		"fedify",
 		"federation",
@@ -818,28 +1130,105 @@ async function handleInboxInternal(request, parameters, span) {
 		});
 	}
 	const keyCache = new KvKeyCache(kv, kvPrefixes.publicKey, ctx);
-	let ldSigVerified;
-	try {
-		ldSigVerified = await verifyJsonLd(json, {
-			contextLoader: ctx.contextLoader,
-			documentLoader: ctx.documentLoader,
-			keyCache,
-			tracerProvider
+	const jsonWithoutSig = detachSignature(json);
+	const hasLdSignature = hasSignature(json);
+	const canAttemptAlternateAuthAfterLdSignatureFailure = skipSignatureVerification || hasHttpSignatureHeaders(request) || hasObjectIntegrityProof(jsonWithoutSig);
+	let deferredLdSignatureError = void 0;
+	const respondInvalidActivity = async (error) => {
+		logger.error("Failed to parse activity:\n{error}", {
+			recipient,
+			activity: json,
+			error
 		});
-	} catch (error) {
-		if (error instanceof Error && error.name === "jsonld.SyntaxError") {
-			logger.error("Failed to parse JSON-LD:\n{error}", {
+		try {
+			await inboxErrorHandler?.(ctx, error);
+		} catch (error) {
+			logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
+				error,
+				activity: json,
+				recipient
+			});
+		}
+		span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: `Failed to parse activity:\n${error}`
+		});
+		return new Response("Invalid activity.", {
+			status: 400,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
+	};
+	let compactedJson = json;
+	let compactedJsonWithoutSig = jsonWithoutSig;
+	let ldSigVerified = false;
+	if (hasLdSignature) {
+		try {
+			compactedJson = await compactJsonLd(json, ctx.contextLoader);
+		} catch (error) {
+			if (isInvalidJsonLdError(error)) {
+				logger.error("Failed to parse JSON-LD:\n{error}", {
+					recipient,
+					error
+				});
+				return new Response("Invalid JSON-LD.", {
+					status: 400,
+					headers: { "Content-Type": "text/plain; charset=utf-8" }
+				});
+			}
+			if (!canAttemptAlternateAuthAfterLdSignatureFailure) throw error;
+			if (!skipSignatureVerification) deferredLdSignatureError = error;
+			logger.debug("Failed to normalize JSON-LD for Linked Data Signatures; deferring to another authentication path only if it verifies:\n{error}", {
 				recipient,
 				error
 			});
-			return new Response("Invalid JSON-LD.", {
-				status: 400,
-				headers: { "Content-Type": "text/plain; charset=utf-8" }
-			});
 		}
-		ldSigVerified = false;
+		if (compactedJson !== json) {
+			compactedJsonWithoutSig = detachSignature(compactedJson);
+			try {
+				ldSigVerified = await verifyCompactJsonLd(compactedJson, {
+					contextLoader: ctx.contextLoader,
+					documentLoader: ctx.documentLoader,
+					keyCache,
+					meterProvider,
+					tracerProvider
+				});
+			} catch (error) {
+				if (error instanceof RangeError && await hasMalformedKnownTemporalLiteral(compactedJsonWithoutSig, ctx.contextLoader)) return await respondInvalidActivity(error);
+				if (isInvalidJsonLdError(error)) {
+					logger.error("Failed to parse JSON-LD:\n{error}", {
+						recipient,
+						error
+					});
+					return new Response("Invalid JSON-LD.", {
+						status: 400,
+						headers: { "Content-Type": "text/plain; charset=utf-8" }
+					});
+				}
+				if (!canAttemptAlternateAuthAfterLdSignatureFailure) throw error;
+				if (!skipSignatureVerification) try {
+					await Object$1.fromJsonLd(compactedJson, {
+						contextLoader: getNormalizationContextLoader(ctx.contextLoader),
+						documentLoader: ctx.documentLoader,
+						tracerProvider
+					});
+				} catch (parseError) {
+					if (parseError instanceof RangeError && await hasMalformedKnownTemporalLiteral(compactedJsonWithoutSig, ctx.contextLoader)) return await respondInvalidActivity(parseError);
+					if (isInvalidJsonLdError(parseError)) {
+						logger.error("Failed to parse JSON-LD:\n{error}", {
+							recipient,
+							error: parseError
+						});
+						return new Response("Invalid JSON-LD.", {
+							status: 400,
+							headers: { "Content-Type": "text/plain; charset=utf-8" }
+						});
+					}
+					deferredLdSignatureError = parseError;
+				}
+				ldSigVerified = false;
+			}
+		}
 	}
-	const jsonWithoutSig = detachSignature(json);
 	let activity = null;
 	let activityVerified = false;
 	if (ldSigVerified) {
@@ -847,7 +1236,16 @@ async function handleInboxInternal(request, parameters, span) {
 			recipient,
 			json
 		});
-		activity = await Activity.fromJsonLd(jsonWithoutSig, ctx);
+		try {
+			activity = await Activity.fromJsonLd(compactedJsonWithoutSig, {
+				...ctx,
+				contextLoader: getNormalizationContextLoader(ctx.contextLoader)
+			});
+		} catch (error) {
+			if (error instanceof RangeError && await hasMalformedKnownTemporalLiteral(compactedJsonWithoutSig, ctx.contextLoader)) return await respondInvalidActivity(error);
+			if (!isPermanentActivityParseError(error)) throw error;
+			return await respondInvalidActivity(error);
+		}
 		activityVerified = true;
 	} else {
 		logger.debug("Linked Data Signatures are not verified.", {
@@ -856,12 +1254,22 @@ async function handleInboxInternal(request, parameters, span) {
 		});
 		try {
 			activity = await verifyObject(Activity, jsonWithoutSig, {
-				contextLoader: ctx.contextLoader,
+				contextLoader: wrapContextLoaderForJsonLd(ctx.contextLoader),
 				documentLoader: ctx.documentLoader,
 				keyCache,
+				meterProvider,
 				tracerProvider
 			});
 		} catch (error) {
+			if (error instanceof RangeError && await hasMalformedKnownTemporalLiteral(jsonWithoutSig, ctx.contextLoader)) return await respondInvalidActivity(error);
+			if (deferredLdSignatureError != null) {
+				logger.debug("Object Integrity Proof fallback did not supersede a deferred Linked Data Signature failure:\n{error}", {
+					recipient,
+					error
+				});
+				activity = null;
+			}
+			if (!isPermanentActivityParseError(error)) throw error;
 			logger.error("Failed to parse activity:\n{error}", {
 				recipient,
 				activity: json,
@@ -906,10 +1314,14 @@ async function handleInboxInternal(request, parameters, span) {
 				documentLoader: ctx.documentLoader,
 				timeWindow: signatureTimeWindow,
 				keyCache,
+				meterProvider,
 				tracerProvider
 			});
 			if (verification.verified === false) {
+				if (deferredLdSignatureError != null) throw deferredLdSignatureError;
 				const reason = verification.reason;
+				const remoteHost = "keyId" in reason && reason.keyId != null ? getRemoteHost(reason.keyId) : void 0;
+				getFederationMetrics(parameters.meterProvider).recordSignatureVerificationFailure(reason.type, remoteHost);
 				logger.error("Failed to verify the request's HTTP Signatures.", {
 					recipient,
 					reason: reason.type,
@@ -984,7 +1396,15 @@ async function handleInboxInternal(request, parameters, span) {
 			}
 			httpSigKey = verification.key;
 		}
-		activity = await Activity.fromJsonLd(jsonWithoutSig, ctx);
+		try {
+			activity = await Activity.fromJsonLd(jsonWithoutSig, {
+				...ctx,
+				contextLoader: wrapContextLoaderForJsonLd(ctx.contextLoader)
+			});
+		} catch (error) {
+			if (!isPermanentActivityParseError(error)) throw error;
+			return await respondInvalidActivity(error);
+		}
 	}
 	if (activity.id != null) span.setAttribute("activitypub.activity.id", activity.id.href);
 	span.setAttribute("activitypub.activity.type", getTypeId(activity).href);
@@ -996,6 +1416,8 @@ async function handleInboxInternal(request, parameters, span) {
 		"http_signatures.key_id": httpSigKey?.id?.href ?? ""
 	});
 	if (httpSigKey != null && !await doesActorOwnKey(activity, httpSigKey, ctx)) {
+		if (deferredLdSignatureError != null) throw deferredLdSignatureError;
+		getFederationMetrics(parameters.meterProvider).recordSignatureVerificationFailure("actorKeyMismatch", httpSigKey.id == null ? void 0 : getRemoteHost(httpSigKey.id));
 		logger.error("The signer ({keyId}) and the actor ({actorId}) do not match.", {
 			activity: json,
 			recipient,
@@ -1013,6 +1435,7 @@ async function handleInboxInternal(request, parameters, span) {
 	}
 	if (pendingNonceLabel != null) {
 		if (!await verifySignatureNonce(request, kv, kvPrefixes.acceptSignatureNonce, pendingNonceLabel)) {
+			getFederationMetrics(parameters.meterProvider).recordSignatureVerificationFailure("invalidNonce", httpSigKey?.id == null ? void 0 : getRemoteHost(httpSigKey.id));
 			logger.error("Signature nonce verification failed (missing, expired, or replayed).", { recipient });
 			return await getFailedSignatureResponse(inboxChallengePolicy, kv, kvPrefixes);
 		}
@@ -1020,15 +1443,20 @@ async function handleInboxInternal(request, parameters, span) {
 	const routeResult = await routeActivity({
 		context: ctx,
 		json,
+		originalJson: json,
+		normalizedActivity: hasLdSignature && compactedJson !== json ? compactedJson : void 0,
+		ldSignatureVerified: hasLdSignature ? ldSigVerified : void 0,
 		activity,
 		recipient,
 		inboxListeners,
 		inboxContextFactory,
+		listenerInboxContextFactory: ldSigVerified ? inboxContextFactory[rawInboxContextFactorySymbol] : void 0,
 		inboxErrorHandler,
 		kv,
 		kvPrefixes,
 		queue,
 		span,
+		meterProvider: parameters.meterProvider,
 		tracerProvider,
 		idempotencyStrategy: parameters.idempotencyStrategy
 	});
@@ -1069,11 +1497,31 @@ async function handleInboxInternal(request, parameters, span) {
 * @since 1.8.0
 */
 const handleCustomCollection = exceptWrapper(_handleCustomCollection);
-async function _handleCustomCollection(request, { name, values, context, tracerProvider, collectionCallbacks: callbacks, filterPredicate }) {
+const pendingCollectionMetricRecorders = /* @__PURE__ */ new WeakMap();
+function deferPendingCollectionMetrics(error, recorder) {
+	if (error == null || typeof error !== "object" && typeof error !== "function") return false;
+	pendingCollectionMetricRecorders.set(error, recorder);
+	return true;
+}
+function recordDeferredPendingCollectionMetrics(error, result, response) {
+	if (error == null || typeof error !== "object" && typeof error !== "function") return;
+	const recorder = pendingCollectionMetricRecorders.get(error);
+	pendingCollectionMetricRecorders.delete(error);
+	recorder?.(result, response);
+}
+async function _handleCustomCollection(request, { name, values, context, tracerProvider, meterProvider, collectionCallbacks: callbacks, filterPredicate }) {
 	verifyDefined(callbacks);
 	await authIfNeeded(context, values, callbacks);
 	const cursor = new URL(request.url).searchParams.get("cursor");
-	return await new CustomCollectionHandler(name, values, context, callbacks, tracerProvider, Collection, CollectionPage, filterPredicate).fetchCollection(cursor).toJsonLd().then(respondAsActivity);
+	const handler = new CustomCollectionHandler(name, values, context, callbacks, tracerProvider, meterProvider, Collection, CollectionPage, filterPredicate).fetchCollection(cursor);
+	try {
+		const response = await handler.toJsonLd().then(respondAsActivity);
+		handler.recordPendingCollectionMetrics("served", response);
+		return response;
+	} catch (e) {
+		if (!deferPendingCollectionMetrics(e, (result, response) => handler.recordPendingCollectionMetrics(result, response))) handler.recordPendingCollectionMetrics("error");
+		throw e;
+	}
 }
 /**
 * Handles an ordered collection request.
@@ -1087,11 +1535,19 @@ async function _handleCustomCollection(request, { name, values, context, tracerP
 * @since 1.8.0
 */
 const handleOrderedCollection = exceptWrapper(_handleOrderedCollection);
-async function _handleOrderedCollection(request, { name, values, context, tracerProvider, collectionCallbacks: callbacks, filterPredicate }) {
+async function _handleOrderedCollection(request, { name, values, context, tracerProvider, meterProvider, collectionCallbacks: callbacks, filterPredicate }) {
 	verifyDefined(callbacks);
 	await authIfNeeded(context, values, callbacks);
 	const cursor = new URL(request.url).searchParams.get("cursor");
-	return await new CustomCollectionHandler(name, values, context, callbacks, tracerProvider, OrderedCollection, OrderedCollectionPage, filterPredicate).fetchCollection(cursor).toJsonLd().then(respondAsActivity);
+	const handler = new CustomCollectionHandler(name, values, context, callbacks, tracerProvider, meterProvider, OrderedCollection, OrderedCollectionPage, filterPredicate).fetchCollection(cursor);
+	try {
+		const response = await handler.toJsonLd().then(respondAsActivity);
+		handler.recordPendingCollectionMetrics("served", response);
+		return response;
+	} catch (e) {
+		if (!deferPendingCollectionMetrics(e, (result, response) => handler.recordPendingCollectionMetrics(result, response))) handler.recordPendingCollectionMetrics("error");
+		throw e;
+	}
 }
 /**
 * Handling custom collections with support for pagination and filtering.
@@ -1106,6 +1562,15 @@ async function _handleOrderedCollection(request, { name, values, context, tracer
 * @since 1.8.0
 */
 var CustomCollectionHandler = class {
+	name;
+	values;
+	context;
+	callbacks;
+	tracerProvider;
+	meterProvider;
+	Collection;
+	CollectionPage;
+	filterPredicate;
 	/**
 	* The tracer for telemetry.
 	* @type {Tracer}
@@ -1130,6 +1595,7 @@ var CustomCollectionHandler = class {
 	*/
 	#dispatcher;
 	#collection = null;
+	#pendingCollectionMetrics = [];
 	/**
 	* Creates a new CustomCollection instance.
 	* @param name The name of the collection.
@@ -1141,12 +1607,13 @@ var CustomCollectionHandler = class {
 	* @param CollectionPage The CollectionPage constructor.
 	* @param filterPredicate Optional filter predicate for items.
 	*/
-	constructor(name$2, values, context, callbacks, tracerProvider = trace.getTracerProvider(), Collection, CollectionPage, filterPredicate) {
+	constructor(name$2, values, context, callbacks, tracerProvider = trace.getTracerProvider(), meterProvider, Collection, CollectionPage, filterPredicate) {
 		this.name = name$2;
 		this.values = values;
 		this.context = context;
 		this.callbacks = callbacks;
 		this.tracerProvider = tracerProvider;
+		this.meterProvider = meterProvider;
 		this.Collection = Collection;
 		this.CollectionPage = CollectionPage;
 		this.filterPredicate = filterPredicate;
@@ -1199,10 +1666,12 @@ var CustomCollectionHandler = class {
 		const { prevCursor, nextCursor } = pages;
 		const partOf = new URL(id);
 		partOf.searchParams.delete("cursor");
+		const items = this.filterItems(pages.items);
+		this.recordPendingCollectionItemCount(true, items.length);
 		return {
 			id,
 			partOf,
-			items: this.filterItems(pages.items),
+			items,
 			prev: this.appendToUrl(prevCursor),
 			next: this.appendToUrl(nextCursor)
 		};
@@ -1215,11 +1684,16 @@ var CustomCollectionHandler = class {
 	*/
 	async getProps(firstCursor) {
 		const lastCursor = await this.callbacks.lastCursor?.(this.context, this.values);
+		const totalItems = await this.totalItems;
+		if (totalItems != null) this.#pendingCollectionMetrics.push({
+			page: false,
+			totalItems: Number(totalItems)
+		});
 		return {
 			id: this.#id,
 			first: this.appendToUrl(firstCursor),
 			last: this.appendToUrl(lastCursor),
-			totalItems: await this.totalItems
+			totalItems
 		};
 	}
 	/**
@@ -1229,10 +1703,12 @@ var CustomCollectionHandler = class {
 	async getPropsWithoutCursor() {
 		const totalItems = await this.totalItems;
 		const pages = await this.getPages({ totalItems });
+		const items = this.filterItems(pages.items);
+		this.recordPendingCollectionItemCount(false, items.length);
 		return {
 			id: this.#id,
 			totalItems,
-			items: this.filterItems(pages.items)
+			items
 		};
 	}
 	/**
@@ -1267,12 +1743,24 @@ var CustomCollectionHandler = class {
 	* @returns A function that handles the span operation.
 	*/
 	spanPages = ({ totalItems = null, cursor = null }) => async (span) => {
+		const pageMetricBase = this.metricBase(cursor !== null);
+		const started = performance.now();
 		try {
 			if (totalItems !== null) span.setAttribute(this.ATTRS.TOTAL_ITEMS, totalItems);
 			const page = await this.dispatch(cursor);
+			const durationMs = getDurationMs(started);
 			span.setAttribute(this.ATTRS.ITEMS, page.items.length);
+			this.#pendingCollectionMetrics.push({
+				page: pageMetricBase.page,
+				dispatchDurationMs: durationMs,
+				totalItems: totalItems == null ? void 0 : Number(totalItems)
+			});
 			return page;
 		} catch (e) {
+			this.#pendingCollectionMetrics.push({
+				page: cursor !== null,
+				dispatchDurationMs: getDurationMs(started)
+			});
 			const message = e instanceof Error ? e.message : String(e);
 			span.setStatus({
 				code: SpanStatusCode.ERROR,
@@ -1299,6 +1787,37 @@ var CustomCollectionHandler = class {
 	filterItems(items) {
 		return filterCollectionItems(items, this.name, this.filterPredicate);
 	}
+	metricBase(page) {
+		return {
+			kind: "custom",
+			page,
+			dispatcher: "custom"
+		};
+	}
+	metricAttributes(page, result, response) {
+		return collectionAttributes(this.metricBase(page), result, response);
+	}
+	recordPendingCollectionItemCount(page, itemCount) {
+		for (let i = this.#pendingCollectionMetrics.length - 1; i >= 0; i--) {
+			const measurement = this.#pendingCollectionMetrics[i];
+			if (measurement.page === page && measurement.dispatchDurationMs != null && measurement.itemCount == null) {
+				measurement.itemCount = itemCount;
+				return;
+			}
+		}
+		this.#pendingCollectionMetrics.push({
+			page,
+			itemCount
+		});
+	}
+	recordPendingCollectionMetrics(result, response) {
+		for (const measurement of this.#pendingCollectionMetrics.splice(0)) {
+			const attrs = this.metricAttributes(measurement.page, result, response);
+			if (measurement.dispatchDurationMs != null) recordCollectionDispatchDuration(this.meterProvider, measurement.dispatchDurationMs, attrs);
+			if (measurement.itemCount != null) recordCollectionPageItems(this.meterProvider, measurement.itemCount, attrs);
+			if (measurement.totalItems != null) recordCollectionTotalItems(this.meterProvider, measurement.totalItems, attrs);
+		}
+	}
 	/**
 	* Appends a cursor to the URL if it exists.
 	* @param cursor The cursor to append, or null/undefined.
@@ -1362,14 +1881,36 @@ var CustomCollectionHandler = class {
 */
 function exceptWrapper(handler) {
 	return async (request, handlerParams) => {
+		const page = new URL(request.url).searchParams.get("cursor") != null;
+		const { meterProvider } = handlerParams;
+		const metricBase = {
+			kind: "custom",
+			page,
+			dispatcher: "custom"
+		};
 		try {
-			return await handler(request, handlerParams);
+			const response = await handler(request, handlerParams);
+			recordCollectionRequest(meterProvider, collectionAttributes(metricBase, "served", response));
+			return response;
 		} catch (error) {
 			const { onNotFound, onUnauthorized } = handlerParams;
 			switch (error?.constructor) {
-				case ItemsNotFoundError: return await onNotFound(request);
-				case UnauthorizedError: return await onUnauthorized(request);
-				default: throw error;
+				case ItemsNotFoundError: {
+					const response = await onNotFound(request);
+					recordDeferredPendingCollectionMetrics(error, "not_found", response);
+					recordCollectionRequest(meterProvider, collectionAttributes(metricBase, "not_found", response));
+					return response;
+				}
+				case UnauthorizedError: {
+					const response = await onUnauthorized(request);
+					recordDeferredPendingCollectionMetrics(error, "unauthorized", response);
+					recordCollectionRequest(meterProvider, collectionAttributes(metricBase, "unauthorized", response));
+					return response;
+				}
+				default:
+					recordDeferredPendingCollectionMetrics(error, "error");
+					recordCollectionRequest(meterProvider, collectionAttributes(metricBase, "error"));
+					throw error;
 			}
 		}
 	};
@@ -1566,22 +2107,72 @@ const logger = getLogger([
 * @returns The response to the request.
 */
 async function handleWebFinger(request, options) {
-	if (options.tracer == null) return await handleWebFingerInternal(request, options);
-	return await options.tracer.startActiveSpan("webfinger.handle", { kind: SpanKind.SERVER }, async (span) => {
-		try {
-			const response = await handleWebFingerInternal(request, options);
-			span.setStatus({ code: response.ok ? SpanStatusCode.UNSET : SpanStatusCode.ERROR });
-			return response;
-		} catch (error) {
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: String(error)
-			});
-			throw error;
-		} finally {
-			span.end();
+	const meterProvider = options.meterProvider;
+	const start = meterProvider == null ? 0 : performance.now();
+	const scheme = computeResourceScheme(options.context.url.searchParams.get("resource"));
+	let notFoundResponse;
+	const wrappedOptions = {
+		...options,
+		async onNotFound(req) {
+			const r = await options.onNotFound(req);
+			notFoundResponse = r;
+			return r;
 		}
-	});
+	};
+	let response;
+	try {
+		if (options.tracer == null) response = await handleWebFingerInternal(request, wrappedOptions);
+		else response = await options.tracer.startActiveSpan("webfinger.handle", { kind: SpanKind.SERVER }, async (span) => {
+			try {
+				const inner = await handleWebFingerInternal(request, wrappedOptions);
+				span.setStatus({ code: inner.ok ? SpanStatusCode.UNSET : SpanStatusCode.ERROR });
+				return inner;
+			} catch (error) {
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+		return response;
+	} finally {
+		if (meterProvider != null) recordWebFingerHandle(meterProvider, {
+			durationMs: Math.max(0, performance.now() - start),
+			result: classifyWebFingerHandleResult(response, notFoundResponse),
+			scheme,
+			statusCode: response?.status
+		});
+	}
+}
+const WEBFINGER_HANDLE_SCHEME_WHITELIST = new Set([
+	"acct",
+	"http",
+	"https",
+	"mailto"
+]);
+function isAllowedResourceScheme(scheme) {
+	return WEBFINGER_HANDLE_SCHEME_WHITELIST.has(scheme);
+}
+function computeResourceScheme(resource) {
+	if (resource == null) return void 0;
+	const colon = resource.indexOf(":");
+	if (colon <= 0) return void 0;
+	const candidate = resource.substring(0, colon).toLowerCase();
+	return isAllowedResourceScheme(candidate) ? candidate : "other";
+}
+function classifyWebFingerHandleResult(response, notFoundResponse) {
+	if (response == null) return "error";
+	if (notFoundResponse != null && response === notFoundResponse) return "not_found";
+	switch (response.status) {
+		case 200: return "resolved";
+		case 400: return "invalid";
+		case 404: return "not_found";
+		case 410: return "tombstoned";
+		default: return "error";
+	}
 }
 async function handleWebFingerInternal(request, { context, host, actorDispatcher, actorHandleMapper, actorAliasMapper, onNotFound, span, webFingerLinksDispatcher }) {
 	if (actorDispatcher == null) {
@@ -1689,10 +2280,124 @@ async function handleWebFingerInternal(request, { context, host, actorDispatcher
 }
 //#endregion
 //#region src/federation/middleware.ts
+const circuitBreakerCasWarningKvStores = /* @__PURE__ */ new WeakSet();
+let nextQueueDepthGaugeSourceId = 0;
+const retryAfterHttpDate = /* @__PURE__ */ new RegExp("^(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \\d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \\d{4} \\d{2}:\\d{2}:\\d{2} GMT|(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), \\d{2}-(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\\d{2} \\d{2}:\\d{2}:\\d{2} GMT|(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (?: \\d|\\d{2}) \\d{2}:\\d{2}:\\d{2} \\d{4})$");
+function parseRetryAfter(headers, now = Temporal.Now.instant()) {
+	const value = headers.get("Retry-After");
+	if (value == null) return void 0;
+	const trimmed = value.trim();
+	if (/^\d+$/.test(trimmed)) {
+		const seconds = Number(trimmed);
+		if (!Number.isFinite(seconds)) return void 0;
+		return parseRetryAfterDuration({ seconds });
+	}
+	if (!retryAfterHttpDate.test(trimmed)) return void 0;
+	const httpDate = trimmed.endsWith("GMT") ? trimmed : `${trimmed} GMT`;
+	const retryAtMs = Date.parse(httpDate);
+	if (Number.isNaN(retryAtMs)) return void 0;
+	const nowMs = Number(now.epochMilliseconds);
+	return parseRetryAfterDuration({ milliseconds: Math.max(0, retryAtMs - nowMs) });
+}
+function parseRetryAfterDuration(durationLike) {
+	try {
+		return Temporal.Duration.from(durationLike);
+	} catch (error) {
+		if (error instanceof RangeError) return void 0;
+		throw error;
+	}
+}
+function clampNegativeDelay(delay) {
+	return delay.sign < 0 ? Temporal.Duration.from({ seconds: 0 }) : delay;
+}
+function getBenchmarkRelaxations(allowPrivateAddress, signatureTimeWindow) {
+	const relaxations = [];
+	if (allowPrivateAddress) relaxations.push({
+		protection: "private_address_checks",
+		effect: "disabled",
+		effectiveValue: true
+	});
+	if (signatureTimeWindow === false) relaxations.push({
+		protection: "http_signature_time_window",
+		effect: "disabled",
+		effectiveValue: false,
+		secureDefaultSeconds: 3600
+	});
+	else try {
+		const seconds = Temporal.Duration.from(signatureTimeWindow).total({ unit: "seconds" });
+		if (seconds !== 3600) relaxations.push({
+			protection: "http_signature_time_window",
+			effect: "changed",
+			effectiveSeconds: seconds,
+			secureDefaultSeconds: 3600
+		});
+	} catch {}
+	return relaxations;
+}
+function formatBenchmarkRelaxations(relaxations) {
+	if (relaxations.length < 1) return "no benchmark-only protections relaxed";
+	return relaxations.map((relaxation) => {
+		switch (relaxation.protection) {
+			case "private_address_checks": return "private address checks disabled (allowPrivateAddress=true)";
+			case "http_signature_time_window":
+				if (relaxation.effect === "disabled") return `HTTP Signature time window disabled (signatureTimeWindow=false)`;
+				return `HTTP Signature time window set to ${relaxation.effectiveSeconds}s (secure default: ${relaxation.secureDefaultSeconds}s)`;
+		}
+	}).join("; ");
+}
+function getBenchmarkTriggerOptions(benchmarkOptions) {
+	const sinks = benchmarkOptions.triggerSinks?.map((sink) => {
+		try {
+			return new URL(sink).href;
+		} catch {
+			throw new TypeError("benchmarkMode.triggerSinks must contain only URLs.");
+		}
+	});
+	return {
+		sinks: sinks == null ? void 0 : new Set(sinks),
+		allowUnsafeRecipients: benchmarkOptions.allowUnsafeTriggerRecipients === true
+	};
+}
+function maxDelay(first, second) {
+	return Temporal.Duration.compare(first, second) >= 0 ? first : second;
+}
+function isTransportDeliveryError(error) {
+	return error instanceof FetchError || isAbortError(error);
+}
+function toCircuitBreakerMetricState(state) {
+	return state === "half-open" ? "half_open" : state;
+}
+function recordCircuitBreakerSpanEvent(span, remoteHost, change) {
+	span.addEvent("activitypub.circuit_breaker.state_change", {
+		"activitypub.remote.host": remoteHost,
+		"activitypub.circuit_breaker.previous_state": toCircuitBreakerMetricState(change.previousState),
+		"activitypub.circuit_breaker.state": toCircuitBreakerMetricState(change.newState)
+	});
+}
+function recordCircuitBreakerHeldSpanEvent(span, remoteHost, state) {
+	span.addEvent("activitypub.circuit_breaker.held", {
+		"activitypub.remote.host": remoteHost,
+		"activitypub.circuit_breaker.state": toCircuitBreakerMetricState(state)
+	});
+}
+function isRemoteContextLoadingFailure(error) {
+	return error instanceof Error && typeof error.details === "object" && error.details != null && error.details.code === "loading remote context failed";
+}
+function isPermanentRemoteContextError(error) {
+	if (!(error instanceof Error) || error.name !== "jsonld.InvalidUrl") return false;
+	const details = error.details;
+	if (details?.code === "invalid remote context") return true;
+	return isRemoteContextLoadingFailure(error) && typeof details?.url === "string" && !URL.canParse(details.url) && isClearlyMalformedContextReference(details.url);
+}
+function isPermanentInboxParseError(error) {
+	return error instanceof Error && (error.name === "UnsafeJsonLdError" || error instanceof InvalidContextReferenceError || isPermanentRemoteContextError(error) || error.name === "jsonld.SyntaxError" && !isRemoteContextLoadingFailure(error)) || error instanceof TypeError && (/^(Invalid JSON-LD:|Invalid type:|Unexpected type:|Invalid @id:)/.test(error.message) || isInvalidUrlTypeError(error));
+}
 /**
 * Create a new {@link Federation} instance.
-* @param parameters Parameters for initializing the instance.
+* @param options Parameters for initializing the instance.
 * @returns A new {@link Federation} instance.
+* @throws {TypeError} If benchmark mode and `meterProvider` are both
+* specified.
 * @since 0.10.0
 */
 function createFederation(options) {
@@ -1720,12 +2425,37 @@ var FederationImpl = class extends FederationBuilderImpl {
 	skipSignatureVerification;
 	outboxRetryPolicy;
 	inboxRetryPolicy;
+	circuitBreaker;
 	activityTransformers;
 	_tracerProvider;
+	_meterProvider;
 	firstKnock;
 	inboxChallengePolicy;
+	benchmarkMode;
+	benchmarkMetricReader;
+	benchmarkTriggerOptions;
+	#queueDepthGaugeSourceId = `fedify-${(++nextQueueDepthGaugeSourceId).toString(36)}`;
+	#queueDepthGaugeEntries = [];
+	#queueDepthGaugeMeterProvider;
 	constructor(options) {
 		super();
+		const benchmarkMode = options.benchmarkMode != null && options.benchmarkMode !== false;
+		const benchmarkOptions = typeof options.benchmarkMode === "object" ? options.benchmarkMode : {};
+		const hasCustomLoaderFactory = options.documentLoaderFactory != null || options.contextLoaderFactory != null;
+		const allowPrivateAddress = options.allowPrivateAddress ?? (benchmarkMode && !hasCustomLoaderFactory ? true : false);
+		const signatureTimeWindow = options.signatureTimeWindow ?? (benchmarkMode ? false : { hours: 1 });
+		if (benchmarkMode && options.meterProvider != null) throw new TypeError("benchmarkMode requires Fedify to own the meterProvider; OpenTelemetry metric readers cannot be added after a MeterProvider is constructed.");
+		if (benchmarkMode) {
+			const relaxations = getBenchmarkRelaxations(allowPrivateAddress, signatureTimeWindow);
+			const relaxationSummary = formatBenchmarkRelaxations(relaxations);
+			getLogger([
+				"fedify",
+				"federation",
+				"benchmark"
+			]).warn(`Fedify benchmarkMode is enabled; ${relaxationSummary}. Benchmark endpoints are active and must not be used in production.`, { relaxations });
+		}
+		this.benchmarkMode = benchmarkMode;
+		this.benchmarkTriggerOptions = benchmarkMode ? getBenchmarkTriggerOptions(benchmarkOptions) : {};
 		this.kv = options.kv;
 		this.kvPrefixes = {
 			activityIdempotence: ["_fedify", "activityIdempotence"],
@@ -1733,6 +2463,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 			publicKey: ["_fedify", "publicKey"],
 			httpMessageSignaturesSpec: ["_fedify", "httpMessageSignaturesSpec"],
 			acceptSignatureNonce: ["_fedify", "acceptSignatureNonce"],
+			circuitBreaker: ["_fedify", "circuit"],
 			...options.kvPrefixes ?? {}
 		};
 		if (options.queue == null) {
@@ -1748,6 +2479,25 @@ var FederationImpl = class extends FederationBuilderImpl {
 			this.outboxQueue = options.queue.outbox;
 			this.fanoutQueue = options.queue.fanout;
 		}
+		if (options.circuitBreaker !== false && this.outboxQueue != null) {
+			this.circuitBreaker = new CircuitBreaker({
+				kv: options.kv,
+				prefix: this.kvPrefixes.circuitBreaker,
+				options: options.circuitBreaker,
+				stateChangeObserver: (remoteHost, _previousState, newState) => {
+					const metricState = toCircuitBreakerMetricState(newState);
+					recordCircuitBreakerStateChange(this.meterProvider, remoteHost, metricState);
+				}
+			});
+			if (options.kv.cas == null && !circuitBreakerCasWarningKvStores.has(options.kv)) {
+				circuitBreakerCasWarningKvStores.add(options.kv);
+				getLogger([
+					"fedify",
+					"federation",
+					"circuit"
+				]).warn("The configured key-value store does not support CAS; outbound delivery circuit breaker updates may race under concurrent workers.");
+			}
+		}
 		this.inboxQueueStarted = false;
 		this.outboxQueueStarted = false;
 		this.fanoutQueueStarted = false;
@@ -1773,48 +2523,109 @@ var FederationImpl = class extends FederationBuilderImpl {
 		}
 		this.router.trailingSlashInsensitive = options.trailingSlashInsensitive ?? false;
 		this._initializeRouter();
-		if (options.allowPrivateAddress || options.userAgent != null) {
+		if (options.allowPrivateAddress === true || options.userAgent != null) {
 			if (options.documentLoaderFactory != null) throw new TypeError("Cannot set documentLoaderFactory with allowPrivateAddress or userAgent options.");
 			if (options.contextLoaderFactory != null) throw new TypeError("Cannot set contextLoaderFactory with allowPrivateAddress or userAgent options.");
 			if (options.authenticatedDocumentLoaderFactory != null) throw new TypeError("Cannot set authenticatedDocumentLoaderFactory with allowPrivateAddress or userAgent options.");
 		}
-		const { allowPrivateAddress, userAgent } = options;
-		this.allowPrivateAddress = allowPrivateAddress ?? false;
-		this.documentLoaderFactory = options.documentLoaderFactory ?? ((opts) => {
-			return kvCache({
-				loader: getDocumentLoader({
-					allowPrivateAddress: opts?.allowPrivateAddress ?? allowPrivateAddress,
-					userAgent: opts?.userAgent ?? userAgent
-				}),
-				kv: options.kv,
-				prefix: this.kvPrefixes.remoteDocument
-			});
+		const { userAgent } = options;
+		this.allowPrivateAddress = allowPrivateAddress;
+		const userDocumentLoaderFactory = options.documentLoaderFactory;
+		const userContextLoaderFactory = options.contextLoaderFactory;
+		const userAuthFactory = options.authenticatedDocumentLoaderFactory;
+		const builtinDocumentLoaderFactory = (opts) => kvCache({
+			loader: getDocumentLoader({
+				allowPrivateAddress: opts?.allowPrivateAddress ?? allowPrivateAddress,
+				userAgent: opts?.userAgent ?? userAgent
+			}),
+			kv: options.kv,
+			prefix: this.kvPrefixes.remoteDocument,
+			meterProvider: this._meterProvider,
+			kind: "object"
+		});
+		const builtinContextLoaderFactory = (opts) => kvCache({
+			loader: getDocumentLoader({
+				allowPrivateAddress: opts?.allowPrivateAddress ?? allowPrivateAddress,
+				userAgent: opts?.userAgent ?? userAgent
+			}),
+			kv: options.kv,
+			prefix: this.kvPrefixes.remoteDocument,
+			meterProvider: this._meterProvider,
+			kind: "context"
+		});
+		this.documentLoaderFactory = (opts) => instrumentDocumentLoader((userDocumentLoaderFactory ?? builtinDocumentLoaderFactory)(opts), {
+			meterProvider: this._meterProvider,
+			kind: "object",
+			cacheEnabled: userDocumentLoaderFactory == null ? true : void 0
 		});
-		this.contextLoaderFactory = options.contextLoaderFactory ?? this.documentLoaderFactory;
-		this.authenticatedDocumentLoaderFactory = options.authenticatedDocumentLoaderFactory ?? ((identity) => getAuthenticatedDocumentLoader(identity, {
-			allowPrivateAddress,
-			userAgent,
+		const resolvedContextLoaderFactory = userContextLoaderFactory ?? userDocumentLoaderFactory ?? builtinContextLoaderFactory;
+		this.contextLoaderFactory = (opts) => instrumentDocumentLoader(resolvedContextLoaderFactory(opts), {
+			meterProvider: this._meterProvider,
+			kind: "context",
+			cacheEnabled: userContextLoaderFactory == null && userDocumentLoaderFactory == null ? true : void 0
+		});
+		this.authenticatedDocumentLoaderFactory = (identity, factoryOpts) => instrumentDocumentLoader(userAuthFactory != null ? userAuthFactory(identity, factoryOpts) : getAuthenticatedDocumentLoader(identity, {
+			allowPrivateAddress: factoryOpts?.allowPrivateAddress ?? allowPrivateAddress,
+			userAgent: factoryOpts?.userAgent ?? userAgent,
 			specDeterminer: new KvSpecDeterminer(this.kv, this.kvPrefixes.httpMessageSignaturesSpec, options.firstKnock),
 			tracerProvider: this.tracerProvider
-		}));
+		}), {
+			meterProvider: this._meterProvider,
+			kind: "object",
+			cacheEnabled: userAuthFactory == null ? false : void 0
+		});
 		this.userAgent = userAgent;
 		this.onOutboxError = options.onOutboxError;
 		this.permanentFailureStatusCodes = options.permanentFailureStatusCodes ?? [404, 410];
-		this.signatureTimeWindow = options.signatureTimeWindow ?? { hours: 1 };
+		this.signatureTimeWindow = signatureTimeWindow;
 		this.skipSignatureVerification = options.skipSignatureVerification ?? false;
 		this.inboxChallengePolicy = options.inboxChallengePolicy;
 		this.outboxRetryPolicy = options.outboxRetryPolicy ?? createExponentialBackoffPolicy();
 		this.inboxRetryPolicy = options.inboxRetryPolicy ?? createExponentialBackoffPolicy();
 		this.activityTransformers = options.activityTransformers ?? getDefaultActivityTransformers();
 		this._tracerProvider = options.tracerProvider;
+		if (benchmarkMode) {
+			const benchmarkMetrics = createBenchmarkMeterProvider();
+			this._meterProvider = benchmarkMetrics.meterProvider;
+			this.benchmarkMetricReader = benchmarkMetrics.reader;
+		} else this._meterProvider = options.meterProvider;
+		this.#queueDepthGaugeEntries = [
+			{
+				role: "inbox",
+				queue: this.inboxQueue
+			},
+			{
+				role: "outbox",
+				queue: this.outboxQueue
+			},
+			{
+				role: "fanout",
+				queue: this.fanoutQueue
+			}
+		];
+		this.#registerQueueDepthGauge(this._meterProvider ?? metrics.getMeterProvider());
 		this.firstKnock = options.firstKnock;
 	}
 	get tracerProvider() {
 		return this._tracerProvider ?? trace.getTracerProvider();
 	}
+	get meterProvider() {
+		const meterProvider = this._meterProvider ?? metrics.getMeterProvider();
+		this.#registerQueueDepthGauge(meterProvider);
+		return meterProvider;
+	}
+	#registerQueueDepthGauge(meterProvider) {
+		if (meterProvider === this.#queueDepthGaugeMeterProvider) return;
+		registerQueueDepthGauge(meterProvider, this.#queueDepthGaugeEntries, { sourceId: this.#queueDepthGaugeSourceId });
+		this.#queueDepthGaugeMeterProvider = meterProvider;
+	}
 	_initializeRouter() {
 		this.router.add("/.well-known/webfinger", "webfinger");
 		this.router.add("/.well-known/nodeinfo", "nodeInfoJrd");
+		if (this.benchmarkMode) {
+			this.router.add("/.well-known/fedify/bench/stats", "benchmarkStats");
+			this.router.add("/.well-known/fedify/bench/trigger", "benchmarkTrigger");
+		}
 	}
 	_getTracer() {
 		return this.tracerProvider.getTracer(name, version);
@@ -1845,80 +2656,125 @@ var FederationImpl = class extends FederationBuilderImpl {
 		await Promise.all(promises);
 	}
 	processQueuedTask(contextData, message) {
-		const tracer = this._getTracer();
-		const extractedContext = propagation.extract(context.active(), message.traceContext);
-		return withContext({ messageId: message.id }, async () => {
-			if (message.type === "fanout") await tracer.startActiveSpan("activitypub.fanout", {
-				kind: SpanKind.CONSUMER,
-				attributes: { "activitypub.activity.type": message.activityType }
-			}, extractedContext, async (span) => {
-				const spanCtx = span.spanContext();
-				return await withContext({
-					traceId: spanCtx.traceId,
-					spanId: spanCtx.spanId
-				}, async () => {
-					if (message.activityId != null) span.setAttribute("activitypub.activity.id", message.activityId);
-					try {
-						await this.#listenFanoutMessage(contextData, message);
-					} catch (e) {
-						span.setStatus({
-							code: SpanStatusCode.ERROR,
-							message: String(e)
-						});
-						throw e;
-					} finally {
-						span.end();
-					}
+		const tracer = this._getTracer();
+		const extractedContext = propagation.extract(context.active(), message.traceContext);
+		const meter = getFederationMetrics(this.meterProvider);
+		return withContext({ messageId: message.id }, async () => {
+			if (message.type === "fanout") {
+				const common = {
+					role: "fanout",
+					queue: this.fanoutQueue,
+					activityType: message.activityType
+				};
+				await tracer.startActiveSpan("activitypub.fanout", {
+					kind: SpanKind.CONSUMER,
+					attributes: { "activitypub.activity.type": message.activityType }
+				}, extractedContext, async (span) => {
+					const spanCtx = span.spanContext();
+					return await withContext({
+						traceId: spanCtx.traceId,
+						spanId: spanCtx.spanId
+					}, async () => {
+						if (message.activityId != null) span.setAttribute("activitypub.activity.id", message.activityId);
+						meter.recordQueueTaskStarted(common);
+						meter.incrementQueueTaskInFlight(common);
+						const startedAt = performance.now();
+						let outcome = "completed";
+						try {
+							await this.#listenFanoutMessage(contextData, message);
+						} catch (e) {
+							const aborted = isAbortError(e);
+							outcome = aborted ? "aborted" : "failed";
+							if (!aborted) span.setStatus({
+								code: SpanStatusCode.ERROR,
+								message: String(e)
+							});
+							throw e;
+						} finally {
+							meter.recordQueueTaskOutcome(common, outcome, getDurationMs(startedAt));
+							meter.decrementQueueTaskInFlight(common);
+							span.end();
+						}
+					});
 				});
-			});
-			else if (message.type === "outbox") await tracer.startActiveSpan("activitypub.outbox", {
-				kind: SpanKind.CONSUMER,
-				attributes: {
-					"activitypub.activity.type": message.activityType,
-					"activitypub.activity.retries": message.attempt
-				}
-			}, extractedContext, async (span) => {
-				const spanCtx = span.spanContext();
-				return await withContext({
-					traceId: spanCtx.traceId,
-					spanId: spanCtx.spanId
-				}, async () => {
-					if (message.activityId != null) span.setAttribute("activitypub.activity.id", message.activityId);
-					try {
-						await this.#listenOutboxMessage(contextData, message, span);
-					} catch (e) {
-						span.setStatus({
-							code: SpanStatusCode.ERROR,
-							message: String(e)
-						});
-						throw e;
-					} finally {
-						span.end();
+			} else if (message.type === "outbox") {
+				const common = {
+					role: "outbox",
+					queue: this.outboxQueue,
+					activityType: message.activityType
+				};
+				await tracer.startActiveSpan("activitypub.outbox", {
+					kind: SpanKind.CONSUMER,
+					attributes: {
+						"activitypub.activity.type": message.activityType,
+						"activitypub.activity.retries": message.attempt
 					}
+				}, extractedContext, async (span) => {
+					const spanCtx = span.spanContext();
+					return await withContext({
+						traceId: spanCtx.traceId,
+						spanId: spanCtx.spanId
+					}, async () => {
+						if (message.activityId != null) span.setAttribute("activitypub.activity.id", message.activityId);
+						meter.recordQueueTaskStarted(common);
+						meter.incrementQueueTaskInFlight(common);
+						const startedAt = performance.now();
+						let outcome = "completed";
+						try {
+							await this.#listenOutboxMessage(contextData, message, span);
+						} catch (e) {
+							const aborted = isAbortError(e);
+							outcome = aborted ? "aborted" : "failed";
+							if (!aborted) span.setStatus({
+								code: SpanStatusCode.ERROR,
+								message: String(e)
+							});
+							throw e;
+						} finally {
+							meter.recordQueueTaskOutcome(common, outcome, getDurationMs(startedAt));
+							meter.decrementQueueTaskInFlight(common);
+							span.end();
+						}
+					});
 				});
-			});
-			else if (message.type === "inbox") await tracer.startActiveSpan("activitypub.inbox", {
-				kind: SpanKind.CONSUMER,
-				attributes: { "activitypub.shared_inbox": message.identifier == null }
-			}, extractedContext, async (span) => {
-				const spanCtx = span.spanContext();
-				return await withContext({
-					traceId: spanCtx.traceId,
-					spanId: spanCtx.spanId
-				}, async () => {
-					try {
-						await this.#listenInboxMessage(contextData, message, span);
-					} catch (e) {
-						span.setStatus({
-							code: SpanStatusCode.ERROR,
-							message: String(e)
-						});
-						throw e;
-					} finally {
-						span.end();
-					}
+			} else if (message.type === "inbox") {
+				const common = {
+					role: "inbox",
+					queue: this.inboxQueue
+				};
+				await tracer.startActiveSpan("activitypub.inbox", {
+					kind: SpanKind.CONSUMER,
+					attributes: { "activitypub.shared_inbox": message.identifier == null }
+				}, extractedContext, async (span) => {
+					const spanCtx = span.spanContext();
+					return await withContext({
+						traceId: spanCtx.traceId,
+						spanId: spanCtx.spanId
+					}, async () => {
+						meter.recordQueueTaskStarted(common);
+						meter.incrementQueueTaskInFlight(common);
+						const startedAt = performance.now();
+						let outcome = "completed";
+						try {
+							await this.#listenInboxMessage(contextData, message, span, (activityType) => {
+								common.activityType = activityType;
+							});
+						} catch (e) {
+							const aborted = isAbortError(e);
+							outcome = aborted ? "aborted" : "failed";
+							if (!aborted) span.setStatus({
+								code: SpanStatusCode.ERROR,
+								message: String(e)
+							});
+							throw e;
+						} finally {
+							meter.recordQueueTaskOutcome(common, outcome, getDurationMs(startedAt));
+							meter.decrementQueueTaskInFlight(common);
+							span.end();
+						}
+					});
 				});
-			});
+			}
 		});
 	}
 	async #listenFanoutMessage(data, message) {
@@ -1980,29 +2836,202 @@ var FederationImpl = class extends FederationBuilderImpl {
 			if (rsaKeyPair == null && pair.privateKey.algorithm.name === "RSASSA-PKCS1-v1_5") rsaKeyPair = pair;
 			keys.push(pair);
 		}
+		const loaderOptions = this.#getLoaderOptions(message.baseUrl);
+		let parsedActorIds;
+		const getActorIds = () => {
+			parsedActorIds ??= (message.actorIds ?? []).flatMap((id) => {
+				try {
+					return [new URL(id)];
+				} catch {
+					logger.warn("Invalid actorId URL in OutboxMessage: {id}", { id });
+					return [];
+				}
+			});
+			return parsedActorIds;
+		};
+		const parseActivity = () => Activity.fromJsonLd(message.activity, {
+			contextLoader: this.contextLoaderFactory(loaderOptions),
+			documentLoader: rsaKeyPair == null ? this.documentLoaderFactory(loaderOptions) : this.authenticatedDocumentLoaderFactory(rsaKeyPair, loaderOptions),
+			tracerProvider: this.tracerProvider
+		});
+		const enqueueHeldOutboxMessage = async (delay, heldSince) => {
+			const { outboxQueue } = this;
+			if (outboxQueue == null) return;
+			const heldMessage = {
+				...message,
+				circuitHeld: true,
+				circuitHeldSince: heldSince.toString()
+			};
+			await outboxQueue.enqueue(heldMessage, {
+				delay: clampNegativeDelay(delay),
+				orderingKey: message.orderingKey
+			});
+			getFederationMetrics(this.meterProvider).recordQueueTaskEnqueued({
+				role: "outbox",
+				queue: outboxQueue,
+				activityType: heldMessage.activityType
+			}, heldMessage.attempt);
+		};
+		const dropHeldOutboxMessage = async (circuit, remoteHost, inbox, heldSince, activity) => {
+			await circuit.dropActivity(remoteHost, {
+				inbox,
+				activity,
+				activityId: message.activityId,
+				activityType: message.activityType,
+				actorIds: getActorIds(),
+				heldSince
+			});
+			if (this.outboxPermanentFailureHandler != null) {
+				const ctx = this.#createContext(new URL(message.baseUrl), _, { documentLoader: this.documentLoaderFactory(loaderOptions) });
+				try {
+					await this.outboxPermanentFailureHandler(ctx, {
+						reason: "circuit-breaker-ttl",
+						inbox,
+						activity,
+						error: new SendActivityError(inbox, 0, "Circuit breaker held activity expired.", ""),
+						statusCode: 0,
+						circuitHeldSince: heldSince,
+						actorIds: getActorIds()
+					});
+				} catch (handlerError) {
+					logger.error("An unexpected error occurred in outboxPermanentFailureHandler:\n{error}", {
+						...logData,
+						error: handlerError
+					});
+				}
+			}
+			recordOutboxActivity(this.meterProvider, "abandoned", message.activityType);
+		};
 		try {
+			const inbox = new URL(message.inbox);
+			const circuit = this.outboxQueue == null ? void 0 : this.circuitBreaker;
+			const remoteHost = getRemoteHost(inbox);
+			let decision;
+			if (circuit != null) try {
+				decision = await circuit.beforeSend(remoteHost, message);
+			} catch (circuitError) {
+				getLogger([
+					"fedify",
+					"federation",
+					"circuit"
+				]).error("Failed to check circuit breaker state before sending; proceeding with delivery:\n{error}", {
+					...logData,
+					remoteHost,
+					error: circuitError
+				});
+			}
+			if (decision != null && circuit != null) {
+				if (decision.type === "hold") {
+					recordCircuitBreakerHeldSpanEvent(span, remoteHost, decision.state);
+					await enqueueHeldOutboxMessage(decision.delay, decision.heldSince);
+					return;
+				}
+				if (decision.type === "drop") {
+					const activity = await parseActivity();
+					await dropHeldOutboxMessage(circuit, remoteHost, inbox, decision.heldSince, activity);
+					return;
+				}
+				if (decision.stateChange != null) recordCircuitBreakerSpanEvent(span, remoteHost, decision.stateChange);
+			}
 			await sendActivity({
 				keys,
 				activity: message.activity,
 				activityId: message.activityId,
 				activityType: message.activityType,
-				inbox: new URL(message.inbox),
+				inbox,
 				sharedInbox: message.sharedInbox,
 				headers: new Headers(message.headers),
 				specDeterminer: new KvSpecDeterminer(this.kv, this.kvPrefixes.httpMessageSignaturesSpec, this.firstKnock),
+				meterProvider: this.meterProvider,
 				tracerProvider: this.tracerProvider
 			});
+			if (circuit != null) try {
+				const stateChange = await circuit.recordSuccess(remoteHost);
+				if (stateChange != null) recordCircuitBreakerSpanEvent(span, remoteHost, stateChange);
+			} catch (error) {
+				getLogger([
+					"fedify",
+					"federation",
+					"circuit"
+				]).error("Failed to record successful delivery in circuit breaker state; the activity was already delivered:\n{error}", {
+					...logData,
+					remoteHost,
+					error
+				});
+			}
 		} catch (error) {
 			span.setStatus({
 				code: SpanStatusCode.ERROR,
 				message: String(error)
 			});
-			const loaderOptions = this.#getLoaderOptions(message.baseUrl);
-			const activity = await Activity.fromJsonLd(message.activity, {
-				contextLoader: this.contextLoaderFactory(loaderOptions),
-				documentLoader: rsaKeyPair == null ? this.documentLoaderFactory(loaderOptions) : this.authenticatedDocumentLoaderFactory(rsaKeyPair, loaderOptions),
-				tracerProvider: this.tracerProvider
+			const remoteHost = (() => {
+				if (error instanceof SendActivityError) return getRemoteHost(error.inbox);
+				try {
+					return getRemoteHost(new URL(message.inbox));
+				} catch (_) {
+					logger.warn("Invalid inbox URL in queued outbox message: {inbox}", logData);
+					return;
+				}
+			})();
+			let retryAfterDelay;
+			let circuitHold;
+			let circuitDrop;
+			let retryPolicyDelay;
+			let policyDelayCalculated = false;
+			const getPolicyDelay = () => {
+				if (!policyDelayCalculated) {
+					retryPolicyDelay = this.outboxRetryPolicy({
+						elapsedTime: Temporal.Instant.from(message.started).until(Temporal.Now.instant()),
+						attempts: message.attempt
+					});
+					policyDelayCalculated = true;
+				}
+				return retryPolicyDelay;
+			};
+			const isPermanentFailure = error instanceof SendActivityError && this.permanentFailureStatusCodes.includes(error.statusCode);
+			if (!isPermanentFailure && error instanceof SendActivityError && (error.statusCode === 429 || error.statusCode === 503)) retryAfterDelay = parseRetryAfter(error.responseHeaders);
+			if (remoteHost != null && this.outboxQueue != null && this.circuitBreaker != null) try {
+				if (error instanceof SendActivityError) {
+					const { statusCode } = error;
+					const stateChange = isPermanentFailure || statusCode === 429 || statusCode >= 400 && statusCode < 500 ? await this.circuitBreaker.recordReachableFailure(remoteHost) : statusCode >= 500 ? await this.circuitBreaker.recordFailure(remoteHost) : void 0;
+					if (stateChange != null) recordCircuitBreakerSpanEvent(span, remoteHost, stateChange);
+				} else if (isTransportDeliveryError(error)) {
+					const stateChange = await this.circuitBreaker.recordFailure(remoteHost);
+					if (stateChange != null) recordCircuitBreakerSpanEvent(span, remoteHost, stateChange);
+				}
+				if (!isPermanentFailure) {
+					const circuitDecision = await this.circuitBreaker.beforeSend(remoteHost, message);
+					if (circuitDecision.type === "hold") circuitHold = {
+						delay: circuitDecision.delay,
+						heldSince: circuitDecision.heldSince,
+						remoteHost,
+						state: circuitDecision.state
+					};
+					else if (circuitDecision.type === "drop") circuitDrop = {
+						circuit: this.circuitBreaker,
+						remoteHost,
+						inbox: new URL(message.inbox),
+						heldSince: circuitDecision.heldSince
+					};
+				}
+			} catch (circuitError) {
+				getLogger([
+					"fedify",
+					"federation",
+					"circuit"
+				]).error("Failed to update circuit breaker state after delivery failure; falling back to normal failure handling:\n{error}", {
+					...logData,
+					remoteHost,
+					error: circuitError
+				});
+			}
+			span.addEvent("activitypub.delivery.failed", {
+				...remoteHost == null ? {} : { "activitypub.remote.host": remoteHost },
+				"activitypub.delivery.attempt": message.attempt,
+				"activitypub.delivery.permanent_failure": isPermanentFailure,
+				...error instanceof SendActivityError ? { "http.response.status_code": error.statusCode } : {}
 			});
+			const activity = await parseActivity();
 			try {
 				await this.onOutboxError?.(error, activity);
 			} catch (error) {
@@ -2011,7 +3040,12 @@ var FederationImpl = class extends FederationBuilderImpl {
 					error
 				});
 			}
-			if (error instanceof SendActivityError && this.permanentFailureStatusCodes.includes(error.statusCode)) {
+			if (circuitDrop != null) {
+				await dropHeldOutboxMessage(circuitDrop.circuit, circuitDrop.remoteHost, circuitDrop.inbox, circuitDrop.heldSince, activity);
+				return;
+			}
+			if (isPermanentFailure) {
+				getFederationMetrics(this.meterProvider).recordPermanentFailure(error.inbox, error.statusCode);
 				logger.warn("Permanent delivery failure for activity {activityId} to {inbox} ({status}); not retrying.", {
 					...logData,
 					status: error.statusCode
@@ -2020,18 +3054,12 @@ var FederationImpl = class extends FederationBuilderImpl {
 					const ctx = this.#createContext(new URL(message.baseUrl), _, { documentLoader: this.documentLoaderFactory(loaderOptions) });
 					try {
 						await this.outboxPermanentFailureHandler(ctx, {
+							reason: "http",
 							inbox: new URL(message.inbox),
 							activity,
 							error,
 							statusCode: error.statusCode,
-							actorIds: (message.actorIds ?? []).flatMap((id) => {
-								try {
-									return [new URL(id)];
-								} catch {
-									logger.warn("Invalid actorId URL in OutboxMessage: {id}", { id });
-									return [];
-								}
-							})
+							actorIds: getActorIds()
 						});
 					} catch (handlerError) {
 						logger.error("An unexpected error occurred in outboxPermanentFailureHandler:\n{error}", {
@@ -2040,37 +3068,62 @@ var FederationImpl = class extends FederationBuilderImpl {
 						});
 					}
 				}
+				recordOutboxActivity(this.meterProvider, "abandoned", message.activityType);
 				return;
 			}
-			if (this.outboxQueue?.nativeRetrial) {
+			if (circuitHold != null && getPolicyDelay() != null) {
+				logger.error("Failed to send activity {activityId} to {inbox}; holding because the remote host circuit is open:\n{error}", {
+					...logData,
+					error
+				});
+				recordCircuitBreakerHeldSpanEvent(span, circuitHold.remoteHost, circuitHold.state);
+				const circuit = this.circuitBreaker;
+				await enqueueHeldOutboxMessage(retryAfterDelay == null || circuit == null ? circuitHold.delay : circuit.capHeldDelay(circuitHold.heldSince, maxDelay(circuitHold.delay, retryAfterDelay)), circuitHold.heldSince);
+				return;
+			}
+			if (this.outboxQueue?.nativeRetrial && retryAfterDelay == null) {
 				logger.error("Failed to send activity {activityId} to {inbox}; backend will handle retry:\n{error}", {
 					...logData,
 					error
 				});
 				throw error;
 			}
-			const delay = this.outboxRetryPolicy({
-				elapsedTime: Temporal.Instant.from(message.started).until(Temporal.Now.instant()),
-				attempts: message.attempt
-			});
+			const policyDelay = getPolicyDelay();
+			const delay = policyDelay == null ? null : retryAfterDelay ?? policyDelay;
 			if (delay != null) {
 				logger.error("Failed to send activity {activityId} to {inbox} (attempt #{attempt}); retry...:\n{error}", {
 					...logData,
 					error
 				});
-				await this.outboxQueue?.enqueue({
+				const retryMessage = {
 					...message,
 					attempt: message.attempt + 1
-				}, { delay: Temporal.Duration.compare(delay, { seconds: 0 }) < 0 ? Temporal.Duration.from({ seconds: 0 }) : delay });
-			} else logger.error("Failed to send activity {activityId} to {inbox} after {attempt} attempts; giving up:\n{error}", {
-				...logData,
-				error
-			});
+				};
+				const { outboxQueue } = this;
+				if (outboxQueue != null) {
+					await outboxQueue.enqueue(retryMessage, {
+						delay: clampNegativeDelay(delay),
+						orderingKey: message.orderingKey
+					});
+					getFederationMetrics(this.meterProvider).recordQueueTaskEnqueued({
+						role: "outbox",
+						queue: outboxQueue,
+						activityType: retryMessage.activityType
+					}, retryMessage.attempt);
+					recordOutboxActivity(this.meterProvider, "retried", retryMessage.activityType);
+				}
+			} else {
+				logger.error("Failed to send activity {activityId} to {inbox} after {attempt} attempts; giving up:\n{error}", {
+					...logData,
+					error
+				});
+				recordOutboxActivity(this.meterProvider, "abandoned", message.activityType);
+			}
 			return;
 		}
 		logger.info("Successfully sent activity {activityId} to {inbox}.", { ...logData });
 	}
-	async #listenInboxMessage(ctxData, message, span) {
+	async #listenInboxMessage(ctxData, message, span, onActivityType) {
 		const logger = getLogger([
 			"fedify",
 			"federation",
@@ -2083,68 +3136,37 @@ var FederationImpl = class extends FederationBuilderImpl {
 			const identity = await this.sharedInboxKeyDispatcher(context);
 			if (identity != null) context = this.#createContext(baseUrl, ctxData, { documentLoader: "identifier" in identity || "username" in identity ? await context.getDocumentLoader(identity) : context.getDocumentLoader(identity) });
 		}
-		const activity = await Activity.fromJsonLd(message.activity, context);
-		span.setAttribute("activitypub.activity.type", getTypeId(activity).href);
-		if (activity.id != null) span.setAttribute("activitypub.activity.id", activity.id.href);
-		const cacheKey = activity.id == null ? null : [
-			...this.kvPrefixes.activityIdempotence,
-			context.origin,
-			activity.id.href
-		];
-		if (cacheKey != null) {
-			if (await this.kv.get(cacheKey) === true) {
-				logger.debug("Activity {activityId} has already been processed.", {
-					activityId: activity.id?.href,
-					activity: message.activity,
-					recipient: message.identifier
-				});
-				return;
-			}
-		}
-		await this._getTracer().startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (span) => {
-			const dispatched = this.inboxListeners?.dispatchWithClass(activity);
-			if (dispatched == null) {
-				logger.error("Unsupported activity type:\n{activity}", {
-					activityId: activity.id?.href,
-					activity: message.activity,
-					recipient: message.identifier,
-					trial: message.attempt
-				});
-				span.setStatus({
-					code: SpanStatusCode.ERROR,
-					message: `Unsupported activity type: ${getTypeId(activity).href}`
-				});
-				span.end();
-				return;
-			}
-			const { class: cls, listener } = dispatched;
-			span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
-			try {
-				await listener(context.toInboxContext(message.identifier, message.activity, activity.id?.href, getTypeId(activity).href), activity);
-			} catch (error) {
+		await this._getTracer().startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (listenerSpan) => {
+			let activity = null;
+			let cacheKey = null;
+			let activityType;
+			const reportInboxError = async (error) => {
 				try {
 					await this.inboxErrorHandler?.(context, error);
 				} catch (error) {
 					logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
 						error,
 						trial: message.attempt,
-						activityId: activity.id?.href,
+						activityId: activity?.id?.href,
 						activity: message.activity,
 						recipient: message.identifier
 					});
 				}
+			};
+			const handleRetriableFailure = async (error) => {
+				await reportInboxError(error);
 				if (this.inboxQueue?.nativeRetrial) {
 					logger.error("Failed to process the incoming activity {activityId}; backend will handle retry:\n{error}", {
 						error,
-						activityId: activity.id?.href,
+						activityId: activity?.id?.href,
 						activity: message.activity,
 						recipient: message.identifier
 					});
-					span.setStatus({
+					listenerSpan.setStatus({
 						code: SpanStatusCode.ERROR,
 						message: String(error)
 					});
-					span.end();
+					listenerSpan.end();
 					throw error;
 				}
 				const delay = this.inboxRetryPolicy({
@@ -2155,34 +3177,165 @@ var FederationImpl = class extends FederationBuilderImpl {
 					logger.error("Failed to process the incoming activity {activityId} (attempt #{attempt}); retry...:\n{error}", {
 						error,
 						attempt: message.attempt,
-						activityId: activity.id?.href,
+						activityId: activity?.id?.href,
 						activity: message.activity,
 						recipient: message.identifier
 					});
-					await this.inboxQueue?.enqueue({
+					if (this.inboxQueue == null) {
+						listenerSpan.setStatus({
+							code: SpanStatusCode.ERROR,
+							message: String(error)
+						});
+						listenerSpan.end();
+						throw error;
+					}
+					const retryMessage = {
 						...message,
 						attempt: message.attempt + 1
-					}, { delay: Temporal.Duration.compare(delay, { seconds: 0 }) < 0 ? Temporal.Duration.from({ seconds: 0 }) : delay });
-				} else logger.error("Failed to process the incoming activity {activityId} after {trial} attempts; giving up:\n{error}", {
-					error,
+					};
+					await this.inboxQueue.enqueue(retryMessage, { delay: clampNegativeDelay(delay) });
+					if (activityType != null) {
+						getFederationMetrics(this.meterProvider).recordQueueTaskEnqueued({
+							role: "inbox",
+							queue: this.inboxQueue,
+							activityType
+						}, retryMessage.attempt);
+						recordInboxActivity(this.meterProvider, "retried", activityType);
+					}
+				} else {
+					logger.error("Failed to process the incoming activity {activityId} after {trial} attempts; giving up:\n{error}", {
+						error,
+						activityId: activity?.id?.href,
+						activity: message.activity,
+						recipient: message.identifier
+					});
+					if (activityType != null) recordInboxActivity(this.meterProvider, "abandoned", activityType);
+				}
+				listenerSpan.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: String(error)
+				});
+				listenerSpan.end();
+			};
+			let dispatched;
+			let parseInput = void 0;
+			let parseContextLoader = context.contextLoader;
+			try {
+				const hasSignatureField = hasSignature(message.activity);
+				const shouldParseFromNormalizedSignedPayload = message.ldSignatureVerified === true || message.normalizedActivity != null || message.ldSignatureVerified == null && hasSignatureField;
+				const parseContext = hasSignatureField ? {
+					...context,
+					contextLoader: getNormalizationContextLoader(context.contextLoader)
+				} : {
+					...context,
+					contextLoader: wrapContextLoaderForJsonLd(context.contextLoader)
+				};
+				parseContextLoader = parseContext.contextLoader;
+				let normalizedActivity;
+				if (shouldParseFromNormalizedSignedPayload) {
+					normalizedActivity = message.normalizedActivity ?? await compactJsonLd(message.activity, context.contextLoader);
+					assertSafeJsonLd(normalizedActivity);
+				}
+				parseInput = shouldParseFromNormalizedSignedPayload ? detachSignature(normalizedActivity) : hasSignatureField ? detachSignature(message.activity) : message.activity;
+				activity = await Activity.fromJsonLd(parseInput, parseContext);
+				activityType = getTypeId(activity).href;
+				span.setAttribute("activitypub.activity.type", activityType);
+				listenerSpan.setAttribute("activitypub.activity.type", activityType);
+				onActivityType?.(activityType);
+				if (activity.id != null) {
+					span.setAttribute("activitypub.activity.id", activity.id.href);
+					listenerSpan.setAttribute("activitypub.activity.id", activity.id.href);
+				}
+				cacheKey = activity.id == null ? null : [
+					...this.kvPrefixes.activityIdempotence,
+					context.origin,
+					activity.id.href
+				];
+				if (cacheKey != null) {
+					if (await this.kv.get(cacheKey) === true) {
+						logger.debug("Activity {activityId} has already been processed.", {
+							activityId: activity.id?.href,
+							activity: message.activity,
+							recipient: message.identifier
+						});
+						recordInboxActivity(this.meterProvider, "rejected", activityType);
+						listenerSpan.end();
+						return;
+					}
+				}
+				dispatched = this.inboxListeners?.dispatchWithClass(activity);
+			} catch (error) {
+				if (activity == null && error instanceof RangeError && await hasMalformedKnownTemporalLiteral(parseInput, parseContextLoader)) {
+					await reportInboxError(error);
+					logger.error("Failed to parse the queued incoming activity {activityId}:\n{error}", {
+						error,
+						trial: message.attempt,
+						activityId: null,
+						activity: message.activity,
+						recipient: message.identifier
+					});
+					listenerSpan.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: String(error)
+					});
+					listenerSpan.end();
+					return;
+				}
+				if (isPermanentInboxParseError(error)) {
+					await reportInboxError(error);
+					logger.error("Failed to parse the queued incoming activity {activityId}:\n{error}", {
+						error,
+						trial: message.attempt,
+						activityId: activity?.id?.href,
+						activity: message.activity,
+						recipient: message.identifier
+					});
+					listenerSpan.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: String(error)
+					});
+					listenerSpan.end();
+					return;
+				}
+				await handleRetriableFailure(error);
+				return;
+			}
+			if (dispatched == null) {
+				logger.error("Unsupported activity type:\n{activity}", {
 					activityId: activity.id?.href,
 					activity: message.activity,
-					recipient: message.identifier
+					recipient: message.identifier,
+					trial: message.attempt
 				});
-				span.setStatus({
+				listenerSpan.setStatus({
 					code: SpanStatusCode.ERROR,
-					message: String(error)
+					message: `Unsupported activity type: ${activityType}`
 				});
-				span.end();
+				recordInboxActivity(this.meterProvider, "rejected", activityType);
+				listenerSpan.end();
+				return;
+			}
+			const { class: cls, listener } = dispatched;
+			listenerSpan.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
+			try {
+				const started = performance.now();
+				try {
+					await listener(context.toInboxContext(message.identifier, message.activity, activity.id?.href, activityType), activity);
+				} finally {
+					getFederationMetrics(this.meterProvider).recordInboxProcessingDuration(activityType, getDurationMs(started));
+				}
+				recordInboxActivity(this.meterProvider, "processed", activityType);
+			} catch (error) {
+				await handleRetriableFailure(error);
 				return;
 			}
 			if (cacheKey != null) await this.kv.set(cacheKey, true, { ttl: Temporal.Duration.from({ days: 1 }) });
 			logger.info("Activity {activityId} has been processed.", {
-				activityId: activity.id?.href,
+				activityId: activity?.id?.href,
 				activity: message.activity,
 				recipient: message.identifier
 			});
-			span.end();
+			listenerSpan.end();
 		});
 	}
 	startQueue(contextData, options = {}) {
@@ -2303,6 +3456,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				sharedInbox: inboxes[inbox].sharedInbox,
 				headers: collectionSync == null ? void 0 : new Headers({ "Collection-Synchronization": await buildCollectionSynchronizationHeader(collectionSync, inboxes[inbox].actorIds) }),
 				specDeterminer: new KvSpecDeterminer(this.kv, this.kvPrefixes.httpMessageSignaturesSpec, this.firstKnock),
+				meterProvider: this.meterProvider,
 				tracerProvider: this.tracerProvider
 			}));
 			await Promise.all(promises);
@@ -2350,9 +3504,11 @@ var FederationImpl = class extends FederationBuilderImpl {
 			});
 		}
 		const { outboxQueue } = this;
-		if (outboxQueue.enqueueMany == null) {
-			const promises = messages.map((m) => outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey }));
-			const errors = (await Promise.allSettled(promises)).filter((r) => r.status === "rejected").map((r) => r.reason);
+		if (outboxQueue.enqueueMany == null || orderingKey != null) {
+			const errors = (await Promise.allSettled(messages.map(async (m) => {
+				await outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey });
+				recordOutboxEnqueue(this.meterProvider, outboxQueue, m.message);
+			}))).filter((r) => r.status === "rejected").map((r) => r.reason);
 			if (errors.length > 0) {
 				logger.error("Failed to enqueue activity {activityId} to send later: {errors}", {
 					activityId: activity.id.href,
@@ -2361,30 +3517,24 @@ var FederationImpl = class extends FederationBuilderImpl {
 				if (errors.length > 1) throw new AggregateError(errors, `Failed to enqueue activity ${activityId} to send later.`);
 				throw errors[0];
 			}
-		} else if (orderingKey != null) {
-			const promises = messages.map((m) => outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey }));
-			const errors = (await Promise.allSettled(promises)).filter((r) => r.status === "rejected").map((r) => r.reason);
-			if (errors.length > 0) {
-				logger.error("Failed to enqueue activity {activityId} to send later: {errors}", {
+		} else {
+			try {
+				await outboxQueue.enqueueMany(messages.map((m) => m.message));
+			} catch (error) {
+				logger.error("Failed to enqueue activity {activityId} to send later: {error}", {
 					activityId: activity.id.href,
-					errors
+					error
 				});
-				if (errors.length > 1) throw new AggregateError(errors, `Failed to enqueue activity ${activityId} to send later.`);
-				throw errors[0];
+				throw error;
 			}
-		} else try {
-			await outboxQueue.enqueueMany(messages.map((m) => m.message));
-		} catch (error) {
-			logger.error("Failed to enqueue activity {activityId} to send later: {error}", {
-				activityId: activity.id.href,
-				error
-			});
-			throw error;
+			for (const m of messages) recordOutboxEnqueue(this.meterProvider, outboxQueue, m.message);
 		}
 	}
 	fetch(request, options) {
 		return withContext({ requestId: getRequestId(request) }, async () => {
 			const tracer = this._getTracer();
+			const metricState = {};
+			const metricStart = performance.now();
 			return await tracer.startActiveSpan(request.method, {
 				kind: SpanKind.SERVER,
 				attributes: {
@@ -2408,10 +3558,12 @@ var FederationImpl = class extends FederationBuilderImpl {
 						response = await this.#fetch(request, {
 							...options,
 							span,
-							tracer
+							tracer,
+							metricState
 						});
 						if (acceptsJsonLd(request)) response.headers.set("Vary", "Accept");
 					} catch (error) {
+						getFederationMetrics(this.meterProvider).recordHttpServerRequest(request.method, metricState.endpoint ?? "error", getDurationMs(metricStart), { routeTemplate: metricState.routeTemplate });
 						span.setStatus({
 							code: SpanStatusCode.ERROR,
 							message: `${error}`
@@ -2424,6 +3576,10 @@ var FederationImpl = class extends FederationBuilderImpl {
 						});
 						throw error;
 					}
+					getFederationMetrics(this.meterProvider).recordHttpServerRequest(request.method, metricState.endpoint ?? "error", getDurationMs(metricStart), {
+						statusCode: response.status,
+						routeTemplate: metricState.routeTemplate
+					});
 					if (span.isRecording()) {
 						span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
 						for (const [k, v] of response.headers) span.setAttribute(ATTR_HTTP_RESPONSE_HEADER(k), [v]);
@@ -2449,13 +3605,18 @@ var FederationImpl = class extends FederationBuilderImpl {
 			});
 		});
 	}
-	async #fetch(request, { onNotFound, onNotAcceptable, onUnauthorized, contextData, span, tracer }) {
+	async #fetch(request, { onNotFound, onNotAcceptable, onUnauthorized, contextData, span, tracer, metricState }) {
 		onNotFound ??= notFound;
 		onNotAcceptable ??= notAcceptable;
 		onUnauthorized ??= unauthorized;
 		const url = new URL(request.url);
 		const route = this.router.route(url.pathname);
-		if (route == null) return await onNotFound(request);
+		if (route == null) {
+			metricState.endpoint = "not_found";
+			return await onNotFound(request);
+		}
+		metricState.routeTemplate = route.template;
+		metricState.endpoint = getEndpointCategory(route.name);
 		span.updateName(`${request.method} ${route.template}`);
 		let context = this.#createContext(request, contextData);
 		const routeName = route.name.replace(/:.*$/, "");
@@ -2468,26 +3629,43 @@ var FederationImpl = class extends FederationBuilderImpl {
 				actorAliasMapper: this.actorCallbacks?.aliasMapper,
 				webFingerLinksDispatcher: this.webFingerLinksDispatcher,
 				onNotFound,
-				tracer
+				tracer,
+				meterProvider: this._meterProvider
 			});
 			case "nodeInfoJrd": return await handleNodeInfoJrd(request, context);
 			case "nodeInfo": return await handleNodeInfo(request, {
 				context,
 				nodeInfoDispatcher: this.nodeInfoDispatcher
 			});
+			case "benchmarkStats": return await handleBenchmarkStats(request, this.benchmarkMetricReader);
+			case "benchmarkTrigger": return await handleBenchmarkTrigger(request, context, this.benchmarkTriggerOptions);
+		}
+		if (request.method !== "POST" && !acceptsJsonLd(request)) {
+			metricState.endpoint = "not_acceptable";
+			const response = await onNotAcceptable(request);
+			const collectionRoute = getCollectionMetricRoute(routeName);
+			if (collectionRoute != null) recordCollectionRequest(this._meterProvider, {
+				...collectionRoute,
+				page: url.searchParams.get("cursor") != null,
+				result: "not_acceptable",
+				statusCode: response.status
+			});
+			return response;
 		}
-		if (request.method !== "POST" && !acceptsJsonLd(request)) return await onNotAcceptable(request);
 		switch (routeName) {
 			case "actor":
-				context = this.#createContext(request, contextData, { invokedFromActorDispatcher: { identifier: route.values.identifier } });
+			case "actorAlias": {
+				const identifier = route.name.startsWith("actorAlias:") ? route.name.substring(ACTOR_ALIAS_PREFIX.length) : route.values.identifier;
+				context = this.#createContext(request, contextData, { invokedFromActorDispatcher: { identifier } });
 				return await handleActor(request, {
-					identifier: route.values.identifier,
+					identifier,
 					context,
 					actorDispatcher: this.actorCallbacks?.dispatcher,
 					authorizePredicate: this.actorCallbacks?.authorizePredicate,
 					onUnauthorized,
 					onNotFound
 				});
+			}
 			case "object": {
 				const typeId = route.name.replace(/^object:/, "");
 				const callbacks = this.objectCallbacks[typeId];
@@ -2533,6 +3711,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 					context,
 					collectionCallbacks: this.outboxCallbacks,
 					tracerProvider: this.tracerProvider,
+					meterProvider: this._meterProvider,
 					onUnauthorized,
 					onNotFound
 				});
@@ -2544,20 +3723,23 @@ var FederationImpl = class extends FederationBuilderImpl {
 					context,
 					collectionCallbacks: this.inboxCallbacks,
 					tracerProvider: this.tracerProvider,
+					meterProvider: this._meterProvider,
 					onUnauthorized,
 					onNotFound
 				});
 				context = this.#createContext(request, contextData, { documentLoader: await context.getDocumentLoader({ identifier: route.values.identifier }) });
-			case "sharedInbox":
+			case "sharedInbox": {
 				if (routeName !== "inbox" && this.sharedInboxKeyDispatcher != null) {
 					const identity = await this.sharedInboxKeyDispatcher(context);
 					if (identity != null) context = this.#createContext(request, contextData, { documentLoader: "identifier" in identity || "username" in identity ? await context.getDocumentLoader(identity) : context.getDocumentLoader(identity) });
 				}
 				if (!this.manuallyStartQueue) this._startQueueInternal(contextData);
+				const inboxContextFactory = context.toInboxContext.bind(context);
+				inboxContextFactory[rawInboxContextFactorySymbol] = context.toInboxContext.bind(context);
 				return await handleInbox(request, {
 					recipient: route.values.identifier ?? null,
 					context,
-					inboxContextFactory: context.toInboxContext.bind(context),
+					inboxContextFactory,
 					kv: this.kv,
 					kvPrefixes: this.kvPrefixes,
 					queue: this.inboxQueue,
@@ -2569,9 +3751,11 @@ var FederationImpl = class extends FederationBuilderImpl {
 					signatureTimeWindow: this.signatureTimeWindow,
 					skipSignatureVerification: this.skipSignatureVerification,
 					inboxChallengePolicy: this.inboxChallengePolicy,
+					meterProvider: this.meterProvider,
 					tracerProvider: this.tracerProvider,
 					idempotencyStrategy: this.idempotencyStrategy
 				});
+			}
 			case "following": return await handleCollection(request, {
 				name: "following",
 				identifier: route.values.identifier,
@@ -2579,6 +3763,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				context,
 				collectionCallbacks: this.followingCallbacks,
 				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
 				onUnauthorized,
 				onNotFound
 			});
@@ -2602,6 +3787,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 					filterPredicate: baseUrl != null ? ((i) => (i instanceof URL ? i.href : i.id?.href ?? "").startsWith(baseUrl)) : void 0,
 					collectionCallbacks: this.followersCallbacks,
 					tracerProvider: this.tracerProvider,
+					meterProvider: this._meterProvider,
 					onUnauthorized,
 					onNotFound
 				});
@@ -2613,6 +3799,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				context,
 				collectionCallbacks: this.likedCallbacks,
 				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
 				onUnauthorized,
 				onNotFound
 			});
@@ -2623,6 +3810,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				context,
 				collectionCallbacks: this.featuredCallbacks,
 				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
 				onUnauthorized,
 				onNotFound
 			});
@@ -2633,6 +3821,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				context,
 				collectionCallbacks: this.featuredTagsCallbacks,
 				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
 				onUnauthorized,
 				onNotFound
 			});
@@ -2645,6 +3834,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 					values: route.values,
 					collectionCallbacks: callbacks,
 					tracerProvider: this.tracerProvider,
+					meterProvider: this._meterProvider,
 					onUnauthorized,
 					onNotFound
 				});
@@ -2658,17 +3848,64 @@ var FederationImpl = class extends FederationBuilderImpl {
 					values: route.values,
 					collectionCallbacks: callbacks,
 					tracerProvider: this.tracerProvider,
+					meterProvider: this._meterProvider,
 					onUnauthorized,
 					onNotFound
 				});
 			}
 			default: {
+				metricState.endpoint = "not_found";
 				const response = onNotFound(request);
 				return response instanceof Promise ? await response : response;
 			}
 		}
 	}
 };
+function getEndpointCategory(routeName) {
+	if (routeName.startsWith("object:")) return "object";
+	if (routeName.startsWith("collection:") || routeName.startsWith("orderedCollection:")) return "collection";
+	if (routeName.startsWith("actorAlias:")) return "actor";
+	switch (routeName) {
+		case "webfinger": return "webfinger";
+		case "nodeInfoJrd":
+		case "nodeInfo": return "nodeinfo";
+		case "actor": return "actor";
+		case "inbox": return "inbox";
+		case "sharedInbox": return "shared_inbox";
+		case "outbox": return "outbox";
+		case "following": return "following";
+		case "followers": return "followers";
+		case "liked": return "liked";
+		case "featured": return "featured";
+		case "featuredTags": return "featured_tags";
+		case "benchmarkStats":
+		case "benchmarkTrigger": return "benchmark";
+		default: return "not_found";
+	}
+}
+function getCollectionMetricRoute(routeName) {
+	switch (routeName) {
+		case "inbox":
+		case "outbox":
+		case "following":
+		case "followers":
+		case "liked":
+		case "featured": return {
+			kind: routeName,
+			dispatcher: "built_in"
+		};
+		case "featuredTags": return {
+			kind: "featured_tags",
+			dispatcher: "built_in"
+		};
+		case "collection":
+		case "orderedCollection": return {
+			kind: "custom",
+			dispatcher: "custom"
+		};
+		default: return;
+	}
+}
 const FANOUT_THRESHOLD = 5;
 var ContextImpl = class ContextImpl {
 	url;
@@ -2730,13 +3967,16 @@ var ContextImpl = class ContextImpl {
 	get tracerProvider() {
 		return this.federation.tracerProvider;
 	}
+	get meterProvider() {
+		return this.federation.meterProvider;
+	}
 	getNodeInfoUri() {
 		const path = this.federation.router.build("nodeInfo", {});
 		if (path == null) throw new RouterError("No NodeInfo dispatcher registered.");
 		return new URL(path, this.canonicalOrigin);
 	}
 	getActorUri(identifier) {
-		const path = this.federation.router.build("actor", { identifier });
+		const path = this.federation.router.build(`actorAlias:${identifier}`, {}) ?? this.federation.router.build("actor", { identifier });
 		if (path == null) throw new RouterError("No actor dispatcher registered.");
 		return new URL(path, this.canonicalOrigin);
 	}
@@ -2802,8 +4042,8 @@ var ContextImpl = class ContextImpl {
 			type: "inbox",
 			identifier: void 0
 		};
-		const identifier = route.values.identifier;
-		if (route.name === "actor") return {
+		const identifier = route.name.startsWith("actorAlias:") ? route.name.substring(ACTOR_ALIAS_PREFIX.length) : route.values.identifier;
+		if (route.name === "actor" || route.name.startsWith("actorAlias:")) return {
 			type: "actor",
 			identifier
 		};
@@ -2969,6 +4209,7 @@ var ContextImpl = class ContextImpl {
 			contextLoader: options.contextLoader ?? this.contextLoader,
 			userAgent: options.userAgent ?? this.federation.userAgent,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider,
+			meterProvider: options.meterProvider ?? this.meterProvider,
 			allowPrivateAddress: this.federation.allowPrivateAddress
 		});
 	}
@@ -2995,6 +4236,7 @@ var ContextImpl = class ContextImpl {
 			...options,
 			userAgent: options.userAgent ?? this.federation.userAgent,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider,
+			meterProvider: options.meterProvider ?? this.federation._meterProvider,
 			allowPrivateAddress: this.federation.allowPrivateAddress
 		});
 	}
@@ -3151,6 +4393,12 @@ var ContextImpl = class ContextImpl {
 		};
 		if (!this.federation.manuallyStartQueue) this.federation._startQueueInternal(this.data);
 		await this.federation.fanoutQueue.enqueue(message, { orderingKey: options.orderingKey });
+		getFederationMetrics(this.federation.meterProvider).recordQueueTaskEnqueued({
+			role: "fanout",
+			queue: this.federation.fanoutQueue,
+			activityType: message.activityType
+		}, 0);
+		recordFanoutRecipients(this.federation.meterProvider, globalThis.Object.keys(message.inboxes).length, message.activityType);
 		return true;
 	}
 	async *getFollowers(identifier) {
@@ -3214,6 +4462,7 @@ var ContextImpl = class ContextImpl {
 		if (await verifyObject(Activity, json, {
 			contextLoader,
 			documentLoader: options.documentLoader ?? this.documentLoader,
+			meterProvider: this.meterProvider,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider,
 			keyCache
 		}) == null) {
@@ -3272,6 +4521,7 @@ var ContextImpl = class ContextImpl {
 		const routeResult = await routeActivity({
 			context: this,
 			json,
+			ldSignatureVerified: false,
 			activity,
 			recipient,
 			inboxListeners: this.federation.inboxListeners,
@@ -3281,6 +4531,7 @@ var ContextImpl = class ContextImpl {
 			kvPrefixes: this.federation.kvPrefixes,
 			queue: this.federation.inboxQueue,
 			span,
+			meterProvider: this.federation.meterProvider,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider,
 			idempotencyStrategy: this.federation.idempotencyStrategy
 		});
@@ -3355,6 +4606,7 @@ var RequestContextImpl = class RequestContextImpl extends ContextImpl {
 			contextLoader: options.contextLoader ?? this.contextLoader,
 			documentLoader: options.documentLoader ?? this.documentLoader,
 			timeWindow: this.federation.signatureTimeWindow,
+			meterProvider: this.meterProvider,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider
 		});
 	}
@@ -3479,6 +4731,7 @@ async function forwardActivityInternal(ctx, loggerCategory, forwarder, recipient
 			activityType: ctx.activityType,
 			inbox: new URL(inbox),
 			sharedInbox: inboxes[inbox].sharedInbox,
+			meterProvider: ctx.meterProvider,
 			tracerProvider: ctx.tracerProvider,
 			specDeterminer: new KvSpecDeterminer(ctx.federation.kv, ctx.federation.kvPrefixes.httpMessageSignaturesSpec, ctx.federation.firstKnock)
 		}));
@@ -3529,8 +4782,10 @@ async function forwardActivityInternal(ctx, loggerCategory, forwarder, recipient
 	}
 	const { outboxQueue } = ctx.federation;
 	if (outboxQueue.enqueueMany == null || orderingKey != null) {
-		const promises = messages.map((m) => outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey }));
-		const errors = (await Promise.allSettled(promises)).filter((r) => r.status === "rejected").map((r) => r.reason);
+		const errors = (await Promise.allSettled(messages.map(async (m) => {
+			await outboxQueue.enqueue(m.message, { orderingKey: m.orderingKey });
+			recordOutboxEnqueue(ctx.federation.meterProvider, outboxQueue, m.message);
+		}))).filter((r) => r.status === "rejected").map((r) => r.reason);
 		if (errors.length > 0) {
 			logger.error("Failed to enqueue activity {activityId} to forward later:\n{errors}", {
 				activityId: ctx.activityId,
@@ -3539,19 +4794,30 @@ async function forwardActivityInternal(ctx, loggerCategory, forwarder, recipient
 			if (errors.length > 1) throw new AggregateError(errors, `Failed to enqueue activity ${ctx.activityId} to forward later.`);
 			throw errors[0];
 		}
-	} else try {
-		await outboxQueue.enqueueMany(messages.map((m) => m.message));
-	} catch (error) {
-		logger.error("Failed to enqueue activity {activityId} to forward later:\n{error}", {
-			activityId: ctx.activityId,
-			error
-		});
-		throw error;
+	} else {
+		try {
+			await outboxQueue.enqueueMany(messages.map((m) => m.message));
+		} catch (error) {
+			logger.error("Failed to enqueue activity {activityId} to forward later:\n{error}", {
+				activityId: ctx.activityId,
+				error
+			});
+			throw error;
+		}
+		for (const m of messages) recordOutboxEnqueue(ctx.federation.meterProvider, outboxQueue, m.message);
 	}
 	return true;
 }
 var InboxContextImpl = class InboxContextImpl extends ContextImpl {
 	recipient;
+	/**
+	* The original received activity payload.
+	*
+	* Fedify may normalize a Linked Data Signature payload internally for safe
+	* parsing, but forwarding must keep the sender's payload unchanged so
+	* third-party signatures/proofs remain intact.
+	* @internal
+	*/
 	activity;
 	activityId;
 	activityType;
@@ -3684,4 +4950,4 @@ function getRequestId(request) {
 	return `req_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
 }
 //#endregion
-export { handleNodeInfoJrd as _, OutboxContextImpl as a, handleActor as c, handleInbox as d, handleObject as f, handleNodeInfo as g, respondWithObjectIfAcceptable as h, KvSpecDeterminer as i, handleCollection as l, respondWithObject as m, FederationImpl as n, createFederation as o, handleOutbox as p, InboxContextImpl as r, handleWebFinger as s, ContextImpl as t, handleCustomCollection as u, actorDehydrator as v, autoIdAssigner as y };
+export { handleNodeInfo as _, OutboxContextImpl as a, autoIdAssigner as b, handleActor as c, handleInbox as d, handleObject as f, handleBenchmarkTrigger as g, respondWithObjectIfAcceptable as h, KvSpecDeterminer as i, handleCollection as l, respondWithObject as m, FederationImpl as n, createFederation as o, handleOutbox as p, InboxContextImpl as r, handleWebFinger as s, ContextImpl as t, handleCustomCollection as u, handleNodeInfoJrd as v, actorDehydrator as y };