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

package/dist/{middleware-nidH7VZH.js → middleware-BgzRkDcm.js}

@@ -1,21 +1,22 @@
 import { Temporal } from "@js-temporal/polyfill";
-import "urlpattern-polyfill";
-import { t as __exportAll } from "./chunk-nlSIicah.js";
-import { r as getDefaultActivityTransformers } from "./transformers-ve6e2xcg.js";
-import { _ as version, a as verifyRequestDetailed, d as validateCryptoKey, f as formatAcceptSignature, g as name, i as verifyRequest, n as parseRfc9421SignatureInput, o as exportJwk, t as doubleKnock, u as importJwk } from "./http-B4rrzxtg.js";
-import { c as getKeyOwner, d as detachSignature, f as hasSignatureLike, i as verifyObject, m as verifyJsonLd, n as hasProofLike, o as normalizeOutgoingActivityJsonLd, p as signJsonLd, r as signObject, s as doesActorOwnKey } from "./proof-Bbbwf8_x.js";
-import { n as getNodeInfo, t as nodeInfoToJson } from "./types-hvL8ElAs.js";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-EMIqoIuB.js";
+import { URLPattern } from "urlpattern-polyfill";
+import { t as __exportAll } from "./chunk-CRNNMoPX.js";
+import { r as getDefaultActivityTransformers } from "./transformers-BGMIq1cs.js";
+import { A as formatAcceptSignature, D as recordOutboxEnqueue, E as recordOutboxActivity, F as version, O as recordWebFingerHandle, P as name, S as recordCollectionTotalItems, T as recordInboxActivity, a as verifyRequestDetailed, b as recordCollectionPageItems, d as validateCryptoKey, f as getDurationMs, g as isAbortError, h as instrumentDocumentLoader, i as verifyRequest, k as registerQueueDepthGauge, m as getRemoteHost, n as parseRfc9421SignatureInput, o as exportJwk, p as getFederationMetrics, t as doubleKnock, u as importJwk, v as recordCircuitBreakerStateChange, w as recordFanoutRecipients, x as recordCollectionRequest, y as recordCollectionDispatchDuration } from "./http-Dh18nwJg.js";
+import { _ as hasSignatureLike, b as signJsonLd, c as getKeyOwner, f as compactJsonLd, g as hasSignature, h as getNormalizationContextLoader, i as verifyObject, l as InvalidContextReferenceError, m as detachSignature, n as hasProofLike, o as normalizeOutgoingActivityJsonLd, r as signObject, s as doesActorOwnKey, u as assertSafeJsonLd, v as isClearlyMalformedContextReference, w as wrapContextLoaderForJsonLd, x as verifyCompactJsonLd, y as isInvalidUrlTypeError } from "./proof-CyXndf6-.js";
+import { n as getNodeInfo, t as nodeInfoToJson } from "./types-CAY3OdLq.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-DNDSb6Po.js";
 import { getLogger, withContext } from "@logtape/logtape";
+import { Router, RouterError, assertPath } 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 { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
-import { cloneDeep, uniq } from "es-toolkit";
-import { Router } from "uri-template-router";
-import { parseTemplate } from "url-template";
+import { SpanKind, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
 import { encodeHex } from "byte-encodings/hex";
+import { uniq } from "es-toolkit";
 import { FetchError, getDocumentLoader } from "@fedify/vocab-runtime";
 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 jsonld from "@fedify/vocab-runtime/jsonld";
 import { lookupWebFinger } from "@fedify/webfinger";
+import { DataPointType, MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
 import { domainToASCII } from "node:url";
 //#region src/federation/activity-listener.ts
 var ActivityListenerSet = class {
@@ -52,125 +53,33 @@ var ActivityListenerSet = class {
 	}
 };
 //#endregion
-//#region src/federation/router.ts
-function cloneInnerRouter(router) {
-	const clone = new Router();
-	clone.nid = router.nid;
-	clone.fsm = cloneDeep(router.fsm);
-	clone.routeSet = new Set(router.routeSet);
-	clone.templateRouteMap = new Map(router.templateRouteMap);
-	clone.valueRouteMap = new Map(router.valueRouteMap);
-	clone.hierarchy = cloneDeep(router.hierarchy);
-	return clone;
-}
+//#region src/federation/builder.ts
+const ACTOR_ALIAS_PREFIX = "actorAlias:";
 /**
-* URL router and constructor based on URI Template
-* ([RFC 6570](https://tools.ietf.org/html/rfc6570)).
+* Route options shared by every dispatcher whose path must expose exactly
+* one `{identifier}` variable bound to a single, non-empty value
+* for `setOutboxDispatcher/Listener()`.
 */
-var Router$1 = class Router$1 {
-	#router;
-	#templates;
-	#templateStrings;
-	/**
-	* Whether to ignore trailing slashes when matching paths.
-	* @since 1.6.0
-	*/
-	trailingSlashInsensitive;
-	/**
-	* Create a new {@link Router}.
-	* @param options Options for the router.
-	*/
-	constructor(options = {}) {
-		this.#router = new Router();
-		this.#templates = {};
-		this.#templateStrings = {};
-		this.trailingSlashInsensitive = options.trailingSlashInsensitive ?? false;
-	}
-	clone() {
-		const clone = new Router$1({ trailingSlashInsensitive: this.trailingSlashInsensitive });
-		clone.#router = cloneInnerRouter(this.#router);
-		clone.#templates = { ...this.#templates };
-		clone.#templateStrings = { ...this.#templateStrings };
-		return clone;
-	}
-	/**
-	* Checks if a path name exists in the router.
-	* @param name The name of the path.
-	* @returns `true` if the path name exists, otherwise `false`.
-	*/
-	has(name) {
-		return name in this.#templates;
-	}
-	/**
-	* Adds a new path rule to the router.
-	* @param template The path pattern.
-	* @param name The name of the path.
-	* @returns The names of the variables in the path pattern.
-	*/
-	add(template, name) {
-		if (!template.startsWith("/")) throw new RouterError("Path must start with a slash.");
-		const rule = this.#router.addTemplate(template, {}, name);
-		this.#templates[name] = parseTemplate(template);
-		this.#templateStrings[name] = template;
-		return new Set(rule.variables.map((v) => v.varname));
-	}
-	/**
-	* Resolves a path name and values from a URL, if any match.
-	* @param url The URL to resolve.
-	* @returns The name of the path and its values, if any match.  Otherwise,
-	*          `null`.
-	*/
-	route(url) {
-		let match = this.#router.resolveURI(url);
-		if (match == null) {
-			if (!this.trailingSlashInsensitive) return null;
-			url = url.endsWith("/") ? url.replace(/\/+$/, "") : `${url}/`;
-			match = this.#router.resolveURI(url);
-			if (match == null) return null;
-		}
-		return {
-			name: match.matchValue,
-			template: this.#templateStrings[match.matchValue],
-			values: match.params
-		};
-	}
-	/**
-	* Constructs a URL/path from a path name and values.
-	* @param name The name of the path.
-	* @param values The values to expand the path with.
-	* @returns The URL/path, if the name exists.  Otherwise, `null`.
-	*/
-	build(name, values) {
-		if (name in this.#templates) return this.#templates[name].expand(values);
-		return null;
-	}
+const identifierSingular = {
+	exact: true,
+	variables: { identifier: { operatables: [""] } }
 };
 /**
-* An error thrown by the {@link Router}.
+* Route options shared by every dispatcher whose path must expose
+* `{identifier}` and `{+identifier}` variables bound to the same single,
+* non-empty value for following setters:
+* - `setActorDispatcher()` (actor path)
+* - `setInboxDispatcher/Listener()` (inbox path)
+* - `setFollowingDispatcher()` (following path)
+* - `setFollowersDispatcher()` (followers path)
+* - `setLikedDispatcher()` (liked path)
+* - `setFeaturedDispatcher()` (featured path)
+* - `setFeaturedTagsDispatcher()` (featured tags path)
 */
-var RouterError = class extends Error {
-	/**
-	* Create a new {@link RouterError}.
-	* @param message The error message.
-	*/
-	constructor(message) {
-		super(message);
-		this.name = "RouterError";
-	}
+const identifierSingularAllowPlus = {
+	exact: true,
+	variables: { identifier: { operatables: ["", "+"] } }
 };
-//#endregion
-//#region src/federation/builder.ts
-function validateSingleIdentifierVariablePath(path, errorMessage) {
-	const operatorMatches = globalThis.Array.from(path.matchAll(/{([+#./;?&]?)([A-Za-z_][A-Za-z0-9_]*)}/g));
-	if (operatorMatches.length !== 1 || operatorMatches[0]?.[2] !== "identifier") throw new RouterError(errorMessage);
-	if (operatorMatches.some((match) => [
-		"?",
-		"&",
-		"#"
-	].includes(match[1]) && match[2] === "identifier")) throw new RouterError(errorMessage);
-	const variables = new Router$1().add(path, "outbox");
-	if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError(errorMessage);
-}
 var FederationBuilderImpl = class {
 	router;
 	actorCallbacks;
@@ -203,12 +112,19 @@ var FederationBuilderImpl = class {
 	*/
 	#symbolRegistry = /* @__PURE__ */ new Map();
 	constructor() {
-		this.router = new Router$1();
+		this.router = new Router();
 		this.objectCallbacks = {};
 		this.objectTypeIds = {};
 		this.collectionCallbacks = {};
 		this.collectionTypeIds = {};
 	}
+	/**
+	* Builds the federation object.
+	* @param options Parameters for initializing the federation object.
+	* @returns The federation object.
+	* @throws {TypeError} If benchmark mode and `meterProvider` are both
+	* specified.
+	*/
 	async build(options) {
 		const { FederationImpl } = await Promise.resolve().then(() => middleware_exports);
 		const f = new FederationImpl(options);
@@ -246,8 +162,8 @@ var FederationBuilderImpl = class {
 	}
 	setActorDispatcher(path, dispatcher) {
 		if (this.router.has("actor")) throw new RouterError("Actor dispatcher already set.");
-		const variables = this.router.add(path, "actor");
-		if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError("Path for actor dispatcher must have one variable: {identifier}");
+		assertPath(path);
+		this.router.add(path, "actor", identifierSingularAllowPlus);
 		const callbacks = { dispatcher: async (context, identifier) => {
 			const actor = await this._getTracer().startActiveSpan("activitypub.dispatch_actor", {
 				kind: SpanKind.SERVER,
@@ -346,6 +262,15 @@ var FederationBuilderImpl = class {
 				callbacks.aliasMapper = mapper;
 				return setters;
 			},
+			mapActorAlias: (path, identifier) => {
+				if (identifier === "") throw new RouterError("Identifier cannot be empty.");
+				if (this.router.has(`actorAlias:${identifier}`)) throw new RouterError(`Actor alias for "${identifier}" already set.`);
+				if (Router.variables(path).size > 0) throw new RouterError("Path for actor alias must have no variables.");
+				const existingRoute = this.router.route(path);
+				if (existingRoute != null) throw new RouterError(`Actor alias path "${path}" conflicts with existing route "${existingRoute.name}".`);
+				this.router.add(path, `${ACTOR_ALIAS_PREFIX}${identifier}`);
+				return setters;
+			},
 			authorize(predicate) {
 				callbacks.authorizePredicate = predicate;
 				return setters;
@@ -355,17 +280,25 @@ var FederationBuilderImpl = class {
 	}
 	setNodeInfoDispatcher(path, dispatcher) {
 		if (this.router.has("nodeInfo")) throw new RouterError("NodeInfo dispatcher already set.");
-		if (this.router.add(path, "nodeInfo").size !== 0) throw new RouterError("Path for NodeInfo dispatcher must have no variables.");
+		if (Router.variables(path).size !== 0) throw new RouterError("Path for NodeInfo dispatcher must have no variables.");
+		this.router.add(path, "nodeInfo");
 		this.nodeInfoDispatcher = dispatcher;
 	}
 	setWebFingerLinksDispatcher(dispatcher) {
 		this.webFingerLinksDispatcher = dispatcher;
 	}
+	/**
+	* The RFC 6570 template-literal `path` overloads were removed for
+	* type-checking efficiency, so the URI variable types can no longer be
+	* inferred from `path` (now typed as a plain `string`); to use them, specify
+	* the variable name through the `TParam` generic argument.
+	*/
 	setObjectDispatcher(cls, path, dispatcher) {
 		const routeName = `object:${cls.typeId.href}`;
 		if (this.router.has(routeName)) throw new RouterError(`Object dispatcher for ${cls.name} already set.`);
-		const variables = this.router.add(path, routeName);
-		if (variables.size < 1) throw new RouterError("Path for object dispatcher must have at least one variable.");
+		assertPath(path);
+		const variables = Router.variables(path);
+		this.router.add(path, routeName);
 		const callbacks = {
 			dispatcher: (ctx, values) => {
 				return this._getTracer().startActiveSpan("activitypub.dispatch_object", {
@@ -407,8 +340,8 @@ var FederationBuilderImpl = class {
 		if (this.router.has("inbox")) {
 			if (this.inboxPath !== path) throw new RouterError("Inbox dispatcher path must match inbox listener path.");
 		} else {
-			const variables = this.router.add(path, "inbox");
-			if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError("Path for inbox dispatcher must have one variable: {identifier}");
+			assertPath(path);
+			this.router.add(path, "inbox", identifierSingularAllowPlus);
 			this.inboxPath = path;
 		}
 		const callbacks = { dispatcher };
@@ -438,8 +371,8 @@ var FederationBuilderImpl = class {
 		if (this.router.has("outbox")) {
 			if (this.outboxPath !== path) throw new RouterError("Outbox dispatcher path must match outbox listener path.");
 		} else {
-			validateSingleIdentifierVariablePath(path, "Path for outbox dispatcher must have one variable: {identifier}");
-			this.router.add(path, "outbox");
+			assertPath(path);
+			this.router.add(path, "outbox", identifierSingular);
 			this.outboxPath = path;
 		}
 		const callbacks = { dispatcher };
@@ -469,8 +402,8 @@ var FederationBuilderImpl = class {
 		if (this.router.has("outbox")) {
 			if (this.outboxPath !== outboxPath) throw new RouterError("Outbox listener path must match outbox dispatcher path.");
 		} else {
-			validateSingleIdentifierVariablePath(outboxPath, "Path for outbox must have one variable: {identifier}");
-			this.router.add(outboxPath, "outbox");
+			assertPath(outboxPath);
+			this.router.add(outboxPath, "outbox", identifierSingular);
 			this.outboxPath = outboxPath;
 		}
 		const listeners = this.outboxListeners = new ActivityListenerSet();
@@ -492,8 +425,8 @@ var FederationBuilderImpl = class {
 	}
 	setFollowingDispatcher(path, dispatcher) {
 		if (this.router.has("following")) throw new RouterError("Following collection dispatcher already set.");
-		const variables = this.router.add(path, "following");
-		if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError("Path for following collection dispatcher must have one variable: {identifier}");
+		assertPath(path);
+		this.router.add(path, "following", identifierSingularAllowPlus);
 		const callbacks = { dispatcher };
 		this.followingCallbacks = callbacks;
 		const setters = {
@@ -518,8 +451,8 @@ var FederationBuilderImpl = class {
 	}
 	setFollowersDispatcher(path, dispatcher) {
 		if (this.router.has("followers")) throw new RouterError("Followers collection dispatcher already set.");
-		const variables = this.router.add(path, "followers");
-		if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError("Path for followers collection dispatcher must have one variable: {identifier}");
+		assertPath(path);
+		this.router.add(path, "followers", identifierSingularAllowPlus);
 		const callbacks = { dispatcher };
 		this.followersCallbacks = callbacks;
 		const setters = {
@@ -544,8 +477,8 @@ var FederationBuilderImpl = class {
 	}
 	setLikedDispatcher(path, dispatcher) {
 		if (this.router.has("liked")) throw new RouterError("Liked collection dispatcher already set.");
-		const variables = this.router.add(path, "liked");
-		if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError("Path for liked collection dispatcher must have one variable: {identifier}");
+		assertPath(path);
+		this.router.add(path, "liked", identifierSingularAllowPlus);
 		const callbacks = { dispatcher };
 		this.likedCallbacks = callbacks;
 		const setters = {
@@ -570,8 +503,8 @@ var FederationBuilderImpl = class {
 	}
 	setFeaturedDispatcher(path, dispatcher) {
 		if (this.router.has("featured")) throw new RouterError("Featured collection dispatcher already set.");
-		const variables = this.router.add(path, "featured");
-		if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError("Path for featured collection dispatcher must have one variable: {identifier}");
+		assertPath(path);
+		this.router.add(path, "featured", identifierSingularAllowPlus);
 		const callbacks = { dispatcher };
 		this.featuredCallbacks = callbacks;
 		const setters = {
@@ -596,8 +529,8 @@ var FederationBuilderImpl = class {
 	}
 	setFeaturedTagsDispatcher(path, dispatcher) {
 		if (this.router.has("featuredTags")) throw new RouterError("Featured tags collection dispatcher already set.");
-		const variables = this.router.add(path, "featuredTags");
-		if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError("Path for featured tags collection dispatcher must have one variable: {identifier}");
+		assertPath(path);
+		this.router.add(path, "featuredTags", identifierSingularAllowPlus);
 		const callbacks = { dispatcher };
 		this.featuredTagsCallbacks = callbacks;
 		const setters = {
@@ -625,12 +558,13 @@ var FederationBuilderImpl = class {
 		if (this.router.has("inbox")) {
 			if (this.inboxPath !== inboxPath) throw new RouterError("Inbox listener path must match inbox dispatcher path.");
 		} else {
-			const variables = this.router.add(inboxPath, "inbox");
-			if (variables.size !== 1 || !variables.has("identifier")) throw new RouterError("Path for inbox must have one variable: {identifier}");
+			assertPath(inboxPath);
+			this.router.add(inboxPath, "inbox", identifierSingularAllowPlus);
 			this.inboxPath = inboxPath;
 		}
 		if (sharedInboxPath != null) {
-			if (this.router.add(sharedInboxPath, "sharedInbox").size !== 0) throw new RouterError("Path for shared inbox must have no variables.");
+			if (Router.variables(sharedInboxPath).size !== 0) throw new RouterError("Path for shared inbox must have no variables.");
+			this.router.add(sharedInboxPath, "sharedInbox");
 		}
 		const listeners = this.inboxListeners = new ActivityListenerSet();
 		const setters = {
@@ -657,9 +591,21 @@ var FederationBuilderImpl = class {
 		};
 		return setters;
 	}
+	/**
+	* The RFC 6570 template-literal `path` overloads were removed for
+	* type-checking efficiency, so the URI variable types can no longer be
+	* inferred from `path` (now typed as a plain `string`); to use them, specify
+	* the variable name through the `TParam` generic argument.
+	*/
 	setCollectionDispatcher(name, itemType, path, dispatcher) {
 		return this.#setCustomCollectionDispatcher(name, "collection", itemType, path, dispatcher);
 	}
+	/**
+	* The RFC 6570 template-literal `path` overloads were removed for
+	* type-checking efficiency, so the URI variable types can no longer be
+	* inferred from `path` (now typed as a plain `string`); to use them, specify
+	* the variable name through the `TParam` generic argument.
+	*/
 	setOrderedCollectionDispatcher(name, itemType, path, dispatcher) {
 		return this.#setCustomCollectionDispatcher(name, "orderedCollection", itemType, path, dispatcher);
 	}
@@ -668,7 +614,9 @@ var FederationBuilderImpl = class {
 		const routeName = `${collectionType}:${this.#uniqueCollectionId(name)}`;
 		if (this.router.has(routeName)) throw new RouterError(`Collection dispatcher for ${strName} already set.`);
 		if (this.collectionCallbacks[name] != null) throw new RouterError(`Collection dispatcher for ${strName} already set.`);
-		if (this.router.add(path, routeName).size < 1) throw new RouterError("Path for collection dispatcher must have at least one variable.");
+		assertPath(path);
+		if (Router.variables(path).size < 1) throw new RouterError("Path for collection dispatcher must have at least one variable.");
+		this.router.add(path, routeName);
 		const callbacks = { dispatcher };
 		this.collectionCallbacks[name] = callbacks;
 		this.collectionTypeIds[name] = itemType;
@@ -730,6 +678,338 @@ function createFederationBuilder() {
 	return new FederationBuilderImpl();
 }
 //#endregion
+//#region src/federation/circuit-breaker.ts
+const MAX_CUSTOM_FAILURE_HISTORY = 100;
+/**
+* Tracks reachability state for remote outbox delivery hosts.
+* @since 2.3.0
+*/
+var CircuitBreaker = class {
+	#kv;
+	#prefix;
+	#options;
+	#now;
+	#stateChangeObserver;
+	constructor(options) {
+		this.#kv = options.kv;
+		this.#prefix = options.prefix;
+		this.#options = normalizeCircuitBreakerOptions(options.options ?? {});
+		this.#now = options.now ?? (() => Temporal.Now.instant());
+		this.#stateChangeObserver = options.stateChangeObserver;
+	}
+	get options() {
+		return this.#options;
+	}
+	capHeldDelay(heldSince, delay) {
+		const now = this.#now();
+		return now.until(this.#capHeldRetryAt(now, heldSince, now.add(delay)));
+	}
+	async beforeSend(remoteHost, message) {
+		const heldSince = parseHeldSince(message.circuitHeldSince);
+		const now = this.#now();
+		if (heldSince != null && Temporal.Instant.compare(heldSince.add(this.#options.heldActivityTtl), now) <= 0) return {
+			type: "drop",
+			heldSince
+		};
+		let lastConflictingState;
+		for (let attempt = 0; attempt < 10; attempt++) {
+			const oldState = await this.#get(remoteHost);
+			if (oldState == null || oldState.state === "closed") return {
+				type: "send",
+				probe: false
+			};
+			if (oldState.state === "half-open") {
+				const halfOpened = oldState.halfOpened == null ? void 0 : Temporal.Instant.from(oldState.halfOpened);
+				if (halfOpened != null) {
+					const staleAt = halfOpened.add(this.#options.recoveryDelay);
+					if (Temporal.Instant.compare(now, staleAt) < 0) {
+						const releaseAt = now.add(this.#options.releaseInterval);
+						const retryAt = Temporal.Instant.compare(releaseAt, staleAt) < 0 ? releaseAt : staleAt;
+						const cappedRetryAt = this.#capHeldRetryAt(now, heldSince, retryAt);
+						return {
+							type: "hold",
+							state: "half-open",
+							delay: now.until(cappedRetryAt),
+							heldSince: heldSince ?? now
+						};
+					}
+				}
+				const newState = {
+					...oldState,
+					state: "half-open",
+					halfOpened: now.toString()
+				};
+				if (await this.#replace(remoteHost, oldState, newState)) return {
+					type: "send",
+					probe: true
+				};
+				lastConflictingState = "half-open";
+				continue;
+			}
+			const probeAt = (oldState.opened == null ? now : Temporal.Instant.from(oldState.opened)).add(this.#options.recoveryDelay);
+			if (Temporal.Instant.compare(now, probeAt) < 0) {
+				const retryAt = this.#capHeldRetryAt(now, heldSince, probeAt);
+				return {
+					type: "hold",
+					state: "open",
+					delay: now.until(retryAt),
+					heldSince: heldSince ?? now
+				};
+			}
+			const newState = {
+				...oldState,
+				state: "half-open",
+				halfOpened: now.toString()
+			};
+			if (await this.#replace(remoteHost, oldState, newState)) {
+				await this.#notifyStateChange(remoteHost, "open", "half-open");
+				return {
+					type: "send",
+					probe: true,
+					stateChange: {
+						previousState: "open",
+						newState: "half-open"
+					}
+				};
+			}
+			lastConflictingState = "open";
+		}
+		if (lastConflictingState != null) {
+			const retryAt = this.#capHeldRetryAt(now, heldSince, now.add(this.#options.releaseInterval));
+			return {
+				type: "hold",
+				state: lastConflictingState,
+				delay: now.until(retryAt),
+				heldSince: heldSince ?? now
+			};
+		}
+		throw new Error(`Failed to update circuit breaker state for ${remoteHost}`);
+	}
+	async recordSuccess(remoteHost) {
+		for (let attempt = 0; attempt < 10; attempt++) {
+			const oldState = await this.#get(remoteHost);
+			if (oldState == null) return void 0;
+			if (await this.#replace(remoteHost, oldState, void 0)) {
+				if (oldState.state !== "closed") {
+					await this.#notifyStateChange(remoteHost, oldState.state, "closed");
+					return {
+						previousState: oldState.state,
+						newState: "closed"
+					};
+				}
+				return;
+			}
+		}
+		throw new Error(`Failed to update circuit breaker state for ${remoteHost}`);
+	}
+	async recordReachableFailure(remoteHost) {
+		return await this.recordSuccess(remoteHost);
+	}
+	async recordFailure(remoteHost) {
+		const now = this.#now();
+		for (let attempt = 0; attempt < 10; attempt++) {
+			const oldState = await this.#get(remoteHost);
+			if (oldState?.state === "open") return void 0;
+			const oldFailures = oldState?.failures.map(Temporal.Instant.from) ?? [];
+			const failures = this.#options.pruneFailures([...oldFailures, now], now);
+			let newState;
+			let transition;
+			if (oldState?.state === "half-open" || this.#options.failure(failures)) {
+				newState = {
+					state: "open",
+					failures: failures.map((t) => t.toString()),
+					opened: now.toString()
+				};
+				transition = [oldState?.state ?? "closed", "open"];
+			} else newState = {
+				state: "closed",
+				failures: failures.map((t) => t.toString())
+			};
+			if (await this.#replace(remoteHost, oldState, newState)) {
+				if (transition != null) {
+					await this.#notifyStateChange(remoteHost, transition[0], transition[1]);
+					return {
+						previousState: transition[0],
+						newState: transition[1]
+					};
+				}
+				return;
+			}
+		}
+		throw new Error(`Failed to update circuit breaker state for ${remoteHost}`);
+	}
+	async dropActivity(remoteHost, details) {
+		try {
+			await this.#options.onActivityDrop?.(remoteHost, details);
+		} catch (error) {
+			getLogger([
+				"fedify",
+				"federation",
+				"circuit"
+			]).error("An unexpected error occurred in circuit breaker activity drop handler:\n{error}", {
+				remoteHost,
+				error
+			});
+		}
+	}
+	async getState(remoteHost) {
+		return await this.#get(remoteHost);
+	}
+	#key(remoteHost) {
+		return [...this.#prefix, remoteHost];
+	}
+	#capHeldRetryAt(now, heldSince, retryAt) {
+		const expiresAt = (heldSince ?? now).add(this.#options.heldActivityTtl);
+		return Temporal.Instant.compare(expiresAt, retryAt) < 0 ? expiresAt : retryAt;
+	}
+	async #get(remoteHost) {
+		return parseCircuitBreakerKvState(await this.#kv.get(this.#key(remoteHost)));
+	}
+	async #replace(remoteHost, oldState, newState) {
+		const key = this.#key(remoteHost);
+		if (this.#kv.cas == null) {
+			if (newState == null) await this.#kv.delete(key);
+			else await this.#kv.set(key, newState);
+			return true;
+		}
+		return await this.#kv.cas(key, oldState, newState);
+	}
+	async #notifyStateChange(remoteHost, previousState, newState) {
+		try {
+			await this.#options.onStateChange?.(remoteHost, previousState, newState);
+		} catch (error) {
+			getLogger([
+				"fedify",
+				"federation",
+				"circuit"
+			]).error("An unexpected error occurred in circuit breaker state change handler:\n{error}", {
+				remoteHost,
+				previousState,
+				newState,
+				error
+			});
+		}
+		try {
+			await this.#stateChangeObserver?.(remoteHost, previousState, newState);
+		} catch (error) {
+			getLogger([
+				"fedify",
+				"federation",
+				"circuit"
+			]).error("An unexpected error occurred in circuit breaker state change observer:\n{error}", {
+				remoteHost,
+				previousState,
+				newState,
+				error
+			});
+		}
+	}
+};
+/**
+* Normalizes user-provided circuit breaker options into the internal policy
+* shape used while processing queued outbox deliveries.
+*
+* @param options The public circuit breaker options supplied to Fedify.
+* @returns The normalized failure predicate, failure pruning function,
+* duration values, and optional callbacks with defaults applied.
+* @throws {RangeError} If any configured duration is not positive.
+* @throws {TypeError} If `failureThreshold` is not a positive integer.
+*/
+function normalizeCircuitBreakerOptions(options) {
+	const recoveryDelay = toInstantDuration(options.recoveryDelay ?? { minutes: 30 });
+	const heldActivityTtl = toInstantDuration(options.heldActivityTtl ?? { hours: 168 });
+	const releaseInterval = toInstantDuration(options.releaseInterval ?? { seconds: 1 });
+	assertPositiveDuration(recoveryDelay, "recoveryDelay");
+	assertPositiveDuration(heldActivityTtl, "heldActivityTtl");
+	assertPositiveDuration(releaseInterval, "releaseInterval");
+	let failure;
+	let pruneFailures;
+	if (options.failure == null) {
+		const failureThreshold = options.failureThreshold ?? 5;
+		if (!Number.isInteger(failureThreshold) || failureThreshold <= 0) throw new TypeError("failureThreshold must be a positive integer.");
+		const failureWindow = toInstantDuration(options.failureWindow ?? { minutes: 10 });
+		assertPositiveDuration(failureWindow, "failureWindow");
+		pruneFailures = (timestamps, now) => {
+			const earliest = now.subtract(failureWindow);
+			return timestamps.filter((timestamp) => Temporal.Instant.compare(timestamp, earliest) >= 0).slice(-failureThreshold);
+		};
+		failure = (timestamps) => {
+			if (timestamps.length < failureThreshold) return false;
+			const first = timestamps[timestamps.length - failureThreshold];
+			const last = timestamps[timestamps.length - 1];
+			return Temporal.Duration.compare(first.until(last), failureWindow) <= 0;
+		};
+	} else {
+		failure = options.failure;
+		pruneFailures = (timestamps) => timestamps.slice(-MAX_CUSTOM_FAILURE_HISTORY);
+	}
+	return {
+		failure,
+		pruneFailures,
+		recoveryDelay,
+		heldActivityTtl,
+		releaseInterval,
+		onStateChange: options.onStateChange,
+		onActivityDrop: options.onActivityDrop
+	};
+}
+function toInstantDuration(duration) {
+	const parsed = Temporal.Duration.from(duration);
+	return Temporal.Duration.from({ milliseconds: Math.trunc(parsed.total({
+		unit: "millisecond",
+		relativeTo: Temporal.PlainDateTime.from("2026-01-01T00:00:00")
+	})) });
+}
+function assertPositiveDuration(duration, name) {
+	if (Temporal.Duration.compare(duration, { seconds: 0 }) <= 0) throw new RangeError(`${name} must be a positive duration.`);
+}
+function parseHeldSince(value) {
+	if (value == null) return void 0;
+	try {
+		return Temporal.Instant.from(value);
+	} catch (error) {
+		getLogger([
+			"fedify",
+			"federation",
+			"circuit"
+		]).warn("Invalid circuitHeldSince value in queued outbox message: {value}", {
+			value,
+			error
+		});
+		return;
+	}
+}
+/**
+* Parses a value loaded from the circuit breaker KV store.
+*
+* @param value The raw KV value to validate.
+* @returns A circuit breaker state when `value` has a recognized state and
+* valid instant strings, or `undefined` when the stored value is malformed.
+*/
+function parseCircuitBreakerKvState(value) {
+	const isInstantString = (v) => {
+		if (typeof v !== "string") return false;
+		try {
+			Temporal.Instant.from(v);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	if (typeof value !== "object" || value == null) return void 0;
+	const record = value;
+	if (record.state !== "closed" && record.state !== "open" && record.state !== "half-open") return;
+	if (!Array.isArray(record.failures) || !record.failures.every((failure) => isInstantString(failure))) return;
+	if (record.opened != null && !isInstantString(record.opened)) return;
+	if (record.halfOpened != null && !isInstantString(record.halfOpened)) return;
+	return {
+		state: record.state,
+		failures: record.failures,
+		...record.opened == null ? {} : { opened: record.opened },
+		...record.halfOpened == null ? {} : { halfOpened: record.halfOpened }
+	};
+}
+//#endregion
 //#region src/federation/collection.ts
 /**
 * Calculates the [partial follower collection digest][1].
@@ -770,7 +1050,7 @@ async function buildCollectionSynchronizationHeader(collectionId, actorIds) {
 }
 //#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",
@@ -807,6 +1087,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";
 		}
 	}
@@ -816,6 +1097,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);
@@ -827,7 +1109,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(),
@@ -846,6 +1130,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,
@@ -865,13 +1155,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);
@@ -893,9 +1191,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,
@@ -1000,6 +1300,35 @@ var KvKeyCache = class {
 };
 //#endregion
 //#region src/federation/negotiation.ts
+/*!
+* Adapted directly from negotiator at https://github.com/jshttp/negotiator/
+* which is licensed as follows:
+*
+* (The MIT License)
+*
+* Copyright (c) 2012-2014 Federico Romero
+* Copyright (c) 2012-2014 Isaac Z. Schlueter
+* Copyright (c) 2014-2015 Douglas Christopher Wilson
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* 'Software'), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
 function compareSpecs(a, b) {
 	return b.q - a.q || (b.s ?? 0) - (a.s ?? 0) || (a.o ?? 0) - (b.o ?? 0) || a.i - b.i || 0;
 }
@@ -1062,7 +1391,123 @@ function acceptsJsonLd(request) {
 	return types.includes("application/activity+json") || types.includes("application/ld+json") || types.includes("application/json");
 }
 //#endregion
+//#region src/federation/temporal.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function normalizeDateTimeLiteral(value) {
+	return value.substring(19).match(/[Z+-]/) ? value : value + "Z";
+}
+function isMalformedDateTimeLiteral(value) {
+	if (typeof value !== "string") return false;
+	try {
+		Temporal.Instant.from(normalizeDateTimeLiteral(value));
+		return false;
+	} catch {
+		return true;
+	}
+}
+function isMalformedDurationLiteral(value) {
+	if (typeof value !== "string") return false;
+	try {
+		Temporal.Duration.from(value);
+		return false;
+	} catch {
+		return true;
+	}
+}
+const TEMPORAL_DATE_TIME_IRIS = new Set([
+	"https://www.w3.org/ns/activitystreams#deleted",
+	"https://www.w3.org/ns/activitystreams#endTime",
+	"https://www.w3.org/ns/activitystreams#published",
+	"https://www.w3.org/ns/activitystreams#startTime",
+	"https://www.w3.org/ns/activitystreams#updated",
+	"http://purl.org/dc/terms/created",
+	"https://w3id.org/security#created"
+]);
+const TEMPORAL_DURATION_IRIS = new Set(["https://www.w3.org/ns/activitystreams#duration"]);
+const QUESTION_CLOSED_IRI = "https://www.w3.org/ns/activitystreams#closed";
+const XSD_DATE_TIME_IRI = "http://www.w3.org/2001/XMLSchema#dateTime";
+function hasMalformedExpandedDateTimeLiteral(value) {
+	if (Array.isArray(value)) return value.some(hasMalformedExpandedDateTimeLiteral);
+	return isPlainObject(value) && "@value" in value && isMalformedDateTimeLiteral(value["@value"]);
+}
+function hasMalformedExpandedQuestionClosedLiteral(value) {
+	if (Array.isArray(value)) return value.some(hasMalformedExpandedQuestionClosedLiteral);
+	if (!isPlainObject(value) || !("@value" in value)) return false;
+	const literal = value["@value"];
+	if (typeof literal === "boolean") return false;
+	if (typeof literal !== "string") return false;
+	if (value["@type"] !== XSD_DATE_TIME_IRI) return false;
+	if (new Date(literal).toString() === "Invalid Date") return false;
+	return isMalformedDateTimeLiteral(literal);
+}
+function hasMalformedExpandedDurationLiteral(value) {
+	if (Array.isArray(value)) return value.some(hasMalformedExpandedDurationLiteral);
+	return isPlainObject(value) && "@value" in value && isMalformedDurationLiteral(value["@value"]);
+}
+function hasMalformedKnownTemporalLiteralInternal(value, visited) {
+	if (Array.isArray(value)) return value.some((item) => hasMalformedKnownTemporalLiteralInternal(item, visited));
+	if (!isPlainObject(value)) return false;
+	if (visited.has(value)) return false;
+	visited.add(value);
+	if ("@value" in value) return false;
+	for (const [key, child] of Object.entries(value)) {
+		if (TEMPORAL_DATE_TIME_IRIS.has(key)) {
+			if (hasMalformedExpandedDateTimeLiteral(child)) return true;
+			continue;
+		}
+		if (key === QUESTION_CLOSED_IRI) {
+			if (hasMalformedExpandedQuestionClosedLiteral(child)) return true;
+			continue;
+		}
+		if (TEMPORAL_DURATION_IRIS.has(key)) {
+			if (hasMalformedExpandedDurationLiteral(child)) return true;
+			continue;
+		}
+		if (hasMalformedKnownTemporalLiteralInternal(child, visited)) return true;
+	}
+	return false;
+}
+async function hasMalformedKnownTemporalLiteral(value, contextLoader) {
+	try {
+		return hasMalformedKnownTemporalLiteralInternal(await jsonld.expand(value, {
+			documentLoader: getNormalizationContextLoader(contextLoader),
+			keepFreeFloatingNodes: true
+		}), /* @__PURE__ */ new Set());
+	} catch {
+		return false;
+	}
+}
+//#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.
@@ -1124,6 +1569,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.
@@ -1134,36 +1606,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)
@@ -1173,87 +1727,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);
-			}
-			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
+			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);
 			}
-		}, 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();
+			let next = null;
+			if (nextCursor != null) {
+				next = new URL(context.url);
+				next.searchParams.set("cursor", nextCursor);
 			}
-		});
-		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.
@@ -1517,7 +2028,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",
@@ -1589,28 +2100,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
-		});
-	} catch (error) {
-		if (error instanceof Error && error.name === "jsonld.SyntaxError") {
-			logger.error("Failed to parse JSON-LD:\n{error}", {
+	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
+		});
+		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) {
@@ -1618,7 +2206,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.", {
@@ -1627,12 +2224,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,
@@ -1677,10 +2284,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,
@@ -1755,7 +2366,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);
@@ -1767,6 +2386,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,
@@ -1784,6 +2405,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);
 		}
@@ -1791,15 +2413,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
 	});
@@ -1840,11 +2467,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.
@@ -1858,11 +2505,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.
@@ -1877,6 +2532,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}
@@ -1901,6 +2565,7 @@ var CustomCollectionHandler = class {
 	*/
 	#dispatcher;
 	#collection = null;
+	#pendingCollectionMetrics = [];
 	/**
 	* Creates a new CustomCollection instance.
 	* @param name The name of the collection.
@@ -1912,12 +2577,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;
@@ -1970,10 +2636,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)
 		};
@@ -1986,11 +2654,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
 		};
 	}
 	/**
@@ -2000,10 +2673,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
 		};
 	}
 	/**
@@ -2038,12 +2713,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,
@@ -2070,6 +2757,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.
@@ -2133,14 +2851,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;
 			}
 		}
 	};
@@ -2358,36 +3098,6 @@ function handleNodeInfoJrd(_request, context) {
 	return Promise.resolve(response);
 }
 //#endregion
-//#region src/federation/retry.ts
-/**
-* Creates an exponential backoff retry policy.  The delay between retries
-* starts at the `initialDelay` and is multiplied by the `factor` for each
-* subsequent retry, up to the `maxDelay`.  The policy will give up after
-* `maxAttempts` attempts.  The actual delay is randomized to avoid
-* synchronization (jitter).
-* @param options The options for the policy.
-* @returns The retry policy.
-* @since 0.12.0
-*/
-function createExponentialBackoffPolicy(options = {}) {
-	const initialDelay = Temporal.Duration.from(options.initialDelay ?? { seconds: 1 });
-	const maxDelay = Temporal.Duration.from(options.maxDelay ?? { hours: 12 });
-	const maxAttempts = options.maxAttempts ?? 10;
-	const factor = options.factor ?? 2;
-	const jitter = options.jitter ?? true;
-	return ({ attempts }) => {
-		if (attempts >= maxAttempts) return null;
-		let milliseconds = initialDelay.total("millisecond");
-		milliseconds *= factor ** attempts;
-		if (jitter) {
-			milliseconds *= 1 + Math.random();
-			milliseconds = Math.round(milliseconds);
-		}
-		const delay = Temporal.Duration.from({ milliseconds });
-		return Temporal.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
-	};
-}
-//#endregion
 //#region src/federation/send.ts
 /**
 * Extracts the inbox URLs from recipients.
@@ -2447,6 +3157,25 @@ function sendActivity(options) {
 	});
 }
 const MAX_ERROR_RESPONSE_BODY_BYTES = 1024;
+function getActivityActorId(activity) {
+	if (!isRecord(activity)) return void 0;
+	return getIdValue(activity.actor);
+}
+function getIdValue(value) {
+	if (typeof value === "string" && value !== "") return value;
+	if (value instanceof URL) return value.href;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const id = getIdValue(item);
+			if (id != null) return id;
+		}
+		return;
+	}
+	if (isRecord(value)) return getIdValue(value.id);
+}
+function isRecord(value) {
+	return typeof value === "object" && value != null;
+}
 async function readLimitedResponseBody(response, maxBytes) {
 	if (response.body == null) return "";
 	const reader = response.body.getReader();
@@ -2474,12 +3203,15 @@ async function readLimitedResponseBody(response, maxBytes) {
 	if (truncated) result += "… (truncated)";
 	return result;
 }
-async function sendActivityInternal({ activity, activityId, keys, inbox, headers, specDeterminer, tracerProvider }, span) {
+async function sendActivityInternal({ activity, activityId, activityType, keys, inbox, headers, specDeterminer, meterProvider, tracerProvider }, span) {
 	const logger = getLogger([
 		"fedify",
 		"federation",
 		"outbox"
 	]);
+	const federationMetrics = getFederationMetrics(meterProvider);
+	const started = performance.now();
+	let deliverySuccess = false;
 	headers = new Headers(headers);
 	headers.set("Content-Type", "application/activity+json");
 	const request = new Request(inbox, {
@@ -2506,34 +3238,49 @@ async function sendActivityInternal({ activity, activityId, keys, inbox, headers
 			specDeterminer
 		});
 	} catch (error) {
+		const transportError = error instanceof FetchError ? error : createFetchError(inbox.href, error);
 		logger.error("Failed to send activity {activityId} to {inbox}:\n{error}", {
 			activityId,
 			inbox: inbox.href,
-			error
+			error: transportError
 		});
-		throw error;
+		federationMetrics.recordDelivery(inbox, getDurationMs(started), false, activityType);
+		throw transportError;
 	}
-	if (!response.ok) {
-		let error;
-		try {
-			error = await readLimitedResponseBody(response, MAX_ERROR_RESPONSE_BODY_BYTES);
-		} catch (_) {
-			error = "";
+	try {
+		if (!response.ok) {
+			let error;
+			try {
+				error = await readLimitedResponseBody(response, MAX_ERROR_RESPONSE_BODY_BYTES);
+			} catch (_) {
+				error = "";
+			}
+			logger.error("Failed to send activity {activityId} to {inbox} ({status} {statusText}):\n{error}", {
+				activityId,
+				inbox: inbox.href,
+				status: response.status,
+				statusText: response.statusText,
+				error
+			});
+			throw new SendActivityError(inbox, response.status, `Failed to send activity ${activityId} to ${inbox.href} (${response.status} ${response.statusText}):\n${error}`, error, response.headers);
 		}
-		logger.error("Failed to send activity {activityId} to {inbox} ({status} {statusText}):\n{error}", {
-			activityId,
-			inbox: inbox.href,
-			status: response.status,
-			statusText: response.statusText,
-			error
-		});
-		throw new SendActivityError(inbox, response.status, `Failed to send activity ${activityId} to ${inbox.href} (${response.status} ${response.statusText}):\n${error}`, error);
+		deliverySuccess = true;
+		const eventAttributes = {
+			"activitypub.inbox.url": inbox.href,
+			"activitypub.activity.id": activityId ?? ""
+		};
+		if (activityType != null) eventAttributes["activitypub.activity.type"] = activityType;
+		const actorId = getActivityActorId(activity);
+		if (actorId != null) eventAttributes["activitypub.actor.id"] = actorId;
+		span.addEvent("activitypub.activity.sent", eventAttributes);
+	} finally {
+		federationMetrics.recordDelivery(inbox, getDurationMs(started), deliverySuccess, activityType);
 	}
-	span.addEvent("activitypub.activity.sent", {
-		"activitypub.activity.json": JSON.stringify(activity),
-		"activitypub.inbox.url": inbox.href,
-		"activitypub.activity.id": activityId ?? ""
-	});
+}
+function createFetchError(url, cause) {
+	const error = new FetchError(url, cause instanceof Error ? cause.message : String(cause));
+	error.cause = cause;
+	return error;
 }
 /**
 * An error that is thrown when an activity fails to send to a remote inbox.
@@ -2558,20 +3305,252 @@ var SendActivityError = class extends Error {
 	*/
 	responseBody;
 	/**
+	* The response headers from the inbox.
+	* @since 2.3.0
+	*/
+	responseHeaders;
+	/**
 	* Creates a new {@link SendActivityError}.
 	* @param inbox The inbox URL.
 	* @param statusCode The HTTP status code.
 	* @param message The error message.
 	* @param responseBody The response body.
+	* @param responseHeaders The response headers.
 	*/
-	constructor(inbox, statusCode, message, responseBody) {
+	constructor(inbox, statusCode, message, responseBody, responseHeaders) {
 		super(message);
 		this.name = "SendActivityError";
 		this.inbox = inbox;
 		this.statusCode = statusCode;
 		this.responseBody = responseBody;
+		this.responseHeaders = new Headers(responseHeaders);
+	}
+};
+//#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/retry.ts
+/**
+* Creates an exponential backoff retry policy.  The delay between retries
+* starts at the `initialDelay` and is multiplied by the `factor` for each
+* subsequent retry, up to the `maxDelay`.  The policy will give up after
+* `maxAttempts` attempts.  The actual delay is randomized to avoid
+* synchronization (jitter).
+* @param options The options for the policy.
+* @returns The retry policy.
+* @since 0.12.0
+*/
+function createExponentialBackoffPolicy(options = {}) {
+	const initialDelay = Temporal.Duration.from(options.initialDelay ?? { seconds: 1 });
+	const maxDelay = Temporal.Duration.from(options.maxDelay ?? { hours: 12 });
+	const maxAttempts = options.maxAttempts ?? 10;
+	const factor = options.factor ?? 2;
+	const jitter = options.jitter ?? true;
+	return ({ attempts }) => {
+		if (attempts >= maxAttempts) return null;
+		let milliseconds = initialDelay.total("millisecond");
+		milliseconds *= factor ** attempts;
+		if (jitter) {
+			milliseconds *= 1 + Math.random();
+			milliseconds = Math.round(milliseconds);
+		}
+		const delay = Temporal.Duration.from({ milliseconds });
+		return Temporal.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
+	};
+}
 //#endregion
 //#region src/federation/webfinger.ts
 const logger = getLogger([
@@ -2587,22 +3566,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) {
@@ -2718,10 +3747,124 @@ var middleware_exports = /* @__PURE__ */ __exportAll({
 	OutboxContextImpl: () => OutboxContextImpl,
 	createFederation: () => createFederation
 });
+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) {
@@ -2749,12 +3892,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"],
@@ -2762,6 +3930,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 			publicKey: ["_fedify", "publicKey"],
 			httpMessageSignaturesSpec: ["_fedify", "httpMessageSignaturesSpec"],
 			acceptSignatureNonce: ["_fedify", "acceptSignatureNonce"],
+			circuitBreaker: ["_fedify", "circuit"],
 			...options.kvPrefixes ?? {}
 		};
 		if (options.queue == null) {
@@ -2777,6 +3946,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;
@@ -2802,48 +3990,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);
@@ -2875,79 +4124,124 @@ var FederationImpl = class extends FederationBuilderImpl {
 	}
 	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 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) {
@@ -3009,29 +4303,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) {
@@ -3040,7 +4507,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
@@ -3049,18 +4521,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}", {
@@ -3069,37 +4535,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",
@@ -3112,68 +4603,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({
@@ -3184,34 +4644,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 = {}) {
@@ -3332,6 +4923,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);
@@ -3379,9 +4971,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,
@@ -3390,30 +4984,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: {
@@ -3437,10 +5025,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}`
@@ -3453,6 +5043,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]);
@@ -3478,13 +5072,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(/:.*$/, "");
@@ -3497,26 +5096,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(11) : 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];
@@ -3562,6 +5178,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 					context,
 					collectionCallbacks: this.outboxCallbacks,
 					tracerProvider: this.tracerProvider,
+					meterProvider: this._meterProvider,
 					onUnauthorized,
 					onNotFound
 				});
@@ -3573,20 +5190,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,
@@ -3598,9 +5218,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,
@@ -3608,6 +5230,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				context,
 				collectionCallbacks: this.followingCallbacks,
 				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
 				onUnauthorized,
 				onNotFound
 			});
@@ -3631,6 +5254,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
 				});
@@ -3642,6 +5266,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				context,
 				collectionCallbacks: this.likedCallbacks,
 				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
 				onUnauthorized,
 				onNotFound
 			});
@@ -3652,6 +5277,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				context,
 				collectionCallbacks: this.featuredCallbacks,
 				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
 				onUnauthorized,
 				onNotFound
 			});
@@ -3662,6 +5288,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				context,
 				collectionCallbacks: this.featuredTagsCallbacks,
 				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
 				onUnauthorized,
 				onNotFound
 			});
@@ -3674,6 +5301,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 					values: route.values,
 					collectionCallbacks: callbacks,
 					tracerProvider: this.tracerProvider,
+					meterProvider: this._meterProvider,
 					onUnauthorized,
 					onNotFound
 				});
@@ -3687,17 +5315,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;
@@ -3759,13 +5434,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);
 	}
@@ -3831,8 +5509,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(11) : route.values.identifier;
+		if (route.name === "actor" || route.name.startsWith("actorAlias:")) return {
 			type: "actor",
 			identifier
 		};
@@ -3998,6 +5676,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
 		});
 	}
@@ -4024,6 +5703,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
 		});
 	}
@@ -4180,6 +5860,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) {
@@ -4243,6 +5929,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) {
@@ -4301,6 +5988,7 @@ var ContextImpl = class ContextImpl {
 		const routeResult = await routeActivity({
 			context: this,
 			json,
+			ldSignatureVerified: false,
 			activity,
 			recipient,
 			inboxListeners: this.federation.inboxListeners,
@@ -4310,6 +5998,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
 		});
@@ -4384,6 +6073,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
 		});
 	}
@@ -4508,6 +6198,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)
 		}));
@@ -4558,8 +6249,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,
@@ -4568,19 +6261,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;
@@ -4713,4 +6417,4 @@ function getRequestId(request) {
 	return `req_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
 }
 //#endregion
-export { createExponentialBackoffPolicy as a, buildCollectionSynchronizationHeader as c, Router$1 as d, RouterError as f, SendActivityError as i, digest as l, middleware_exports as n, respondWithObject as o, handleWebFinger as r, respondWithObjectIfAcceptable as s, createFederation as t, createFederationBuilder as u };
+export { SendActivityError as a, buildCollectionSynchronizationHeader as c, normalizeCircuitBreakerOptions as d, parseCircuitBreakerKvState as f, createExponentialBackoffPolicy as i, digest as l, middleware_exports as n, respondWithObject as o, createFederationBuilder as p, handleWebFinger as r, respondWithObjectIfAcceptable as s, createFederation as t, CircuitBreaker as u };