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

package/dist/federation/middleware.test.mjs

@@ -1,30 +1,34 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as esm_default } from "../esm-DVILvP5e.mjs";
-import { n as RouterError } from "../router-CrMLXoOr.mjs";
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-CRDpx_HF.mjs";
-import { n as assertFalse, t as assertRejects } from "../assert_rejects-B-qJtC9Z.mjs";
-import { t as assertInstanceOf } from "../assert_instance_of-C4Ri6VuN.mjs";
-import { t as assertThrows } from "../assert_throws-4NwKEy2q.mjs";
-import { t as assertNotEquals } from "../assert_not_equals--wG9hV7u.mjs";
-import { t as assertStrictEquals } from "../assert_strict_equals-Dmjbg-bA.mjs";
-import { t as assert } from "../assert-DikXweDx.mjs";
-import { l as verifyRequest, s as signRequest } from "../http-CSlLA54v.mjs";
+import { t as esm_default } from "../esm-vrlUxr60.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import { r as assertExists } from "../std__assert-BBjXFNOb.mjs";
+import { r as assertFalse, t as assertRejects } from "../assert_rejects-DN60FHPX.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-DBC5X09g.mjs";
+import { t as assertThrows } from "../assert_throws-BOkhLGYc.mjs";
+import { t as assertNotEquals } from "../assert_not_equals-DkVK8oqV.mjs";
+import { t as assertStrictEquals } from "../assert_strict_equals-XEgZAlrj.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
+import { g as recordInboxActivity } from "../metrics-BHeWd24f.mjs";
+import { l as verifyRequest, s as signRequest } from "../http-BufbkLuW.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DGu1NFwu.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-DPp-X6gk.mjs";
-import { a as signJsonLd, o as verifyJsonLd, r as detachSignature } from "../ld-DR78beiv.mjs";
-import { t as doesActorOwnKey } from "../owner-C-tqfvxn.mjs";
-import { i as verifyObject, r as signObject } from "../proof-BlmRPzrK.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-B7mVwA5_.mjs";
+import { a as compactJsonLd, h as verifyJsonLd, p as signJsonLd, s as detachSignature } from "../ld-0Lsznacf.mjs";
+import { t as doesActorOwnKey } from "../owner-Cl-1cAR8.mjs";
+import { i as verifyObject, r as signObject } from "../proof-Dnz8jtiQ.mjs";
 import { t as MemoryKvStore } from "../kv-rV3vodCc.mjs";
-import { i as KvSpecDeterminer, n as FederationImpl, o as createFederation, r as InboxContextImpl, t as ContextImpl } from "../middleware-K1g6bEkV.mjs";
-import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
+import { g as handleBenchmarkTrigger, i as KvSpecDeterminer, n as FederationImpl, o as createFederation, r as InboxContextImpl, t as ContextImpl } from "../middleware-EV6J_eAc.mjs";
+import { t as CircuitBreaker } from "../circuit-breaker-CSWsyoef.mjs";
+import { configure, reset } from "@logtape/logtape";
+import { RouterError } from "@fedify/uri-template";
 import * as vocab from "@fedify/vocab";
-import { getTypeId, lookupObject } from "@fedify/vocab";
+import { Create, Offer, Person, getTypeId, lookupObject } from "@fedify/vocab";
+import { SpanStatusCode, metrics } from "@opentelemetry/api";
+import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, getDocumentLoader } from "@fedify/vocab-runtime";
-import { configure, reset } from "@logtape/logtape";
 import serialize from "json-canon";
+import { DataPointType, MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
 //#region ../fixture/src/fixtures/example.com/create.json
 var id$2 = "https://example.com/create";
 var create_default = {
@@ -96,6 +100,14 @@ async function withLogtapeLock(fn) {
 	logtapeLock = run.then(() => void 0, () => void 0);
 	return await run;
 }
+var TestMetricReader = class extends MetricReader {
+	onShutdown() {
+		return Promise.resolve();
+	}
+	onForceFlush() {
+		return Promise.resolve();
+	}
+};
 test("createFederation()", async (t) => {
 	const kv = new MemoryKvStore();
 	await t.step("allowPrivateAddress", () => {
@@ -110,6 +122,104 @@ test("createFederation()", async (t) => {
 			allowPrivateAddress: true
 		}), TypeError);
 	});
+	await t.step("benchmarkMode applies cooperative benchmark defaults", () => {
+		const federation = createFederation({
+			kv,
+			benchmarkMode: true
+		});
+		assertInstanceOf(federation, FederationImpl);
+		assertEquals(federation.allowPrivateAddress, true);
+		assertEquals(federation.signatureTimeWindow, false);
+	});
+	await t.step("benchmarkMode preserves explicit option overrides", () => {
+		const federation = createFederation({
+			kv,
+			benchmarkMode: true,
+			allowPrivateAddress: false,
+			signatureTimeWindow: { minutes: 10 }
+		});
+		assertInstanceOf(federation, FederationImpl);
+		assertEquals(federation.allowPrivateAddress, false);
+		assertEquals(federation.signatureTimeWindow, { minutes: 10 });
+	});
+	await t.step("benchmarkMode tolerates calendar time windows", () => {
+		const federation = createFederation({
+			kv,
+			benchmarkMode: true,
+			signatureTimeWindow: { months: 1 }
+		});
+		assertInstanceOf(federation, FederationImpl);
+		assertEquals(federation.signatureTimeWindow, { months: 1 });
+	});
+	await t.step("benchmarkMode leaves custom loader factories alone", () => {
+		const federation = createFederation({
+			kv,
+			benchmarkMode: true,
+			documentLoaderFactory: () => mockDocumentLoader,
+			contextLoaderFactory: () => mockDocumentLoader,
+			authenticatedDocumentLoaderFactory: () => mockDocumentLoader
+		});
+		assertInstanceOf(federation, FederationImpl);
+		assertEquals(federation.allowPrivateAddress, false);
+	});
+	await t.step("benchmarkMode keeps private-address default with auth loader only", () => {
+		const federation = createFederation({
+			kv,
+			benchmarkMode: true,
+			authenticatedDocumentLoaderFactory: () => mockDocumentLoader
+		});
+		assertInstanceOf(federation, FederationImpl);
+		assertEquals(federation.allowPrivateAddress, true);
+	});
+	await t.step("benchmarkMode rejects an explicit meterProvider", () => {
+		const [meterProvider] = createTestMeterProvider();
+		assertThrows(() => createFederation({
+			kv,
+			benchmarkMode: true,
+			meterProvider
+		}), TypeError, "benchmarkMode requires Fedify to own the meterProvider");
+	});
+	await t.step("benchmarkMode warns that benchmark-only relaxations are on", async () => {
+		await withLogtapeLock(async () => {
+			const records = [];
+			await reset();
+			try {
+				await configure({
+					sinks: { test(record) {
+						records.push(record);
+					} },
+					loggers: [{
+						category: [
+							"fedify",
+							"federation",
+							"benchmark"
+						],
+						lowestLevel: "warning",
+						sinks: ["test"]
+					}]
+				});
+				createFederation({
+					kv,
+					benchmarkMode: true
+				});
+				assertEquals(records.length, 1);
+				assertEquals(records[0].level, "warning");
+				assertEquals(records[0].rawMessage, "Fedify benchmarkMode is enabled; private address checks disabled (allowPrivateAddress=true); HTTP Signature time window disabled (signatureTimeWindow=false). Benchmark endpoints are active and must not be used in production.");
+				assertEquals(records[0].properties.relaxations, [{
+					protection: "private_address_checks",
+					effect: "disabled",
+					effectiveValue: true
+				}, {
+					protection: "http_signature_time_window",
+					effect: "disabled",
+					effectiveValue: false,
+					secureDefaultSeconds: 3600
+				}]);
+			} finally {
+				await reset();
+			}
+		});
+	});
 	await t.step("origin", () => {
 		const f = createFederation({
 			kv,
@@ -203,6 +313,319 @@ test("createFederation()", async (t) => {
 		}), TypeError);
 	});
 });
+test("benchmarkMode stats endpoint", async (t) => {
+	await t.step("is absent when benchmarkMode is off", async () => {
+		assertEquals((await createFederation({ kv: new MemoryKvStore() }).fetch(new Request("https://example.com/.well-known/fedify/bench/stats"), { contextData: void 0 })).status, 404);
+	});
+	await t.step("returns a v1 in-process metrics snapshot", async () => {
+		const federation = createFederation({
+			kv: new MemoryKvStore(),
+			benchmarkMode: true,
+			queue: {
+				enqueue() {
+					return Promise.resolve();
+				},
+				listen() {
+					return Promise.resolve();
+				},
+				getDepth() {
+					return Promise.resolve({
+						queued: 3,
+						ready: 2,
+						delayed: 1
+					});
+				}
+			}
+		});
+		recordInboxActivity(federation.meterProvider, "processed", vocab.Create.typeId.href);
+		const response = await federation.fetch(new Request("https://example.com/.well-known/fedify/bench/stats"), { contextData: void 0 });
+		assertEquals(response.status, 200);
+		assertEquals(response.headers.get("Content-Type"), "application/json");
+		const body = await response.json();
+		assertEquals(body.version, 1);
+		assertEquals(body.source, "server");
+		assertEquals(Number.isNaN(Date.parse(body.generatedAt)), false);
+		const metrics = body.scopeMetrics.flatMap((scope) => scope.metrics);
+		assertExists(metrics.find((metric) => metric.name === "activitypub.inbox.activity"));
+		const queueDepth = metrics.find((metric) => metric.name === "fedify.queue.depth");
+		assertExists(queueDepth);
+		assertEquals(queueDepth.dataPointType, "gauge");
+		assertEquals(queueDepth.dataPoints.map((point) => ({
+			state: point.attributes["fedify.queue.depth.state"],
+			role: point.attributes["fedify.queue.role"],
+			value: point.value
+		})).sort((a, b) => String(a.state).localeCompare(String(b.state))), [
+			{
+				state: "delayed",
+				role: "shared",
+				value: 1
+			},
+			{
+				state: "queued",
+				role: "shared",
+				value: 3
+			},
+			{
+				state: "ready",
+				role: "shared",
+				value: 2
+			}
+		]);
+	});
+});
+test("createFederation() registers queue depth for regular metrics", async () => {
+	const reader = new TestMetricReader();
+	const meterProvider = new MeterProvider$1({ readers: [reader] });
+	try {
+		createFederation({
+			kv: new MemoryKvStore(),
+			meterProvider,
+			queue: {
+				enqueue() {
+					return Promise.resolve();
+				},
+				listen() {
+					return Promise.resolve();
+				},
+				getDepth() {
+					return Promise.resolve({
+						queued: 5,
+						ready: 4,
+						delayed: 3
+					});
+				}
+			}
+		});
+		const queueDepth = (await reader.collect()).resourceMetrics.scopeMetrics.flatMap((scope) => scope.metrics).find((metric) => metric.descriptor.name === "fedify.queue.depth");
+		assertExists(queueDepth);
+		assertEquals(queueDepth.dataPointType, DataPointType.GAUGE);
+		assertEquals(queueDepth.dataPoints.map((point) => ({
+			state: point.attributes["fedify.queue.depth.state"],
+			role: point.attributes["fedify.queue.role"],
+			value: point.value
+		})).sort((a, b) => String(a.state).localeCompare(String(b.state))), [
+			{
+				state: "delayed",
+				role: "shared",
+				value: 3
+			},
+			{
+				state: "queued",
+				role: "shared",
+				value: 5
+			},
+			{
+				state: "ready",
+				role: "shared",
+				value: 4
+			}
+		]);
+	} finally {
+		await meterProvider.shutdown();
+	}
+});
+test("createFederation() registers queue depth after global meterProvider is set", async () => {
+	metrics.disable();
+	const federation = createFederation({
+		kv: new MemoryKvStore(),
+		queue: {
+			enqueue() {
+				return Promise.resolve();
+			},
+			listen() {
+				return Promise.resolve();
+			},
+			getDepth() {
+				return Promise.resolve({ queued: 8 });
+			}
+		}
+	});
+	const reader = new TestMetricReader();
+	const meterProvider = new MeterProvider$1({ readers: [reader] });
+	try {
+		metrics.setGlobalMeterProvider(meterProvider);
+		federation.meterProvider;
+		const queueDepth = (await reader.collect()).resourceMetrics.scopeMetrics.flatMap((scope) => scope.metrics).find((metric) => metric.descriptor.name === "fedify.queue.depth");
+		assertExists(queueDepth);
+		assertEquals(queueDepth.dataPointType, DataPointType.GAUGE);
+		assertEquals(queueDepth.dataPoints.map((point) => ({
+			state: point.attributes["fedify.queue.depth.state"],
+			role: point.attributes["fedify.queue.role"],
+			value: point.value
+		})), [{
+			state: "queued",
+			role: "shared",
+			value: 8
+		}]);
+	} finally {
+		metrics.disable();
+		await meterProvider.shutdown();
+	}
+});
+test("createFederation() distinguishes queue depth series per federation", async () => {
+	const reader = new TestMetricReader();
+	const meterProvider = new MeterProvider$1({ readers: [reader] });
+	try {
+		const createQueue = (queued) => ({
+			enqueue() {
+				return Promise.resolve();
+			},
+			listen() {
+				return Promise.resolve();
+			},
+			getDepth() {
+				return Promise.resolve({ queued });
+			}
+		});
+		createFederation({
+			kv: new MemoryKvStore(),
+			meterProvider,
+			queue: createQueue(1)
+		});
+		createFederation({
+			kv: new MemoryKvStore(),
+			meterProvider,
+			queue: createQueue(2)
+		});
+		const queueDepth = (await reader.collect()).resourceMetrics.scopeMetrics.flatMap((scope) => scope.metrics).find((metric) => metric.descriptor.name === "fedify.queue.depth");
+		assertExists(queueDepth);
+		const queuedPoints = queueDepth.dataPoints.filter((point) => point.attributes["fedify.queue.depth.state"] === "queued");
+		assertEquals(queuedPoints.map((point) => point.value).sort(), [1, 2]);
+		const instanceIds = queuedPoints.map((point) => point.attributes["fedify.federation.instance_id"]);
+		assertEquals(instanceIds.every((id) => typeof id === "string"), true);
+		assertEquals(new Set(instanceIds).size, 2);
+	} finally {
+		await meterProvider.shutdown();
+	}
+});
+test("benchmarkMode trigger endpoint", async (t) => {
+	const createTriggerTarget = (options = {}) => {
+		const messages = [];
+		const federation = createFederation({
+			kv: new MemoryKvStore(),
+			benchmarkMode: {
+				triggerSinks: ["https://sink.example/inbox"],
+				allowUnsafeTriggerRecipients: options.allowUnsafeTriggerRecipients
+			},
+			contextLoaderFactory: () => mockDocumentLoader,
+			queue: { outbox: {
+				enqueue(message) {
+					messages.push(message);
+					return Promise.resolve();
+				},
+				listen() {
+					return Promise.resolve();
+				}
+			} }
+		});
+		federation.setActorDispatcher("/users/{identifier}", (ctx, identifier) => new vocab.Person({
+			id: ctx.getActorUri(identifier),
+			inbox: ctx.getInboxUri(identifier)
+		})).setKeyPairsDispatcher(() => [{
+			privateKey: rsaPrivateKey2,
+			publicKey: rsaPublicKey2.publicKey
+		}]);
+		return {
+			federation,
+			messages
+		};
+	};
+	const createTriggerBody = async (options = {}) => ({
+		sender: { identifier: "alice" },
+		sinks: options.sinks,
+		recipients: options.recipients ?? [{
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Service",
+			id: "https://sink.example/actors/bob",
+			inbox: options.recipientInbox ?? "https://sink.example/inbox"
+		}],
+		activity: await new vocab.Create({
+			id: new URL("https://example.com/activities/bench-1"),
+			actor: new URL("https://example.com/users/alice"),
+			object: new vocab.Note({
+				id: new URL("https://example.com/notes/bench-1"),
+				attribution: new URL("https://example.com/users/alice"),
+				content: "benchmark"
+			})
+		}).toJsonLd({ contextLoader: mockDocumentLoader }),
+		allowUnsafeRecipients: options.allowUnsafeRecipients
+	});
+	await t.step("is absent when benchmarkMode is off", async () => {
+		assertEquals((await createFederation({ kv: new MemoryKvStore() }).fetch(new Request("https://example.com/.well-known/fedify/bench/trigger", { method: "POST" }), { contextData: void 0 })).status, 404);
+	});
+	await t.step("rejects unreadable JSON request bodies", async () => {
+		const response = await handleBenchmarkTrigger({
+			method: "POST",
+			json() {
+				throw new TypeError("body is unavailable");
+			}
+		}, {});
+		assertEquals(response.status, 400);
+		assertEquals(await response.json(), { error: "Invalid JSON request body." });
+	});
+	await t.step("rejects empty recipient lists", async () => {
+		const { federation, messages } = createTriggerTarget();
+		const response = await federation.fetch(new Request("https://example.com/.well-known/fedify/bench/trigger", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(await createTriggerBody({ recipients: [] }))
+		}), { contextData: void 0 });
+		assertEquals(response.status, 400);
+		assertEquals(await response.json(), { error: "No valid recipient inboxes found. The recipients list must not be empty." });
+		assertEquals(messages, []);
+	});
+	await t.step("rejects recipients outside configured trigger sinks", async () => {
+		const { federation, messages } = createTriggerTarget();
+		assertEquals((await federation.fetch(new Request("https://example.com/.well-known/fedify/bench/trigger", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(await createTriggerBody({ recipientInbox: "https://not-a-sink.example/inbox" }))
+		}), { contextData: void 0 })).status, 403);
+		assertEquals(messages, []);
+	});
+	await t.step("does not trust request-provided trigger sinks or bypasses", async () => {
+		const { federation, messages } = createTriggerTarget();
+		assertEquals((await federation.fetch(new Request("https://example.com/.well-known/fedify/bench/trigger", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(await createTriggerBody({
+				recipientInbox: "https://not-a-sink.example/inbox",
+				sinks: ["https://not-a-sink.example/inbox"],
+				allowUnsafeRecipients: true
+			}))
+		}), { contextData: void 0 })).status, 403);
+		assertEquals(messages, []);
+	});
+	await t.step("allows unsafe recipients only with a server override", async () => {
+		const { federation, messages } = createTriggerTarget({ allowUnsafeTriggerRecipients: true });
+		assertEquals((await federation.fetch(new Request("https://example.com/.well-known/fedify/bench/trigger", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(await createTriggerBody({ recipientInbox: "https://not-a-sink.example/inbox" }))
+		}), { contextData: void 0 })).status, 202);
+		assertEquals(messages.length, 1);
+		assertEquals(messages[0].inbox, "https://not-a-sink.example/inbox");
+	});
+	await t.step("sends the activity to explicit sink recipients", async () => {
+		const { federation, messages } = createTriggerTarget();
+		const response = await federation.fetch(new Request("https://example.com/.well-known/fedify/bench/trigger", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(await createTriggerBody())
+		}), { contextData: void 0 });
+		assertEquals(response.status, 202);
+		const body = await response.json();
+		assertEquals(body.version, 1);
+		assertEquals(body.activityId, "https://example.com/activities/bench-1");
+		assertEquals(body.queueCorrelationId, "https://example.com/activities/bench-1");
+		assertEquals(body.recipientCount, 1);
+		assertEquals(body.inboxCount, 1);
+		assertEquals(messages.length, 1);
+		assertEquals(messages[0].type, "outbox");
+		assertEquals(messages[0].activityId, body.queueCorrelationId);
+		assertEquals(messages[0].inbox, "https://sink.example/inbox");
+	});
+});
 test({
 	name: "Federation.createContext()",
 	permissions: {
@@ -270,7 +693,8 @@ test({
 			}));
 			ctx = federation.createContext(new URL("https://example.com/"), 123);
 			assertEquals(ctx.getNodeInfoUri(), new URL("https://example.com/nodeinfo/2.1"));
-			federation.setActorDispatcher("/users/{identifier}", () => new vocab.Person({})).setKeyPairsDispatcher(() => [{
+			assertThrows(() => createFederation({ kv: new MemoryKvStore() }).setActorDispatcher("/users/{identifier}", () => null).mapActorAlias("/actor/{id}", "instance"), RouterError, "Path for actor alias must have no variables.");
+			federation.setActorDispatcher("/users/{identifier}", () => new vocab.Person({})).mapActorAlias("/bot", "bot").setKeyPairsDispatcher(() => [{
 				privateKey: rsaPrivateKey2,
 				publicKey: rsaPublicKey2.publicKey
 			}, {
@@ -279,11 +703,16 @@ test({
 			}]).mapHandle((_, username) => username === "HANDLE" ? "handle" : null);
 			ctx = federation.createContext(new URL("https://example.com/"), 123);
 			assertEquals(ctx.getActorUri("handle"), new URL("https://example.com/users/handle"));
+			assertEquals(ctx.getActorUri("bot"), new URL("https://example.com/bot"));
 			assertEquals(ctx.parseUri(new URL("https://example.com/")), null);
 			assertEquals(ctx.parseUri(new URL("https://example.com/users/handle")), {
 				type: "actor",
 				identifier: "handle"
 			});
+			assertEquals(ctx.parseUri(new URL("https://example.com/bot")), {
+				type: "actor",
+				identifier: "bot"
+			});
 			assertEquals(ctx.parseUri(null), null);
 			assertEquals(await ctx.getActorKeyPairs("handle"), [{
 				keyId: new URL("https://example.com/users/handle#main-key"),
@@ -775,7 +1204,7 @@ test("Federation.fetch()", async (t) => {
 				inbox: ctx.getInboxUri(identifier),
 				preferredUsername: identifier
 			});
-		}).setKeyPairsDispatcher(() => {
+		}).mapActorAlias("/bot", "bot").setKeyPairsDispatcher(() => {
 			return [{
 				privateKey: rsaPrivateKey2,
 				publicKey: rsaPublicKey2.publicKey
@@ -799,6 +1228,32 @@ test("Federation.fetch()", async (t) => {
 		assertEquals(dispatches, []);
 		assertEquals(response.status, 406);
 	});
+	await t.step("GET actor alias", async () => {
+		const { federation, dispatches } = createTestContext();
+		const response = await federation.fetch(new Request("https://example.com/bot", {
+			method: "GET",
+			headers: { "Accept": "application/activity+json" }
+		}), { contextData: void 0 });
+		assertEquals(dispatches, ["bot"]);
+		assertEquals(response.status, 200);
+		const body = await response.json();
+		assertEquals(body.id, "https://example.com/bot");
+		assertEquals(body.preferredUsername, "bot");
+	});
+	await t.step("WebFinger for actor alias", async () => {
+		const { federation } = createTestContext();
+		const response = await federation.fetch(new Request("https://example.com/.well-known/webfinger?resource=acct:bot@example.com"), { contextData: void 0 });
+		assertEquals(response.status, 200);
+		const body = await response.json();
+		assertEquals(body.subject, "acct:bot@example.com");
+		assertExists(body.links);
+		assert(Array.isArray(body.links));
+		const selfLink = body.links.find((l) => l.rel === "self");
+		assertExists(selfLink);
+		assertEquals(selfLink.href, "https://example.com/bot");
+		assertExists(body.aliases);
+		assert(body.aliases.includes("https://example.com/bot"));
+	});
 	await t.step("POST with application/json", async () => {
 		const { federation, inbox } = createTestContext();
 		const request = await signRequest(new Request("https://example.com/users/json/inbox", {
@@ -905,6 +1360,18 @@ test("Federation.fetch()", async (t) => {
 		assertEquals(inbox, []);
 		assertEquals(response.status, 404);
 	});
+	await t.step("empty identifier segment is Not Found, dispatcher not invoked", async () => {
+		const { federation, dispatches } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/users/", {
+			method: "GET",
+			headers: { "Accept": "application/activity+json" }
+		}), { contextData: void 0 })).status, 404);
+		assertEquals((await federation.fetch(new Request("https://example.com/users//inbox", {
+			method: "POST",
+			headers: { "accept": "application/ld+json" }
+		}), { contextData: void 0 })).status, 404);
+		assertEquals(dispatches.includes(""), false);
+	});
 	await t.step("onNotAcceptable with GET", async () => {
 		const { federation } = createTestContext();
 		let notAcceptableCalled = false;
@@ -924,6 +1391,213 @@ test("Federation.fetch()", async (t) => {
 	});
 	esm_default.hardReset();
 });
+test("Federation.fetch() records HTTP server request metrics", async (t) => {
+	const createTestContext = () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = createFederation({
+			kv,
+			meterProvider,
+			documentLoaderFactory: () => mockDocumentLoader
+		});
+		federation.setActorDispatcher("/users/{identifier}", (ctx, identifier) => {
+			if (identifier === "boom") throw new Error("explosion in actor dispatcher");
+			return new vocab.Person({
+				id: ctx.getActorUri(identifier),
+				inbox: ctx.getInboxUri(identifier),
+				preferredUsername: identifier
+			});
+		});
+		federation.setNodeInfoDispatcher("/nodeinfo/2.1", () => ({
+			software: {
+				name: "example",
+				version: "1.0.0"
+			},
+			protocols: ["activitypub"],
+			usage: {
+				users: {},
+				localPosts: 0,
+				localComments: 0
+			}
+		}));
+		federation.setFollowersDispatcher("/users/{identifier}/followers", () => ({ items: [] }));
+		federation.setCollectionDispatcher("custom-collection", vocab.Object, "/users/{identifier}/custom/{id}", () => ({ items: [] }));
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
+		return {
+			federation,
+			recorder
+		};
+	};
+	await t.step("records a successful actor request", async () => {
+		const { federation, recorder } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/users/alice", {
+			method: "GET",
+			headers: { "Accept": "application/activity+json" }
+		}), { contextData: void 0 })).status, 200);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].type, "counter");
+		assertEquals(counts[0].value, 1);
+		assertEquals(counts[0].attributes["http.request.method"], "GET");
+		assertEquals(counts[0].attributes["fedify.endpoint"], "actor");
+		assertEquals(counts[0].attributes["http.response.status_code"], 200);
+		assertEquals(counts[0].attributes["fedify.route.template"], "/users/{identifier}");
+		const durations = recorder.getMeasurements("fedify.http.server.request.duration");
+		assertEquals(durations.length, 1);
+		assertEquals(durations[0].type, "histogram");
+		assert(durations[0].value >= 0);
+		assertEquals(durations[0].attributes["fedify.endpoint"], "actor");
+		assertEquals(durations[0].attributes["http.response.status_code"], 200);
+		assertEquals(durations[0].attributes["fedify.route.template"], "/users/{identifier}");
+	});
+	await t.step("records WebFinger requests", async () => {
+		const { federation, recorder } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/.well-known/webfinger?resource=acct:alice@example.com"), { contextData: void 0 })).status, 200);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["fedify.endpoint"], "webfinger");
+		assertEquals(counts[0].attributes["fedify.route.template"], "/.well-known/webfinger");
+		assertEquals(counts[0].attributes["http.response.status_code"], 200);
+	});
+	await t.step("records NodeInfo JRD requests", async () => {
+		const { federation, recorder } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/.well-known/nodeinfo"), { contextData: void 0 })).status, 200);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["fedify.endpoint"], "nodeinfo");
+		assertEquals(counts[0].attributes["fedify.route.template"], "/.well-known/nodeinfo");
+	});
+	await t.step("records NodeInfo dispatcher requests", async () => {
+		const { federation, recorder } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/nodeinfo/2.1"), { contextData: void 0 })).status, 200);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["fedify.endpoint"], "nodeinfo");
+		assertEquals(counts[0].attributes["fedify.route.template"], "/nodeinfo/2.1");
+	});
+	await t.step("records 404 not_found for unmatched paths", async () => {
+		const { federation, recorder } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/no/such/path"), { contextData: void 0 })).status, 404);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["fedify.endpoint"], "not_found");
+		assertEquals(counts[0].attributes["http.response.status_code"], 404);
+		assertEquals(counts[0].attributes["fedify.route.template"], void 0);
+	});
+	await t.step("records 406 not_acceptable when JSON-LD Accept missing", async () => {
+		const { federation, recorder } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/users/alice", {
+			method: "GET",
+			headers: { "Accept": "text/html" }
+		}), { contextData: void 0 })).status, 406);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["fedify.endpoint"], "not_acceptable");
+		assertEquals(counts[0].attributes["http.response.status_code"], 406);
+		assertEquals(counts[0].attributes["fedify.route.template"], "/users/{identifier}");
+	});
+	await t.step("records collection metrics for not_acceptable collection requests", async () => {
+		const { federation, recorder } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/users/alice/followers", {
+			method: "GET",
+			headers: { "Accept": "text/html" }
+		}), { contextData: void 0 })).status, 406);
+		const requests = recorder.getMeasurements("activitypub.collection.request");
+		assertEquals(requests.length, 1);
+		assertEquals(requests[0].attributes["activitypub.collection.kind"], "followers");
+		assertEquals(requests[0].attributes["activitypub.collection.page"], false);
+		assertEquals(requests[0].attributes["fedify.collection.dispatcher"], "built_in");
+		assertEquals(requests[0].attributes["activitypub.collection.result"], "not_acceptable");
+		assertEquals(requests[0].attributes["http.response.status_code"], 406);
+	});
+	await t.step("records thrown errors after classification with the matched endpoint", async () => {
+		const { federation, recorder } = createTestContext();
+		await assertRejects(() => federation.fetch(new Request("https://example.com/users/boom", {
+			method: "GET",
+			headers: { "Accept": "application/activity+json" }
+		}), { contextData: void 0 }), Error, "explosion");
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["fedify.endpoint"], "actor");
+		assertEquals(counts[0].attributes["http.response.status_code"], void 0);
+		assertEquals(counts[0].attributes["fedify.route.template"], "/users/{identifier}");
+		const durations = recorder.getMeasurements("fedify.http.server.request.duration");
+		assertEquals(durations.length, 1);
+		assertEquals(durations[0].attributes["fedify.endpoint"], "actor");
+	});
+	await t.step("collapses user-defined collection dispatchers to endpoint=collection", async () => {
+		const { federation, recorder } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/users/alice/custom/1", {
+			method: "GET",
+			headers: { "Accept": "application/activity+json" }
+		}), { contextData: void 0 })).status, 200);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["fedify.endpoint"], "collection");
+		assertEquals(counts[0].attributes["fedify.route.template"], "/users/{identifier}/custom/{id}");
+	});
+	await t.step("records followers as endpoint=followers", async () => {
+		const { federation, recorder } = createTestContext();
+		assertEquals((await federation.fetch(new Request("https://example.com/users/alice/followers", {
+			method: "GET",
+			headers: { "Accept": "application/activity+json" }
+		}), { contextData: void 0 })).status, 200);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["fedify.endpoint"], "followers");
+		assertEquals(counts[0].attributes["fedify.route.template"], "/users/{identifier}/followers");
+	});
+	await t.step("records sharedInbox as endpoint=shared_inbox", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = createFederation({
+			kv,
+			meterProvider,
+			documentLoaderFactory: () => mockDocumentLoader
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
+		assert((await federation.fetch(new Request("https://example.com/inbox", {
+			method: "POST",
+			headers: { "accept": "application/ld+json" }
+		}), { contextData: void 0 })).status >= 400);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["fedify.endpoint"], "shared_inbox");
+		assertEquals(counts[0].attributes["fedify.route.template"], "/inbox");
+		assertEquals(counts[0].attributes["http.request.method"], "POST");
+	});
+	await t.step("normalizes unknown HTTP methods to _OTHER for cardinality control", async () => {
+		const { federation, recorder } = createTestContext();
+		assert((await federation.fetch(new Request("https://example.com/users/alice", {
+			method: "PROPFIND",
+			headers: { "Accept": "application/activity+json" }
+		}), { contextData: void 0 })).status >= 100);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["http.request.method"], "_OTHER");
+	});
+	await t.step("preserves QUERY as a known HTTP method", async () => {
+		const { federation, recorder } = createTestContext();
+		assert((await federation.fetch(new Request("https://example.com/users/alice", {
+			method: "QUERY",
+			headers: { "Accept": "application/activity+json" }
+		}), { contextData: void 0 })).status >= 100);
+		const counts = recorder.getMeasurements("fedify.http.server.request.count");
+		assertEquals(counts.length, 1);
+		assertEquals(counts[0].attributes["http.request.method"], "QUERY");
+	});
+	await t.step("uses the global meter provider when none is configured", async () => {
+		const federation = createFederation({
+			kv: new MemoryKvStore(),
+			documentLoaderFactory: () => mockDocumentLoader
+		});
+		federation.setActorDispatcher("/users/{identifier}", (ctx, identifier) => new vocab.Person({ id: ctx.getActorUri(identifier) }));
+		assertEquals((await federation.fetch(new Request("https://example.com/users/alice", {
+			method: "GET",
+			headers: { "Accept": "application/activity+json" }
+		}), { contextData: void 0 })).status, 200);
+	});
+});
 test("Federation.setInboxListeners()", async (t) => {
 	const kv = new MemoryKvStore();
 	esm_default.spyGlobal();
@@ -1693,19 +2367,22 @@ test("Federation.setOutboxListeners()", async (t) => {
 		};
 		let listenCalled = false;
 		const enqueued = [];
+		const queue = {
+			enqueue(message) {
+				enqueued.push(message);
+				return Promise.resolve();
+			},
+			listen() {
+				listenCalled = true;
+				return Promise.resolve();
+			}
+		};
+		const [meterProvider, recorder] = createTestMeterProvider();
 		const federation = new FederationImpl({
 			kv,
 			contextLoaderFactory: () => mockDocumentLoader,
-			queue: {
-				enqueue(message) {
-					enqueued.push(message);
-					return Promise.resolve();
-				},
-				listen() {
-					listenCalled = true;
-					return Promise.resolve();
-				}
-			}
+			meterProvider,
+			queue
 		});
 		federation.setActorDispatcher("/users/{identifier}", (_ctx, identifier) => identifier === "john" ? new vocab.Person({}) : null).setKeyPairsDispatcher(() => [{
 			privateKey: rsaPrivateKey2,
@@ -1731,7 +2408,59 @@ test("Federation.setOutboxListeners()", async (t) => {
 		assertEquals(enqueued.length, 1);
 		assertEquals(enqueued[0].type, "outbox");
 		assertEquals(enqueued[0].actorIds, ["https://remote.example/users/alice"]);
+		const enqueuedMetrics = recorder.getMeasurements("fedify.queue.task.enqueued");
+		assertEquals(enqueuedMetrics.length, 1);
+		assertEquals(enqueuedMetrics[0].attributes["fedify.queue.role"], "outbox");
+		assertEquals(enqueuedMetrics[0].attributes["fedify.queue.task.attempt"], 0);
+	});
+});
+test("Federation.fetch() preserves original LD-signed payload for InboxContextImpl.activity", async () => {
+	const remoteContextUrl = "https://remote.example/contexts/ext";
+	const sourceContextLoader = async (resource) => {
+		const url = new URL(resource).href;
+		if (url === remoteContextUrl) return {
+			contextUrl: null,
+			documentUrl: url,
+			document: { "@context": { ext: "https://example.com/ext" } }
+		};
+		return await mockDocumentLoader(url);
+	};
+	const federation = createFederation({
+		kv: new MemoryKvStore(),
+		documentLoaderFactory: () => mockDocumentLoader,
+		contextLoaderFactory: () => sourceContextLoader
 	});
+	federation.setActorDispatcher("/users/{identifier}", (_ctx, identifier) => identifier === "someone" ? new Person({}) : null);
+	let receivedRaw = null;
+	let receivedTyped = null;
+	federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, (ctx, activity) => {
+		receivedRaw = ctx.activity;
+		receivedTyped = activity;
+	});
+	const signed = await signJsonLd({
+		"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+		id: "https://example.com/activities/preserve-raw",
+		type: "Create",
+		actor: "https://example.com/person2",
+		ext: "preserve-me",
+		object: {
+			id: "https://example.com/notes/preserve-raw",
+			type: "Note",
+			attributedTo: "https://example.com/person2",
+			content: "Hello, world!"
+		}
+	}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: sourceContextLoader });
+	const response = await federation.fetch(new Request("https://example.com/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body: JSON.stringify(signed)
+	}), { contextData: void 0 });
+	assertEquals([response.status, await response.text()], [202, ""]);
+	assertEquals(receivedRaw, signed);
+	assertNotEquals(receivedRaw, await compactJsonLd(signed, sourceContextLoader));
+	const delivered = receivedTyped;
+	assert(delivered != null);
+	assertEquals(delivered.id?.href, "https://example.com/activities/preserve-raw");
 });
 test("Federation.setInboxDispatcher()", async (t) => {
 	const kv = new MemoryKvStore();
@@ -2054,32 +2783,2798 @@ test("FederationImpl.processQueuedTask()", async (t) => {
 			attempt: 1
 		}]);
 	});
-});
-test("FederationImpl.processQueuedTask() permanent failure", async (t) => {
-	esm_default.spyGlobal();
+	await t.step("records activitypub.outbox.activity retry on transient failure", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		await new FederationImpl({
+			kv,
+			meterProvider,
+			queue: {
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			}
+		}).processQueuedTask(void 0, {
+			type: "outbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			keys: [],
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				actor: "https://example.com/users/alice",
+				object: {
+					type: "Note",
+					content: "test"
+				}
+			},
+			activityType: "https://www.w3.org/ns/activitystreams#Create",
+			inbox: "https://invalid-domain-that-does-not-exist.example/inbox",
+			sharedInbox: false,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			headers: {},
+			traceContext: {}
+		});
+		const outboxLifecycle = recorder.getMeasurements("activitypub.outbox.activity");
+		assertEquals(outboxLifecycle.length, 1);
+		assertEquals(outboxLifecycle[0].type, "counter");
+		assertEquals(outboxLifecycle[0].attributes["activitypub.processing.result"], "retried");
+		assertEquals(outboxLifecycle[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+	});
+	await t.step("records activitypub.outbox.activity abandoned when retry policy gives up", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		await new FederationImpl({
+			kv,
+			meterProvider,
+			queue: {
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			},
+			outboxRetryPolicy: () => null
+		}).processQueuedTask(void 0, {
+			type: "outbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			keys: [],
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Follow",
+				actor: "https://example.com/users/alice",
+				object: "https://remote.example/users/bob"
+			},
+			activityType: "https://www.w3.org/ns/activitystreams#Follow",
+			inbox: "https://invalid-domain-that-does-not-exist.example/inbox",
+			sharedInbox: false,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			headers: {},
+			traceContext: {}
+		});
+		const outboxLifecycle = recorder.getMeasurements("activitypub.outbox.activity");
+		assertEquals(outboxLifecycle.length, 1);
+		assertEquals(outboxLifecycle[0].type, "counter");
+		assertEquals(outboxLifecycle[0].attributes["activitypub.processing.result"], "abandoned");
+		assertEquals(outboxLifecycle[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Follow");
+	});
+	await t.step("records activitypub.inbox.activity processed on successful queued dispatch", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = new FederationImpl({
+			kv,
+			meterProvider,
+			queue: {
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(vocab.Create, () => {});
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://example.com/activities/queued-processed",
+				actor: "https://remote.example/users/alice",
+				object: {
+					type: "Note",
+					content: "Hello world"
+				}
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		const inboxLifecycle = recorder.getMeasurements("activitypub.inbox.activity");
+		assertEquals(inboxLifecycle.length, 1);
+		assertEquals(inboxLifecycle[0].type, "counter");
+		assertEquals(inboxLifecycle[0].attributes["activitypub.processing.result"], "processed");
+		assertEquals(inboxLifecycle[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+	});
+	await t.step("records activitypub.inbox.activity retried on transient listener failure", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = new FederationImpl({
+			kv,
+			meterProvider,
+			queue: {
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(vocab.Create, () => {
+			throw new Error("Intended error for testing");
+		});
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://example.com/activities/queued-retried",
+				actor: "https://remote.example/users/alice",
+				object: {
+					type: "Note",
+					content: "Hello world"
+				}
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		const inboxLifecycle = recorder.getMeasurements("activitypub.inbox.activity");
+		assertEquals(inboxLifecycle.length, 1);
+		assertEquals(inboxLifecycle[0].attributes["activitypub.processing.result"], "retried");
+		assertEquals(inboxLifecycle[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+	});
+	await t.step("records activitypub.inbox.activity abandoned when retry policy gives up", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = new FederationImpl({
+			kv,
+			meterProvider,
+			queue: {
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			},
+			inboxRetryPolicy: () => null
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(vocab.Create, () => {
+			throw new Error("Intended error for testing");
+		});
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://example.com/activities/queued-abandoned",
+				actor: "https://remote.example/users/alice",
+				object: {
+					type: "Note",
+					content: "Hello world"
+				}
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		const inboxLifecycle = recorder.getMeasurements("activitypub.inbox.activity");
+		assertEquals(inboxLifecycle.length, 1);
+		assertEquals(inboxLifecycle[0].attributes["activitypub.processing.result"], "abandoned");
+		assertEquals(inboxLifecycle[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+	});
+	await t.step("records queued inbox processing duration", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = new FederationImpl({
+			kv,
+			meterProvider,
+			queue: {
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			}
+		});
+		let handled = false;
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(vocab.Create, () => {
+			handled = true;
+		});
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://remote.example/activities/1",
+				actor: "https://remote.example/users/alice",
+				object: {
+					type: "Note",
+					content: "Hello world"
+				}
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		assert(handled);
+		const durations = recorder.getMeasurements("activitypub.inbox.processing_duration");
+		assertEquals(durations.length, 1);
+		assertEquals(durations[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		const started = recorder.getMeasurements("fedify.queue.task.started");
+		assertEquals(started.length, 1);
+		assertEquals(started[0].attributes["fedify.queue.role"], "inbox");
+		const completed = recorder.getMeasurements("fedify.queue.task.completed");
+		assertEquals(completed.length, 1);
+		assertEquals(completed[0].attributes["fedify.queue.role"], "inbox");
+		assertEquals(completed[0].attributes["fedify.queue.task.result"], "completed");
+		assertEquals(completed[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		assertEquals(recorder.getMeasurements("fedify.queue.task.failed").length, 0);
+		const taskDurations = recorder.getMeasurements("fedify.queue.task.duration");
+		assertEquals(taskDurations.length, 1);
+		assertEquals(taskDurations[0].type, "histogram");
+		assertEquals(taskDurations[0].attributes["fedify.queue.role"], "inbox");
+		assertEquals(taskDurations[0].attributes["fedify.queue.task.result"], "completed");
+		const inFlight = recorder.getMeasurements("fedify.queue.task.in_flight");
+		assertEquals(inFlight.length, 2);
+		assertEquals(inFlight[0].type, "upDownCounter");
+		assertEquals(inFlight[0].value, 1);
+		assertEquals(inFlight[1].value, -1);
+		assertEquals(inFlight[0].attributes, inFlight[1].attributes);
+		assertEquals(inFlight[0].attributes["fedify.queue.role"], "inbox");
+		assertEquals(inFlight[0].attributes["activitypub.activity.type"], void 0);
+	});
+	await t.step("with restrictive context loader and normalized LD-signed inbox activity", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const sourceContextLoader = async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		};
+		const restrictiveContextLoader = async (resource) => {
+			const url = new URL(resource).href;
+			if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+			throw new Error(`Unexpected context: ${url}`);
+		};
+		const kv = new MemoryKvStore();
+		let receivedCount = 0;
+		let received = null;
+		let receivedRaw = null;
+		const federation = new FederationImpl({
+			kv,
+			contextLoaderFactory: () => restrictiveContextLoader
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, (ctx, activity) => {
+			receivedCount++;
+			receivedRaw = ctx.activity;
+			received = activity;
+		});
+		const signed = await signJsonLd({
+			"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+			id: "https://remote.example/activities/1",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/1",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello, world!"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: sourceContextLoader });
+		const normalizedActivity = await compactJsonLd(signed, sourceContextLoader);
+		const messageId = crypto.randomUUID();
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: messageId,
+			baseUrl: "https://example.com",
+			activity: signed,
+			normalizedActivity,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		const delivered = received;
+		assert(delivered != null);
+		const deliveredCreate = delivered;
+		assertInstanceOf(deliveredCreate, Create);
+		assertEquals(deliveredCreate.id?.href, "https://remote.example/activities/1");
+		assertEquals(receivedRaw, signed);
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: messageId,
+			baseUrl: "https://example.com",
+			activity: signed,
+			normalizedActivity,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		assertEquals(receivedCount, 1);
+	});
+	await t.step("cached normalizedActivity is rechecked for unsafe JSON-LD keywords", async () => {
+		const queuedMessages = [];
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		let receivedCount = 0;
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			receivedCount++;
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://remote.example/activities/unsafe-normalized-cache",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/unsafe-normalized-cache",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from unsafe normalized cache"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+		const normalizedActivity = await compactJsonLd(signed, mockDocumentLoader);
+		const tamperedNormalizedActivity = {
+			...normalizedActivity,
+			signature: {
+				...normalizedActivity.signature,
+				"@included": [{
+					id: "https://remote.example/activities/inside-signature",
+					type: "Undo"
+				}]
+			}
+		};
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			normalizedActivity: tamperedNormalizedActivity,
+			ldSignatureVerified: false,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		assertEquals(receivedCount, 0);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("old queued LDS inbox messages without normalizedActivity still work", async () => {
+		const restrictiveContextLoader = async (resource) => {
+			const url = new URL(resource).href;
+			if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+			throw new Error(`Unexpected context: ${url}`);
+		};
+		const kv = new MemoryKvStore();
+		let received = null;
+		const federation = new FederationImpl({
+			kv,
+			contextLoaderFactory: () => restrictiveContextLoader
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, (_ctx, activity) => {
+			received = activity;
+		});
+		const compacted = await compactJsonLd(await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://remote.example/activities/legacy",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/legacy",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader }), restrictiveContextLoader);
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: compacted,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		assert(received != null);
+		assertEquals(received.id?.href, "https://remote.example/activities/legacy");
+	});
+	await t.step("queued signature-bearing non-LDS inbox messages keep parse-time normalization contexts", async () => {
+		const signingContextLoader = async (resource) => {
+			const url = new URL(resource).href;
+			if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1" || url === "https://w3id.org/security/v1" || url === "https://w3id.org/security/data-integrity/v1") return await mockDocumentLoader(url);
+			throw new Error(`Unexpected context: ${url}`);
+		};
+		const processingContextLoader = async (resource) => {
+			const url = new URL(resource).href;
+			if (url === "https://w3id.org/identity/v1" || url === "https://w3id.org/security/v1" || url === "https://w3id.org/security/data-integrity/v1") throw new Error("queued non-LDS signed payloads should parse with the normalization loader's built-in signature contexts");
+			return await signingContextLoader(resource);
+		};
+		const kv = new MemoryKvStore();
+		let received = null;
+		let receivedRaw = null;
+		const federation = new FederationImpl({
+			kv,
+			contextLoaderFactory: () => processingContextLoader
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, (ctx, activity) => {
+			receivedRaw = ctx.activity;
+			received = activity;
+		});
+		const signed = await signJsonLd({
+			"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
+			id: "https://remote.example/activities/non-lds-queued-signature",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/non-lds-queued-signature",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from non-LDS queued signature"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: signingContextLoader });
+		const signedPayload = signed;
+		assert(Array.isArray(signedPayload["@context"]) && signedPayload["@context"].includes("https://w3id.org/security/v1"));
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			ldSignatureVerified: false,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		if (received == null) throw new Error("Inbox activity not delivered.");
+		assertEquals(received.id?.href, "https://remote.example/activities/non-lds-queued-signature");
+		assertEquals(receivedRaw, signed);
+	});
+	await t.step("queued signature-bearing non-LDS inbox messages reuse normalizedActivity for custom contexts", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const sourceContextLoader = async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		};
+		const restrictiveContextLoader = async (resource) => {
+			const url = new URL(resource).href;
+			if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+			throw new Error(`Unexpected context: ${url}`);
+		};
+		const kv = new MemoryKvStore();
+		let received = null;
+		let receivedRaw = null;
+		const federation = new FederationImpl({
+			kv,
+			contextLoaderFactory: () => restrictiveContextLoader
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, (ctx, activity) => {
+			receivedRaw = ctx.activity;
+			received = activity;
+		});
+		const unsignedBody = {
+			"@context": [
+				remoteContextUrl,
+				"https://www.w3.org/ns/activitystreams",
+				"https://w3id.org/security/v1"
+			],
+			id: "https://remote.example/activities/non-lds-queued-custom-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/non-lds-queued-custom-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from non-LDS queued custom context"
+			},
+			signature: {
+				type: "RsaSignature2017",
+				creator: "not a url",
+				created: "2024-09-12T16:50:46Z",
+				signatureValue: "Zm9v"
+			}
+		};
+		const normalizedActivity = await compactJsonLd(unsignedBody, sourceContextLoader);
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: unsignedBody,
+			normalizedActivity,
+			ldSignatureVerified: false,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		if (received == null) throw new Error("Inbox activity not delivered.");
+		assertEquals(received.id?.href, "https://remote.example/activities/non-lds-queued-custom-context");
+		assertEquals(receivedRaw, unsignedBody);
+	});
+	await t.step("legacy raw LDS inbox messages without normalizedActivity retry through worker error handling", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const restrictiveContextLoader = async (resource) => {
+			const url = new URL(resource).href;
+			if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+			throw new Error(`Unexpected context: ${url}`);
+		};
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => restrictiveContextLoader
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+			id: "https://remote.example/activities/legacy-raw",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/legacy-raw",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from raw legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		} });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages.length, 1);
+		const retried = queuedMessages[0];
+		assertEquals(retried.attempt, 1);
+		assertEquals(retried.activity, inboxMessage.activity);
+	});
+	await t.step("without inbox queue retriable inbox parse failures bubble to caller", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const sourceContextLoader = async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		};
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv: new MemoryKvStore(),
+			contextLoaderFactory: () => async (resource) => {
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				if (url === remoteContextUrl) throw new Error(`Transient remote context failure: ${url}`);
+				throw new Error(`Unexpected context: ${url}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+			id: "https://remote.example/activities/manual-retry",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/manual-retry",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from manual retry queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: sourceContextLoader });
+		await assertRejects(() => federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		}), Error);
+		assertEquals(errorCount, 1);
+	});
+	await t.step("legacy raw LDS inbox messages with transient InvalidUrl failures retry", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				if (url === remoteContextUrl) {
+					const error = /* @__PURE__ */ new Error(`Transient remote context failure: ${url}`);
+					error.name = "jsonld.InvalidUrl";
+					error.details = {
+						code: "loading remote context failed",
+						url
+					};
+					throw error;
+				}
+				throw new Error(`Unexpected context: ${url}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+			id: "https://remote.example/activities/legacy-invalid-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/legacy-invalid-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from invalid legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		} });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages.length, 1);
+		const retried = queuedMessages[0];
+		assertEquals(retried.attempt, 1);
+		assertEquals(retried.activity, inboxMessage.activity);
+	});
+	await t.step("legacy raw LDS inbox messages with opaque context ids retry", async () => {
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				if (resource === "app-context") {
+					const error = /* @__PURE__ */ new Error(`Opaque context backend is unavailable: ${resource}`);
+					error.name = "jsonld.InvalidUrl";
+					error.details = {
+						code: "loading remote context failed",
+						url: resource
+					};
+					throw error;
+				}
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				throw new Error(`Unexpected context: ${resource}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://remote.example/activities/legacy-malformed-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/legacy-malformed-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from malformed legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				...signed,
+				"@context": ["app-context", "https://www.w3.org/ns/activitystreams"]
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, [{
+			...inboxMessage,
+			attempt: 1
+		}]);
+	});
+	await t.step("legacy raw LDS inbox messages with Invalid URL TypeErrors retry", async () => {
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				if (resource === "app:context") throw new TypeError(`Invalid URL: ${resource}`);
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				throw new Error(`Unexpected context: ${resource}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://remote.example/activities/legacy-typeerror-invalid-url",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/legacy-typeerror-invalid-url",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from invalid-url typeerror queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				...signed,
+				"@context": ["app:context", "https://www.w3.org/ns/activitystreams"]
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages.length, 1);
+		const retried = queuedMessages[0];
+		assertEquals(retried.attempt, 1);
+		assertEquals(retried.activity, inboxMessage.activity);
+	});
+	await t.step("legacy raw LDS inbox messages with malformed absolute context refs do not retry", async () => {
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				if (resource === "http:/[") throw new TypeError(`Invalid URL: ${resource}`);
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				throw new Error(`Unexpected context: ${resource}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://remote.example/activities/legacy-malformed-absolute-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/legacy-malformed-absolute-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from malformed absolute context queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				...signed,
+				"@context": ["http:/[", "https://www.w3.org/ns/activitystreams"]
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("malformed IRI fields are permanent queued inbox parse errors", async () => {
+		const queuedMessages = [];
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "http://[",
+				type: "Create",
+				actor: "https://remote.example/users/alice",
+				object: {
+					id: "https://remote.example/notes/invalid-iri",
+					type: "Note",
+					attributedTo: "https://remote.example/users/alice",
+					content: "Hello from invalid IRI queue"
+				}
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("legacy raw LDS inbox messages with network-path context ids retry", async () => {
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				if (resource === "//cdn.example/ctx") {
+					const error = /* @__PURE__ */ new Error(`Network-path context backend is unavailable: ${resource}`);
+					error.name = "jsonld.InvalidUrl";
+					error.details = {
+						code: "loading remote context failed",
+						url: resource
+					};
+					throw error;
+				}
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				throw new Error(`Unexpected context: ${resource}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://remote.example/activities/legacy-network-path-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/legacy-network-path-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from network-path legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				...signed,
+				"@context": ["//cdn.example/ctx", "https://www.w3.org/ns/activitystreams"]
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, [{
+			...inboxMessage,
+			attempt: 1
+		}]);
+	});
+	await t.step("legacy raw LDS inbox messages with malformed network-path refs do not retry", async () => {
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				if (resource === "//[") {
+					const error = /* @__PURE__ */ new Error(`Malformed network-path context: ${resource}`);
+					error.name = "jsonld.InvalidUrl";
+					error.details = {
+						code: "loading remote context failed",
+						url: resource
+					};
+					throw error;
+				}
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				throw new Error(`Unexpected context: ${resource}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://remote.example/activities/legacy-malformed-network-path-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/legacy-malformed-network-path-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from malformed network-path legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				...signed,
+				"@context": ["//[", "https://www.w3.org/ns/activitystreams"]
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("legacy raw LDS inbox messages with malformed context URLs do not retry", async () => {
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				if (resource === "not a url") {
+					const error = /* @__PURE__ */ new Error(`Invalid remote context URL: ${resource}`);
+					error.name = "jsonld.InvalidUrl";
+					error.details = {
+						code: "loading remote context failed",
+						url: resource
+					};
+					throw error;
+				}
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				throw new Error(`Unexpected context: ${resource}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://remote.example/activities/legacy-malformed-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/legacy-malformed-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from malformed legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				...signed,
+				"@context": ["not a url", "https://www.w3.org/ns/activitystreams"]
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("legacy raw LDS inbox messages with invalid percent escapes do not retry", async () => {
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				if (resource === "foo%zz") {
+					const error = /* @__PURE__ */ new Error(`Invalid remote context URL: ${resource}`);
+					error.name = "jsonld.InvalidUrl";
+					error.details = {
+						code: "loading remote context failed",
+						url: resource
+					};
+					throw error;
+				}
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				throw new Error(`Unexpected context: ${resource}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://remote.example/activities/legacy-malformed-percent-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			object: {
+				id: "https://remote.example/notes/legacy-malformed-percent-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from malformed percent legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				...signed,
+				"@context": ["foo%zz", "https://www.w3.org/ns/activitystreams"]
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("legacy raw LDS inbox messages with invalid remote contexts do not retry", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				if (url === remoteContextUrl) return {
+					contextUrl: null,
+					documentUrl: url,
+					document: [
+						"not",
+						"an",
+						"object"
+					]
+				};
+				throw new Error(`Unexpected context: ${url}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+			id: "https://remote.example/activities/legacy-invalid-remote-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/legacy-invalid-remote-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from invalid remote context queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		} });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("legacy raw LDS inbox messages with string remote contexts retry", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				if (url === remoteContextUrl) return {
+					contextUrl: null,
+					documentUrl: url,
+					document: "{not valid json"
+				};
+				throw new Error(`Unexpected context: ${url}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+			id: "https://remote.example/activities/legacy-string-remote-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/legacy-string-remote-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from string remote context queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		} });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, [{
+			...inboxMessage,
+			attempt: 1
+		}]);
+	});
+	await t.step("legacy raw LDS inbox messages with loader TypeErrors retry", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				if (url === remoteContextUrl) throw new TypeError(`Cannot initialize remote context loader: ${url}`);
+				throw new Error(`Unexpected context: ${url}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+			id: "https://remote.example/activities/legacy-typeerror-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/legacy-typeerror-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from typeerror legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		} });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, [{
+			...inboxMessage,
+			attempt: 1
+		}]);
+	});
+	await t.step("legacy raw LDS inbox messages with syntax errors in remote contexts retry", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				if (url === remoteContextUrl) {
+					const error = /* @__PURE__ */ new Error(`Transient syntax failure: ${url}`);
+					error.name = "jsonld.SyntaxError";
+					error.details = { code: "loading remote context failed" };
+					throw error;
+				}
+				throw new Error(`Unexpected context: ${url}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+			id: "https://remote.example/activities/legacy-syntax-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/legacy-syntax-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from syntax legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		} });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, [{
+			...inboxMessage,
+			attempt: 1
+		}]);
+	});
+	await t.step("legacy raw LDS inbox messages with loader RangeErrors retry", async () => {
+		const remoteContextUrl = "https://remote.example/contexts/ext";
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			contextLoaderFactory: () => async (resource) => {
+				const url = new URL(resource).href;
+				if (url === "https://www.w3.org/ns/activitystreams" || url === "https://w3id.org/identity/v1") return await mockDocumentLoader(url);
+				if (url === remoteContextUrl) throw new RangeError(`Temporary remote context cache window exceeded: ${url}`);
+				throw new Error(`Unexpected context: ${url}`);
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		const signed = await signJsonLd({
+			"@context": [remoteContextUrl, "https://www.w3.org/ns/activitystreams"],
+			id: "https://remote.example/activities/legacy-rangeerror-context",
+			type: "Create",
+			actor: "https://remote.example/users/alice",
+			ext: "preserve-me",
+			object: {
+				id: "https://remote.example/notes/legacy-rangeerror-context",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Hello from rangeerror legacy queue"
+			}
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: async (resource) => {
+			const url = new URL(resource).href;
+			if (url === remoteContextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { ext: "https://example.com/ext" } }
+			};
+			return await mockDocumentLoader(url);
+		} });
+		const inboxMessage = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: signed,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		};
+		await federation.processQueuedTask(void 0, inboxMessage);
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, [{
+			...inboxMessage,
+			attempt: 1
+		}]);
+	});
+	await t.step("permanent queued inbox parse errors do not re-enqueue poison messages", async () => {
+		const queuedMessages = [];
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://remote.example/objects/not-an-activity",
+				type: "Note",
+				attributedTo: "https://remote.example/users/alice",
+				content: "Not an activity"
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("malformed Temporal fields are permanent queued inbox parse errors", async () => {
+		const queuedMessages = [];
+		const queue = {
+			enqueue(message, _options) {
+				queuedMessages.push(message);
+				return Promise.resolve();
+			},
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		};
+		const kv = new MemoryKvStore();
+		let errorCount = 0;
+		const federation = new FederationImpl({
+			kv,
+			queue,
+			documentLoaderFactory: () => mockDocumentLoader,
+			contextLoaderFactory: () => mockDocumentLoader
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw new Error("listener should not run");
+		}).onError(() => {
+			errorCount++;
+		});
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"],
+				id: "https://remote.example/activities/invalid-proof-created",
+				type: "Create",
+				actor: "https://remote.example/users/alice",
+				object: {
+					id: "https://remote.example/notes/invalid-proof-created",
+					type: "Note",
+					attributedTo: "https://remote.example/users/alice",
+					content: "Hello, world!"
+				},
+				proof: {
+					type: "DataIntegrityProof",
+					cryptosuite: "eddsa-jcs-2022",
+					verificationMethod: "https://remote.example/users/alice#ed25519-key",
+					proofPurpose: "assertionMethod",
+					created: { "@value": "not-a-date" },
+					proofValue: "zLaewdp4H9kqtwyrLatK4cjY5oRHwVcw4gibPSUDYDMhi4M49v8pcYk3ZB6D69dNpAPbUmY8ocuJ3m9KhKJEEg7z"
+				}
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		});
+		assertEquals(errorCount, 1);
+		assertEquals(queuedMessages, []);
+	});
+});
+test("FederationImpl.processQueuedTask() permanent failure", async (t) => {
+	esm_default.spyGlobal();
 	esm_default.post("https://gone.example/inbox", {
 		status: 410,
 		body: "Gone"
 	});
-	esm_default.post("https://notfound.example/inbox", {
-		status: 404,
-		body: "Not Found"
+	esm_default.post("https://notfound.example/inbox", {
+		status: 404,
+		body: "Not Found"
+	});
+	esm_default.post("https://error.example/inbox", {
+		status: 500,
+		body: "Internal Server Error"
+	});
+	esm_default.post("https://legal.example/inbox", {
+		status: 451,
+		body: "Unavailable For Legal Reasons"
+	});
+	function setup(options = {}) {
+		const kv = new MemoryKvStore();
+		const queuedMessages = [];
+		const federation = new FederationImpl({
+			kv,
+			queue: {
+				...options.nativeRetrial ? { nativeRetrial: true } : {},
+				enqueue(message, _options) {
+					queuedMessages.push(message);
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			},
+			...options.permanentFailureStatusCodes ? { permanentFailureStatusCodes: options.permanentFailureStatusCodes } : {},
+			...options.meterProvider ? { meterProvider: options.meterProvider } : {},
+			...options.tracerProvider ? { tracerProvider: options.tracerProvider } : {}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
+		return {
+			federation,
+			queuedMessages
+		};
+	}
+	function createOutboxMessage(inbox, activityId, actorIds) {
+		return {
+			type: "outbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			keys: [],
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: activityId,
+				actor: "https://example.com/users/alice",
+				object: {
+					type: "Note",
+					content: "test"
+				}
+			},
+			activityType: "https://www.w3.org/ns/activitystreams#Create",
+			inbox,
+			sharedInbox: false,
+			...actorIds != null ? { actorIds } : {},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			headers: {},
+			traceContext: {}
+		};
+	}
+	await t.step("410 Gone triggers permanent failure handler", async () => {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const [tracerProvider, exporter] = createTestTracerProvider();
+		const { federation, queuedMessages } = setup({
+			meterProvider,
+			tracerProvider
+		});
+		let handlerCalled = false;
+		let handlerValues = {};
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			handlerCalled = true;
+			handlerValues = { ...values };
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/1", ["https://gone.example/users/bob", "https://gone.example/users/charlie"]));
+		assert(handlerCalled, "Permanent failure handler should be called");
+		assertEquals(handlerValues.inbox, new URL("https://gone.example/inbox"));
+		assertEquals(handlerValues.statusCode, 410);
+		assertInstanceOf(handlerValues.activity, vocab.Create);
+		assertEquals(handlerValues.actorIds, [new URL("https://gone.example/users/bob"), new URL("https://gone.example/users/charlie")]);
+		assertEquals(queuedMessages, []);
+		const failures = recorder.getMeasurements("activitypub.delivery.permanent_failure");
+		assertEquals(failures.length, 1);
+		assertEquals(failures[0].value, 1);
+		assertEquals(failures[0].attributes["activitypub.remote.host"], "gone.example");
+		assertEquals(failures[0].attributes["http.response.status_code"], 410);
+		const abandoned = recorder.getMeasurements("activitypub.outbox.activity");
+		assertEquals(abandoned.length, 1);
+		assertEquals(abandoned[0].attributes["activitypub.processing.result"], "abandoned");
+		assertEquals(abandoned[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		const events = exporter.getEvents("activitypub.outbox", "activitypub.delivery.failed");
+		assertEquals(events.length, 1);
+		assertEquals(events[0].attributes?.["activitypub.remote.host"], "gone.example");
+		assertEquals(events[0].attributes?.["activitypub.delivery.attempt"], 0);
+		assertEquals(events[0].attributes?.["activitypub.delivery.permanent_failure"], true);
+		assertEquals(events[0].attributes?.["http.response.status_code"], 410);
+	});
+	await t.step("404 Not Found triggers permanent failure handler", async () => {
+		const { federation, queuedMessages } = setup();
+		let handlerCalled = false;
+		let handlerStatusCode = 0;
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			handlerCalled = true;
+			handlerStatusCode = values.statusCode;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://notfound.example/inbox", "https://example.com/activity/2", ["https://notfound.example/users/bob"]));
+		assert(handlerCalled, "Permanent failure handler should be called");
+		assertEquals(handlerStatusCode, 404);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("500 error does NOT trigger permanent failure handler", async () => {
+		const { federation, queuedMessages } = setup();
+		let handlerCalled = false;
+		federation.setOutboxPermanentFailureHandler(() => {
+			handlerCalled = true;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://error.example/inbox", "https://example.com/activity/3", ["https://error.example/users/bob"]));
+		assertFalse(handlerCalled, "Permanent failure handler should NOT be called");
+		assertEquals(queuedMessages.length, 1);
+		assertEquals(queuedMessages[0].attempt, 1);
+	});
+	await t.step("custom permanentFailureStatusCodes", async () => {
+		const { federation, queuedMessages } = setup({ permanentFailureStatusCodes: [
+			404,
+			410,
+			451
+		] });
+		let handlerCalled = false;
+		let handlerStatusCode = 0;
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			handlerCalled = true;
+			handlerStatusCode = values.statusCode;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://legal.example/inbox", "https://example.com/activity/4", ["https://legal.example/users/bob"]));
+		assert(handlerCalled, "Permanent failure handler should be called for 451");
+		assertEquals(handlerStatusCode, 451);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("handler exception is caught and logged", async () => {
+		const { federation, queuedMessages } = setup();
+		federation.setOutboxPermanentFailureHandler(() => {
+			throw new Error("Handler error that should be ignored");
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/5", ["https://gone.example/users/bob"]));
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("permanent failure skips retry without handler registered", async () => {
+		const { federation, queuedMessages } = setup();
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/6", []));
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("nativeRetrial: permanent failure does not re-throw", async () => {
+		const { federation, queuedMessages } = setup({ nativeRetrial: true });
+		let handlerCalled = false;
+		federation.setOutboxPermanentFailureHandler(() => {
+			handlerCalled = true;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/7", ["https://gone.example/users/bob"]));
+		assert(handlerCalled, "Permanent failure handler should be called");
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("actorIds missing from message defaults to empty array", async () => {
+		const { federation, queuedMessages } = setup();
+		let handlerActorIds = [];
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			handlerActorIds = values.actorIds;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/8"));
+		assertEquals(handlerActorIds, []);
+		assertEquals(queuedMessages, []);
+	});
+	await t.step("malformed inbox does not break failure handling", async () => {
+		await withLogtapeLock(async () => {
+			const [tracerProvider, exporter] = createTestTracerProvider();
+			const { federation, queuedMessages } = setup({ tracerProvider });
+			const records = [];
+			await reset();
+			try {
+				await configure({
+					sinks: { buffer(record) {
+						records.push(record);
+					} },
+					filters: {},
+					loggers: [{
+						category: [],
+						sinks: ["buffer"]
+					}]
+				});
+				await federation.processQueuedTask(void 0, createOutboxMessage("not a url", "https://example.com/activity/9", ["https://gone.example/users/bob"]));
+				assertEquals(queuedMessages.length, 1);
+				assertEquals(queuedMessages[0].attempt, 1);
+				const events = exporter.getEvents("activitypub.outbox", "activitypub.delivery.failed");
+				assertEquals(events.length, 1);
+				assertEquals(events[0].attributes?.["activitypub.remote.host"], void 0);
+				assertEquals(events[0].attributes?.["activitypub.delivery.attempt"], 0);
+				assertEquals(records.some((record) => record.rawMessage === "Invalid inbox URL in queued outbox message: {inbox}" && record.properties.inbox === "not a url"), true);
+			} finally {
+				await reset();
+			}
+		});
+	});
+	esm_default.hardReset();
+});
+test("FederationImpl.processQueuedTask() circuit breaker", async (t) => {
+	esm_default.spyGlobal();
+	function setup(options, federationOptions = {}, queueOptions = {}) {
+		const kv = new MemoryKvStore();
+		const queued = [];
+		const federation = new FederationImpl({
+			kv,
+			queue: {
+				nativeRetrial: queueOptions.nativeRetrial,
+				enqueue(message, options) {
+					queued.push({
+						message,
+						options
+					});
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			},
+			circuitBreaker: options,
+			...federationOptions
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
+		return {
+			federation,
+			kv,
+			queued
+		};
+	}
+	function createOutboxMessage(inbox, overrides = {}) {
+		return {
+			type: "outbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			keys: [],
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://example.com/activity/circuit",
+				actor: "https://example.com/users/alice",
+				object: {
+					type: "Note",
+					content: "test"
+				}
+			},
+			activityId: "https://example.com/activity/circuit",
+			activityType: "https://www.w3.org/ns/activitystreams#Create",
+			inbox,
+			sharedInbox: false,
+			actorIds: ["https://breaker.example/users/bob"],
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			headers: {},
+			traceContext: {},
+			...overrides
+		};
+	}
+	await t.step("is not created without an outbox queue", () => {
+		assertEquals(new FederationImpl({ kv: new MemoryKvStore() }).circuitBreaker, void 0);
+	});
+	await t.step("5xx opens circuit and holds the failed message", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://breaker.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued, kv } = setup({
+			failureThreshold: 1,
+			failureWindow: { minutes: 10 },
+			recoveryDelay: { minutes: 30 }
+		});
+		const orderingKey = "https://example.com/object/breaker";
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://breaker.example/inbox", { orderingKey }));
+		assertEquals(queued.length, 1);
+		const held = queued[0].message;
+		assertEquals(held.attempt, 0);
+		assertEquals(held.orderingKey, orderingKey);
+		assertEquals(held.circuitHeld, true);
+		assertExists(held.circuitHeldSince);
+		assertEquals(queued[0].options?.orderingKey, orderingKey);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ minutes: 30 }));
+		const state = await kv.get([
+			"_fedify",
+			"circuit",
+			"breaker.example"
+		]);
+		assertEquals(state?.state, "open");
+		assertEquals(Array.isArray(state?.failures), true);
+		assertEquals((state?.failures).length, 1);
+		assertExists(state?.opened);
+	});
+	await t.step("open circuit requeues without sending", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		let requests = 0;
+		esm_default.post("https://open.example/inbox", () => {
+			requests++;
+			return {
+				status: 500,
+				body: "server error"
+			};
+		});
+		const { federation, queued } = setup({
+			failureThreshold: 1,
+			recoveryDelay: { hours: 1 }
+		});
+		const orderingKey = "https://example.com/object/open";
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://open.example/inbox", { orderingKey }));
+		const held = queued[0].message;
+		queued.length = 0;
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://open.example/inbox", {
+			circuitHeld: true,
+			circuitHeldSince: held.circuitHeldSince,
+			orderingKey
+		}));
+		assertEquals(requests, 1);
+		assertEquals(queued.length, 1);
+		const requeued = queued[0].message;
+		assertEquals(requeued.attempt, 0);
+		assertEquals(requeued.orderingKey, orderingKey);
+		assertEquals(requeued.circuitHeld, true);
+		assertEquals(requeued.circuitHeldSince, held.circuitHeldSince);
+		assertEquals(queued[0].options?.orderingKey, orderingKey);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ hours: 1 }));
+	});
+	await t.step("circuit keys include non-default ports", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		let defaultPortRequests = 0;
+		esm_default.post("https://ports.example:8443/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		esm_default.post("https://ports.example/inbox", () => {
+			defaultPortRequests++;
+			return {
+				status: 202,
+				body: ""
+			};
+		});
+		const { federation, queued, kv } = setup({
+			failureThreshold: 1,
+			recoveryDelay: { hours: 1 }
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://ports.example:8443/inbox"));
+		assertEquals((await kv.get([
+			"_fedify",
+			"circuit",
+			"ports.example:8443"
+		]))?.state, "open");
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"ports.example"
+		]), void 0);
+		queued.length = 0;
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://ports.example/inbox"));
+		assertEquals(defaultPortRequests, 1);
+		assertEquals(queued, []);
+	});
+	await t.step("post-send circuit errors do not retry delivery", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://success-bookkeeping.example/inbox", {
+			status: 202,
+			body: ""
+		});
+		const { federation, queued, kv } = setup({ failureThreshold: 1 });
+		await kv.set([
+			"_fedify",
+			"circuit",
+			"success-bookkeeping.example"
+		], {
+			state: "closed",
+			failures: []
+		});
+		kv.cas = () => Promise.resolve(false);
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://success-bookkeeping.example/inbox"));
+		assertEquals(queued, []);
+	});
+	await t.step("pre-send circuit errors do not block delivery", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		let requests = 0;
+		esm_default.post("https://presend-bookkeeping.example/inbox", () => {
+			requests++;
+			return {
+				status: 202,
+				body: ""
+			};
+		});
+		const { federation, queued, kv } = setup({ failureThreshold: 1 });
+		kv.get = () => Promise.reject(/* @__PURE__ */ new Error("kv get failed"));
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://presend-bookkeeping.example/inbox"));
+		assertEquals(requests, 1);
+		assertEquals(queued, []);
+	});
+	await t.step("circuit failure errors fall back to retry", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://failure-bookkeeping.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued, kv } = setup({ failureThreshold: 1 }, { outboxRetryPolicy: () => Temporal.Duration.from({ seconds: 3 }) });
+		kv.cas = () => Promise.resolve(false);
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://failure-bookkeeping.example/inbox"));
+		assertEquals(queued.length, 1);
+		const retry = queued[0].message;
+		assertEquals(retry.attempt, 1);
+		assertEquals(retry.circuitHeld, void 0);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ seconds: 3 }));
+	});
+	await t.step("local delivery errors do not open circuit", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		const { federation, queued, kv } = setup({ failureThreshold: 1 }, { outboxRetryPolicy: () => Temporal.Duration.from({ seconds: 3 }) });
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://local-error.example/inbox", { headers: { "Invalid Header": "x" } }));
+		assertEquals(queued.length, 1);
+		const retry = queued[0].message;
+		assertEquals(retry.attempt, 1);
+		assertEquals(retry.circuitHeld, void 0);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ seconds: 3 }));
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"local-error.example"
+		]), void 0);
+	});
+	await t.step("calendar retry delays are enqueued", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://calendar-delay.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued } = setup({ failureThreshold: 5 }, { outboxRetryPolicy: () => Temporal.Duration.from({ days: 1 }) });
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://calendar-delay.example/inbox"));
+		assertEquals(queued.length, 1);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ days: 1 }));
+	});
+	await t.step("negative calendar retry delays are clamped", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://negative-calendar-delay.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued } = setup({ failureThreshold: 5 }, { outboxRetryPolicy: () => Temporal.Duration.from({ days: -1 }) });
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://negative-calendar-delay.example/inbox"));
+		assertEquals(queued.length, 1);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ seconds: 0 }));
+	});
+	await t.step("circuit hold respects retry give-up", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://hold-give-up.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued, kv } = setup({
+			failureThreshold: 1,
+			recoveryDelay: { minutes: 30 }
+		}, { outboxRetryPolicy: () => null });
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://hold-give-up.example/inbox"));
+		assertEquals(queued, []);
+		assertEquals((await kv.get([
+			"_fedify",
+			"circuit",
+			"hold-give-up.example"
+		]))?.state, "open");
+	});
+	await t.step("circuit decision errors fall back to retry", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://decision-bookkeeping.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued, kv } = setup({ failureThreshold: 1 }, { outboxRetryPolicy: () => Temporal.Duration.from({ seconds: 4 }) });
+		const originalGet = kv.get.bind(kv);
+		let getCalls = 0;
+		kv.get = (...args) => {
+			getCalls++;
+			return getCalls === 1 ? originalGet(...args) : Promise.reject(/* @__PURE__ */ new Error("kv get failed"));
+		};
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://decision-bookkeeping.example/inbox"));
+		assertEquals(queued.length, 1);
+		const retry = queued[0].message;
+		assertEquals(retry.attempt, 1);
+		assertEquals(retry.circuitHeld, void 0);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ seconds: 4 }));
+	});
+	await t.step("circuit reachable errors keep permanent failure", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://permanent-bookkeeping.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued, kv } = setup({ failureThreshold: 1 }, { permanentFailureStatusCodes: [500] });
+		await kv.set([
+			"_fedify",
+			"circuit",
+			"permanent-bookkeeping.example"
+		], {
+			state: "half-open",
+			failures: ["2026-05-25T00:00:00Z"],
+			opened: "2026-05-25T00:00:00Z",
+			halfOpened: "2026-05-25T00:00:00Z"
+		});
+		const originalCas = kv.cas.bind(kv);
+		let casCalls = 0;
+		kv.cas = (...args) => {
+			casCalls++;
+			return casCalls === 1 ? originalCas(...args) : Promise.resolve(false);
+		};
+		let permanentFailureStatusCode;
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			permanentFailureStatusCode = values.statusCode;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://permanent-bookkeeping.example/inbox"));
+		assertEquals(queued, []);
+		assertEquals(permanentFailureStatusCode, 500);
+	});
+	await t.step("429 respects Retry-After without opening circuit", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://rate.example/inbox", {
+			status: 429,
+			headers: { "Retry-After": "120" },
+			body: "rate limited"
+		});
+		const { federation, queued, kv } = setup({
+			failureThreshold: 1,
+			recoveryDelay: { minutes: 30 }
+		});
+		const orderingKey = "https://example.com/object/rate";
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://rate.example/inbox", { orderingKey }));
+		assertEquals(queued.length, 1);
+		const retry = queued[0].message;
+		assertEquals(retry.attempt, 1);
+		assertEquals(retry.orderingKey, orderingKey);
+		assertEquals(retry.circuitHeld, void 0);
+		assertEquals(queued[0].options?.orderingKey, orderingKey);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ seconds: 120 }));
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"rate.example"
+		]), void 0);
+	});
+	await t.step("429 respects Retry-After with circuit breaker disabled", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://rate-disabled.example/inbox", {
+			status: 429,
+			headers: { "Retry-After": "120" },
+			body: "rate limited"
+		});
+		const { federation, queued, kv } = setup(false, {}, { nativeRetrial: true });
+		assertEquals(federation.circuitBreaker, void 0);
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://rate-disabled.example/inbox", { orderingKey: "https://example.com/object/rate-limited" }));
+		assertEquals(queued.length, 1);
+		const retry = queued[0].message;
+		assertEquals(retry.attempt, 1);
+		assertEquals(retry.circuitHeld, void 0);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ seconds: 120 }));
+		assertEquals(queued[0].options?.orderingKey, "https://example.com/object/rate-limited");
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"rate-disabled.example"
+		]), void 0);
+	});
+	await t.step("429 Retry-After still respects retry give-up", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://give-up.example/inbox", {
+			status: 429,
+			headers: { "Retry-After": "120" },
+			body: "rate limited"
+		});
+		const { federation, queued, kv } = setup({ failureThreshold: 1 }, { outboxRetryPolicy: () => null });
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://give-up.example/inbox"));
+		assertEquals(queued, []);
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"give-up.example"
+		]), void 0);
+	});
+	await t.step("503 respects Retry-After while counting failure", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://unavailable.example/inbox", {
+			status: 503,
+			headers: { "Retry-After": "120" },
+			body: "temporarily unavailable"
+		});
+		const { federation, queued, kv } = setup({
+			failureThreshold: 5,
+			failureWindow: { minutes: 10 }
+		}, { outboxRetryPolicy: () => Temporal.Duration.from({ seconds: 3 }) });
+		const orderingKey = "https://example.com/object/unavailable";
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://unavailable.example/inbox", { orderingKey }));
+		assertEquals(queued.length, 1);
+		const retry = queued[0].message;
+		assertEquals(retry.attempt, 1);
+		assertEquals(retry.circuitHeld, void 0);
+		assertEquals(retry.orderingKey, orderingKey);
+		assertEquals(queued[0].options?.delay, Temporal.Duration.from({ seconds: 120 }));
+		assertEquals(queued[0].options?.orderingKey, orderingKey);
+		const state = await kv.get([
+			"_fedify",
+			"circuit",
+			"unavailable.example"
+		]);
+		assertEquals(state?.state, "closed");
+		assertEquals((state?.failures).length, 1);
+	});
+	await t.step("503 Retry-After delays newly opened circuit hold", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://open-retry-after.example/inbox", {
+			status: 503,
+			headers: { "Retry-After": "3600" },
+			body: "temporarily unavailable"
+		});
+		const { federation, queued, kv } = setup({
+			failureThreshold: 1,
+			recoveryDelay: { seconds: 30 }
+		}, { outboxRetryPolicy: () => Temporal.Duration.from({ seconds: 3 }) });
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://open-retry-after.example/inbox"));
+		assertEquals(queued.length, 1);
+		const held = queued[0].message;
+		assertEquals(held.attempt, 0);
+		assertEquals(held.circuitHeld, true);
+		assertEquals(queued[0].options?.delay?.toString(), "PT3600S");
+		assertEquals((await kv.get([
+			"_fedify",
+			"circuit",
+			"open-retry-after.example"
+		]))?.state, "open");
 	});
-	esm_default.post("https://error.example/inbox", {
-		status: 500,
-		body: "Internal Server Error"
+	await t.step("malformed Retry-After falls back to retry policy", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://huge-retry-after.example/inbox", {
+			status: 429,
+			headers: { "Retry-After": "999999999999999999999999999999" },
+			body: "rate limited"
+		});
+		const { federation, queued, kv } = setup({ failureThreshold: 1 }, { outboxRetryPolicy: () => Temporal.Duration.from({ seconds: 3 }) });
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://huge-retry-after.example/inbox"));
+		assertEquals(queued.length, 1);
+		assertEquals(queued[0].options?.delay?.total({ unit: "second" }), 3);
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"huge-retry-after.example"
+		]), void 0);
 	});
-	esm_default.post("https://legal.example/inbox", {
-		status: 451,
-		body: "Unavailable For Legal Reasons"
+	await t.step("invalid Retry-After date falls back to retry policy", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://invalid-retry-after.example/inbox", {
+			status: 429,
+			headers: { "Retry-After": "1.5" },
+			body: "rate limited"
+		});
+		const { federation, queued, kv } = setup({ failureThreshold: 1 }, { outboxRetryPolicy: () => Temporal.Duration.from({ seconds: 3 }) });
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://invalid-retry-after.example/inbox"));
+		assertEquals(queued.length, 1);
+		assertEquals(queued[0].options?.delay?.total({ unit: "second" }), 3);
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"invalid-retry-after.example"
+		]), void 0);
 	});
-	function setup(options = {}) {
+	await t.step("asctime Retry-After date is interpreted as UTC", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		const retryAfter = "Wed Dec 31 23:59:59 2036";
+		esm_default.post("https://asctime-retry-after.example/inbox", {
+			status: 429,
+			headers: { "Retry-After": retryAfter },
+			body: "rate limited"
+		});
+		const { federation, queued } = setup({ failureThreshold: 1 }, { outboxRetryPolicy: () => Temporal.Duration.from({ seconds: 3 }) });
+		const before = Temporal.Now.instant();
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://asctime-retry-after.example/inbox"));
+		const after = Temporal.Now.instant();
+		const retryAtMs = Date.parse(`${retryAfter} GMT`);
+		assertEquals(queued.length, 1);
+		const delayMs = queued[0].options?.delay?.total({ unit: "millisecond" });
+		assertExists(delayMs);
+		assertEquals(delayMs <= retryAtMs - before.epochMilliseconds, true);
+		assertEquals(delayMs >= retryAtMs - after.epochMilliseconds, true);
+	});
+	await t.step("permanent 5xx does not open circuit", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://permanent-500.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued, kv } = setup({ failureThreshold: 1 }, { permanentFailureStatusCodes: [500] });
+		let permanentFailureStatusCode;
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			permanentFailureStatusCode = values.statusCode;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://permanent-500.example/inbox"));
+		assertEquals(queued, []);
+		assertEquals(permanentFailureStatusCode, 500);
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"permanent-500.example"
+		]), void 0);
+	});
+	await t.step("permanent 5xx closes half-open circuit", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://permanent-probe.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued, kv } = setup({
+			failureThreshold: 1,
+			releaseInterval: { seconds: 1 }
+		}, { permanentFailureStatusCodes: [500] });
+		await kv.set([
+			"_fedify",
+			"circuit",
+			"permanent-probe.example"
+		], {
+			state: "half-open",
+			failures: ["2026-05-25T00:00:00Z"],
+			opened: "2026-05-25T00:00:00Z",
+			halfOpened: "2026-05-25T00:00:00Z"
+		});
+		let permanentFailureStatusCode;
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			permanentFailureStatusCode = values.statusCode;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://permanent-probe.example/inbox"));
+		assertEquals(queued, []);
+		assertEquals(permanentFailureStatusCode, 500);
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"permanent-probe.example"
+		]), void 0);
+	});
+	await t.step("permanent 4xx closes half-open circuit", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://gone.example/inbox", {
+			status: 410,
+			body: "gone"
+		});
+		const { federation, queued, kv } = setup({
+			failureThreshold: 1,
+			releaseInterval: { seconds: 1 }
+		});
+		await kv.set([
+			"_fedify",
+			"circuit",
+			"gone.example"
+		], {
+			state: "half-open",
+			failures: ["2026-05-25T00:00:00Z"],
+			opened: "2026-05-25T00:00:00Z",
+			halfOpened: "2026-05-25T00:00:00Z"
+		});
+		let permanentFailureStatusCode;
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			permanentFailureStatusCode = values.statusCode;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox"));
+		assertEquals(queued, []);
+		assertEquals(permanentFailureStatusCode, 410);
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"gone.example"
+		]), void 0);
+	});
+	await t.step("false disables circuit handling", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://disabled.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const { federation, queued, kv } = setup(false);
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://disabled.example/inbox"));
+		assertEquals(queued.length, 1);
+		const retry = queued[0].message;
+		assertEquals(retry.attempt, 1);
+		assertEquals(retry.circuitHeld, void 0);
+		assertEquals(await kv.get([
+			"_fedify",
+			"circuit",
+			"disabled.example"
+		]), void 0);
+	});
+	await t.step("state changes are recorded in metrics and spans", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://telemetry.example/inbox", {
+			status: 500,
+			body: "server error"
+		});
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const [tracerProvider, exporter] = createTestTracerProvider();
+		const { federation, queued } = setup({ failureThreshold: 1 }, {
+			meterProvider,
+			tracerProvider
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://telemetry.example/inbox"));
+		assertEquals(queued.length, 1);
+		const measurements = recorder.getMeasurements("activitypub.circuit_breaker.state_change");
+		assertEquals(measurements.length, 1);
+		assertEquals(measurements[0].attributes["activitypub.remote.host"], "telemetry.example");
+		assertEquals(measurements[0].attributes["activitypub.circuit_breaker.state"], "open");
+		const events = exporter.getEvents("activitypub.outbox", "activitypub.circuit_breaker.state_change");
+		assertEquals(events.length, 1);
+		assertEquals(events[0].attributes?.["activitypub.remote.host"], "telemetry.example");
+		assertEquals(events[0].attributes?.["activitypub.circuit_breaker.previous_state"], "closed");
+		assertEquals(events[0].attributes?.["activitypub.circuit_breaker.state"], "open");
+		const heldEvents = exporter.getEvents("activitypub.outbox", "activitypub.circuit_breaker.held");
+		assertEquals(heldEvents.length, 1);
+		assertEquals(heldEvents[0].attributes?.["activitypub.remote.host"], "telemetry.example");
+		assertEquals(heldEvents[0].attributes?.["activitypub.circuit_breaker.state"], "open");
+	});
+	await t.step("held half-open circuit is recorded in spans", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		const now = Temporal.Instant.from("2026-05-25T00:00:30Z");
+		const [tracerProvider, exporter] = createTestTracerProvider();
+		const { federation, queued, kv } = setup({
+			failureThreshold: 1,
+			recoveryDelay: { minutes: 5 },
+			releaseInterval: { minutes: 1 }
+		}, { tracerProvider });
+		federation.circuitBreaker = new CircuitBreaker({
+			kv,
+			prefix: ["_fedify", "circuit"],
+			now: () => now,
+			options: {
+				failureThreshold: 1,
+				recoveryDelay: { minutes: 5 },
+				releaseInterval: { minutes: 1 }
+			}
+		});
+		await kv.set([
+			"_fedify",
+			"circuit",
+			"half-open-telemetry.example"
+		], {
+			state: "half-open",
+			failures: ["2026-05-25T00:00:00Z"],
+			opened: "2026-05-25T00:00:00Z",
+			halfOpened: "2026-05-25T00:00:00Z"
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://half-open-telemetry.example/inbox", {
+			circuitHeld: true,
+			circuitHeldSince: "2026-05-25T00:00:00Z"
+		}));
+		assertEquals(queued.length, 1);
+		const events = exporter.getEvents("activitypub.outbox", "activitypub.circuit_breaker.held");
+		assertEquals(events.length, 1);
+		assertEquals(events[0].attributes?.["activitypub.remote.host"], "half-open-telemetry.example");
+		assertEquals(events[0].attributes?.["activitypub.circuit_breaker.state"], "half_open");
+	});
+	await t.step("stale half-open probe does not record open transition", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		esm_default.post("https://stale-probe-telemetry.example/inbox", {
+			status: 202,
+			body: ""
+		});
+		const now = Temporal.Instant.from("2026-05-25T00:00:02Z");
+		const [tracerProvider, exporter] = createTestTracerProvider();
+		const { federation, kv } = setup({
+			failureThreshold: 1,
+			recoveryDelay: { seconds: 1 }
+		}, { tracerProvider });
+		federation.circuitBreaker = new CircuitBreaker({
+			kv,
+			prefix: ["_fedify", "circuit"],
+			now: () => now,
+			options: {
+				failureThreshold: 1,
+				recoveryDelay: { seconds: 1 }
+			}
+		});
+		await kv.set([
+			"_fedify",
+			"circuit",
+			"stale-probe-telemetry.example"
+		], {
+			state: "half-open",
+			failures: ["2026-05-25T00:00:00Z"],
+			opened: "2026-05-25T00:00:00Z",
+			halfOpened: "2026-05-25T00:00:00Z"
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://stale-probe-telemetry.example/inbox"));
+		const events = exporter.getEvents("activitypub.outbox", "activitypub.circuit_breaker.state_change");
+		assertEquals(events.length, 1);
+		assertEquals(events[0].attributes?.["activitypub.circuit_breaker.previous_state"], "half_open");
+		assertEquals(events[0].attributes?.["activitypub.circuit_breaker.state"], "closed");
+	});
+	await t.step("expired held activity is dropped", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		const now = Temporal.Instant.from("2026-05-25T00:00:02Z");
+		let dropped = null;
+		const { federation, queued, kv } = setup(false);
+		federation.circuitBreaker = new CircuitBreaker({
+			kv,
+			prefix: ["_fedify", "circuit"],
+			now: () => now,
+			options: {
+				failureThreshold: 1,
+				heldActivityTtl: { seconds: 1 },
+				onActivityDrop(remoteHost, details) {
+					dropped = {
+						remoteHost,
+						heldSince: details.heldSince
+					};
+				}
+			}
+		});
+		let permanentFailureReason;
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			permanentFailureReason = values.reason;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://ttl.example/inbox", {
+			circuitHeld: true,
+			circuitHeldSince: "2026-05-25T00:00:00Z"
+		}));
+		assertEquals(queued, []);
+		assertEquals(dropped, {
+			remoteHost: "ttl.example",
+			heldSince: Temporal.Instant.from("2026-05-25T00:00:00Z")
+		});
+		assertEquals(permanentFailureReason, "circuit-breaker-ttl");
+	});
+	await t.step("expired held probe is dropped after failed send", async () => {
+		esm_default.hardReset();
+		esm_default.spyGlobal();
+		let now = Temporal.Instant.from("2026-05-25T00:00:01Z");
+		const heldSince = Temporal.Instant.from("2026-05-25T00:00:00Z");
+		esm_default.post("https://expired-probe.example/inbox", () => {
+			now = Temporal.Instant.from("2026-05-25T00:00:03Z");
+			return {
+				status: 500,
+				body: "server error"
+			};
+		});
+		let dropped = null;
+		const { federation, queued, kv } = setup({
+			failureThreshold: 1,
+			recoveryDelay: { seconds: 1 },
+			heldActivityTtl: { seconds: 2 },
+			releaseInterval: { seconds: 1 }
+		});
+		federation.circuitBreaker = new CircuitBreaker({
+			kv,
+			prefix: ["_fedify", "circuit"],
+			now: () => now,
+			options: {
+				failureThreshold: 1,
+				recoveryDelay: { seconds: 1 },
+				heldActivityTtl: { seconds: 2 },
+				releaseInterval: { seconds: 1 },
+				onActivityDrop(remoteHost, details) {
+					dropped = {
+						remoteHost,
+						heldSince: details.heldSince
+					};
+				}
+			}
+		});
+		await kv.set([
+			"_fedify",
+			"circuit",
+			"expired-probe.example"
+		], {
+			state: "half-open",
+			failures: ["2026-05-25T00:00:00Z"],
+			opened: "2026-05-25T00:00:00Z",
+			halfOpened: "2026-05-25T00:00:00Z"
+		});
+		let permanentFailureReason;
+		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
+			permanentFailureReason = values.reason;
+		});
+		await federation.processQueuedTask(void 0, createOutboxMessage("https://expired-probe.example/inbox", {
+			circuitHeld: true,
+			circuitHeldSince: heldSince.toString()
+		}));
+		assertEquals(queued, []);
+		assertEquals(dropped, {
+			remoteHost: "expired-probe.example",
+			heldSince
+		});
+		assertEquals(permanentFailureReason, "circuit-breaker-ttl");
+	});
+	esm_default.hardReset();
+});
+test("FederationImpl.processQueuedTask() queue task metrics", async (t) => {
+	await t.step("records failed result when worker re-throws (nativeRetrial)", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = new FederationImpl({
+			kv,
+			meterProvider,
+			queue: {
+				nativeRetrial: true,
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(vocab.Create, () => {
+			throw new Error("Intended error for testing");
+		});
+		await assertRejects(() => federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://remote.example/activities/2",
+				actor: "https://remote.example/users/alice",
+				object: {
+					type: "Note",
+					content: "Hello world"
+				}
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		}), Error);
+		assertEquals(recorder.getMeasurements("fedify.queue.task.completed").length, 0);
+		const failed = recorder.getMeasurements("fedify.queue.task.failed");
+		assertEquals(failed.length, 1);
+		assertEquals(failed[0].attributes["fedify.queue.role"], "inbox");
+		assertEquals(failed[0].attributes["fedify.queue.task.result"], "failed");
+		assertEquals(failed[0].attributes["fedify.queue.native_retrial"], true);
+		assertEquals(failed[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		const taskDurations = recorder.getMeasurements("fedify.queue.task.duration");
+		assertEquals(taskDurations.length, 1);
+		assertEquals(taskDurations[0].attributes["fedify.queue.task.result"], "failed");
+		const inFlight = recorder.getMeasurements("fedify.queue.task.in_flight");
+		assertEquals(inFlight.length, 2);
+		assertEquals(inFlight[0].value, 1);
+		assertEquals(inFlight[1].value, -1);
+		assertEquals(inFlight[0].attributes, inFlight[1].attributes);
+	});
+	await t.step("records completed when retry handler swallows listener error", async () => {
 		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
 		const queuedMessages = [];
 		const federation = new FederationImpl({
 			kv,
+			meterProvider,
 			queue: {
-				...options.nativeRetrial ? { nativeRetrial: true } : {},
 				enqueue(message, _options) {
 					queuedMessages.push(message);
 					return Promise.resolve();
@@ -2087,132 +5582,233 @@ test("FederationImpl.processQueuedTask() permanent failure", async (t) => {
 				listen(_handler, _options) {
 					return Promise.resolve();
 				}
-			},
-			...options.permanentFailureStatusCodes ? { permanentFailureStatusCodes: options.permanentFailureStatusCodes } : {}
+			}
 		});
-		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
-		return {
-			federation,
-			queuedMessages
-		};
-	}
-	function createOutboxMessage(inbox, activityId, actorIds) {
-		return {
-			type: "outbox",
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(vocab.Create, () => {
+			throw new Error("Intended error for testing");
+		});
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
 			id: crypto.randomUUID(),
 			baseUrl: "https://example.com",
-			keys: [],
 			activity: {
 				"@context": "https://www.w3.org/ns/activitystreams",
 				type: "Create",
-				id: activityId,
-				actor: "https://example.com/users/alice",
+				id: "https://remote.example/activities/retry",
+				actor: "https://remote.example/users/alice",
 				object: {
 					type: "Note",
-					content: "test"
+					content: "Hello world"
 				}
 			},
-			activityType: "https://www.w3.org/ns/activitystreams#Create",
-			inbox,
-			sharedInbox: false,
-			...actorIds != null ? { actorIds } : {},
 			started: (/* @__PURE__ */ new Date()).toISOString(),
 			attempt: 0,
-			headers: {},
+			identifier: null,
 			traceContext: {}
-		};
-	}
-	await t.step("410 Gone triggers permanent failure handler", async () => {
-		const { federation, queuedMessages } = setup();
-		let handlerCalled = false;
-		let handlerValues = {};
-		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
-			handlerCalled = true;
-			handlerValues = { ...values };
 		});
-		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/1", ["https://gone.example/users/bob", "https://gone.example/users/charlie"]));
-		assert(handlerCalled, "Permanent failure handler should be called");
-		assertEquals(handlerValues.inbox, new URL("https://gone.example/inbox"));
-		assertEquals(handlerValues.statusCode, 410);
-		assertInstanceOf(handlerValues.activity, vocab.Create);
-		assertEquals(handlerValues.actorIds, [new URL("https://gone.example/users/bob"), new URL("https://gone.example/users/charlie")]);
-		assertEquals(queuedMessages, []);
+		assertEquals(queuedMessages.length, 1);
+		const completed = recorder.getMeasurements("fedify.queue.task.completed");
+		assertEquals(completed.length, 1);
+		assertEquals(completed[0].attributes["fedify.queue.task.result"], "completed");
+		const enqueued = recorder.getMeasurements("fedify.queue.task.enqueued");
+		assertEquals(enqueued.length, 1);
+		assertEquals(enqueued[0].attributes["fedify.queue.role"], "inbox");
+		assertEquals(enqueued[0].attributes["fedify.queue.task.attempt"], 1);
+		assertEquals(enqueued[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
 	});
-	await t.step("404 Not Found triggers permanent failure handler", async () => {
-		const { federation, queuedMessages } = setup();
-		let handlerCalled = false;
-		let handlerStatusCode = 0;
-		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
-			handlerCalled = true;
-			handlerStatusCode = values.statusCode;
+	await t.step("records aborted result when worker re-throws AbortError", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const [tracerProvider, exporter] = createTestTracerProvider();
+		const federation = new FederationImpl({
+			kv,
+			meterProvider,
+			tracerProvider,
+			queue: {
+				nativeRetrial: true,
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			}
 		});
-		await federation.processQueuedTask(void 0, createOutboxMessage("https://notfound.example/inbox", "https://example.com/activity/2", ["https://notfound.example/users/bob"]));
-		assert(handlerCalled, "Permanent failure handler should be called");
-		assertEquals(handlerStatusCode, 404);
-		assertEquals(queuedMessages, []);
-	});
-	await t.step("500 error does NOT trigger permanent failure handler", async () => {
-		const { federation, queuedMessages } = setup();
-		let handlerCalled = false;
-		federation.setOutboxPermanentFailureHandler(() => {
-			handlerCalled = true;
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(vocab.Create, () => {
+			throw new DOMException("aborted", "AbortError");
 		});
-		await federation.processQueuedTask(void 0, createOutboxMessage("https://error.example/inbox", "https://example.com/activity/3", ["https://error.example/users/bob"]));
-		assertFalse(handlerCalled, "Permanent failure handler should NOT be called");
-		assertEquals(queuedMessages.length, 1);
-		assertEquals(queuedMessages[0].attempt, 1);
+		await assertRejects(() => federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://remote.example/activities/3",
+				actor: "https://remote.example/users/alice",
+				object: {
+					type: "Note",
+					content: "Hello world"
+				}
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
+		}), DOMException);
+		assertEquals(recorder.getMeasurements("fedify.queue.task.failed").length, 0);
+		assertEquals(recorder.getMeasurements("fedify.queue.task.completed").length, 0);
+		const taskDurations = recorder.getMeasurements("fedify.queue.task.duration");
+		assertEquals(taskDurations.length, 1);
+		assertEquals(taskDurations[0].attributes["fedify.queue.task.result"], "aborted");
+		const inboxSpans = exporter.getSpans("activitypub.inbox");
+		assertEquals(inboxSpans.length, 1);
+		assertEquals(inboxSpans[0].status.code, SpanStatusCode.UNSET);
 	});
-	await t.step("custom permanentFailureStatusCodes", async () => {
-		const { federation, queuedMessages } = setup({ permanentFailureStatusCodes: [
-			404,
-			410,
-			451
-		] });
-		let handlerCalled = false;
-		let handlerStatusCode = 0;
-		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
-			handlerCalled = true;
-			handlerStatusCode = values.statusCode;
+	await t.step("records native_retrial and backend attributes", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		class TestMessageQueue {
+			nativeRetrial = true;
+			enqueue(_message, _options) {
+				return Promise.resolve();
+			}
+			listen(_handler, _options) {
+				return Promise.resolve();
+			}
+		}
+		const federation = new FederationImpl({
+			kv,
+			meterProvider,
+			queue: new TestMessageQueue()
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(vocab.Create, () => {});
+		await federation.processQueuedTask(void 0, {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://remote.example/activities/4",
+				actor: "https://remote.example/users/alice",
+				object: {
+					type: "Note",
+					content: "Hello world"
+				}
+			},
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			attempt: 0,
+			identifier: null,
+			traceContext: {}
 		});
-		await federation.processQueuedTask(void 0, createOutboxMessage("https://legal.example/inbox", "https://example.com/activity/4", ["https://legal.example/users/bob"]));
-		assert(handlerCalled, "Permanent failure handler should be called for 451");
-		assertEquals(handlerStatusCode, 451);
-		assertEquals(queuedMessages, []);
+		const completed = recorder.getMeasurements("fedify.queue.task.completed");
+		assertEquals(completed.length, 1);
+		assertEquals(completed[0].attributes["fedify.queue.backend"], "TestMessageQueue");
+		assertEquals(completed[0].attributes["fedify.queue.native_retrial"], true);
 	});
-	await t.step("handler exception is caught and logged", async () => {
-		const { federation, queuedMessages } = setup();
-		federation.setOutboxPermanentFailureHandler(() => {
-			throw new Error("Handler error that should be ignored");
+	await t.step("records outbox worker metrics on successful delivery", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = new FederationImpl({
+			kv,
+			meterProvider,
+			queue: {
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			}
 		});
-		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/5", ["https://gone.example/users/bob"]));
-		assertEquals(queuedMessages, []);
-	});
-	await t.step("permanent failure skips retry without handler registered", async () => {
-		const { federation, queuedMessages } = setup();
-		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/6", []));
-		assertEquals(queuedMessages, []);
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
+		esm_default.spyGlobal();
+		esm_default.post("https://remote.example/inbox", { status: 202 });
+		try {
+			await federation.processQueuedTask(void 0, {
+				type: "outbox",
+				id: crypto.randomUUID(),
+				baseUrl: "https://example.com",
+				keys: [],
+				activity: {
+					"@context": "https://www.w3.org/ns/activitystreams",
+					type: "Create",
+					id: "https://example.com/activities/1",
+					actor: "https://example.com/users/alice",
+					object: {
+						type: "Note",
+						content: "test"
+					}
+				},
+				activityType: "https://www.w3.org/ns/activitystreams#Create",
+				inbox: "https://remote.example/inbox",
+				sharedInbox: false,
+				started: (/* @__PURE__ */ new Date()).toISOString(),
+				attempt: 0,
+				headers: {},
+				traceContext: {}
+			});
+		} finally {
+			esm_default.hardReset();
+		}
+		const started = recorder.getMeasurements("fedify.queue.task.started");
+		assertEquals(started.length, 1);
+		assertEquals(started[0].attributes["fedify.queue.role"], "outbox");
+		assertEquals(started[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		const completed = recorder.getMeasurements("fedify.queue.task.completed");
+		assertEquals(completed.length, 1);
+		assertEquals(completed[0].attributes["fedify.queue.task.result"], "completed");
+		assertEquals(recorder.getMeasurements("fedify.queue.task.enqueued").length, 0);
 	});
-	await t.step("nativeRetrial: permanent failure does not re-throw", async () => {
-		const { federation, queuedMessages } = setup({ nativeRetrial: true });
-		let handlerCalled = false;
-		federation.setOutboxPermanentFailureHandler(() => {
-			handlerCalled = true;
+	await t.step("records started/completed for a fanout task with no recipients", async () => {
+		const kv = new MemoryKvStore();
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const exportedKey = await crypto.subtle.exportKey("jwk", rsaPrivateKey3);
+		const federation = new FederationImpl({
+			kv,
+			meterProvider,
+			queue: {
+				enqueue(_message, _options) {
+					return Promise.resolve();
+				},
+				listen(_handler, _options) {
+					return Promise.resolve();
+				}
+			}
 		});
-		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/7", ["https://gone.example/users/bob"]));
-		assert(handlerCalled, "Permanent failure handler should be called");
-		assertEquals(queuedMessages, []);
-	});
-	await t.step("actorIds missing from message defaults to empty array", async () => {
-		const { federation, queuedMessages } = setup();
-		let handlerActorIds = [];
-		federation.setOutboxPermanentFailureHandler((_ctx, values) => {
-			handlerActorIds = values.actorIds;
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
+		await federation.processQueuedTask(void 0, {
+			type: "fanout",
+			id: crypto.randomUUID(),
+			baseUrl: "https://example.com",
+			keys: [{
+				keyId: "https://example.com/users/alice#main-key",
+				privateKey: exportedKey
+			}],
+			inboxes: {},
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://example.com/activities/1",
+				actor: "https://example.com/users/alice",
+				object: {
+					type: "Note",
+					content: "test"
+				}
+			},
+			activityType: "https://www.w3.org/ns/activitystreams#Create",
+			traceContext: {}
 		});
-		await federation.processQueuedTask(void 0, createOutboxMessage("https://gone.example/inbox", "https://example.com/activity/8"));
-		assertEquals(handlerActorIds, []);
-		assertEquals(queuedMessages, []);
+		const started = recorder.getMeasurements("fedify.queue.task.started");
+		assertEquals(started.length, 1);
+		assertEquals(started[0].attributes["fedify.queue.role"], "fanout");
+		assertEquals(started[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		const completed = recorder.getMeasurements("fedify.queue.task.completed");
+		assertEquals(completed.length, 1);
+		assertEquals(completed[0].attributes["fedify.queue.role"], "fanout");
+		assertEquals(completed[0].attributes["fedify.queue.task.result"], "completed");
 	});
-	esm_default.hardReset();
 });
 test("ContextImpl.lookupObject()", async (t) => {
 	esm_default.spyGlobal();
@@ -2770,6 +6366,66 @@ test("ContextImpl.sendActivity()", async (t) => {
 	});
 	esm_default.hardReset();
 });
+test("ContextImpl.sendActivity() records fanout recipient metrics", async () => {
+	const kv = new MemoryKvStore();
+	const [meterProvider, recorder] = createTestMeterProvider();
+	const queue = {
+		messages: [],
+		enqueue(message) {
+			this.messages.push(message);
+			return Promise.resolve();
+		},
+		async listen() {}
+	};
+	const federation = new FederationImpl({
+		kv,
+		contextLoaderFactory: () => mockDocumentLoader,
+		queue,
+		meterProvider
+	});
+	federation.setActorDispatcher("/{identifier}", async (ctx, identifier) => {
+		if (identifier !== "john") return null;
+		const keys = await ctx.getActorKeyPairs(identifier);
+		return new vocab.Person({
+			id: ctx.getActorUri(identifier),
+			preferredUsername: "john",
+			publicKey: keys[0].cryptographicKey,
+			assertionMethods: keys.map((k) => k.multikey)
+		});
+	}).setKeyPairsDispatcher((_ctx, identifier) => {
+		if (identifier !== "john") return [];
+		return [{
+			privateKey: rsaPrivateKey2,
+			publicKey: rsaPublicKey2.publicKey
+		}, {
+			privateKey: ed25519PrivateKey,
+			publicKey: ed25519PublicKey.publicKey
+		}];
+	});
+	const ctx = new ContextImpl({
+		data: void 0,
+		federation,
+		url: new URL("https://example.com/"),
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	const activity = new vocab.Create({
+		id: new URL("https://example.com/activity/1"),
+		actor: new URL("https://example.com/person")
+	});
+	const recipients = Array.from({ length: 7 }, (_, i) => ({
+		id: new URL(`https://example${i + 1}.com/recipient`),
+		inboxId: new URL(`https://example${i + 1}.com/inbox`)
+	}));
+	await ctx.sendActivity({ username: "john" }, recipients, activity, { fanout: "force" });
+	assertEquals(queue.messages.length, 1);
+	assertEquals(queue.messages[0].type, "fanout");
+	const measurements = recorder.getMeasurements("activitypub.fanout.recipients");
+	assertEquals(measurements.length, 1);
+	assertEquals(measurements[0].type, "histogram");
+	assertEquals(measurements[0].value, recipients.length);
+	assertEquals(measurements[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+});
 test({
 	name: "ContextImpl.routeActivity()",
 	permissions: {
@@ -2842,6 +6498,182 @@ test({
 		]);
 	}
 });
+test({
+	name: "ContextImpl.routeActivity() forwards meterProvider to inbox enqueue",
+	permissions: {
+		env: true,
+		read: true
+	},
+	async fn() {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const enqueued = [];
+		const federation = new FederationImpl({
+			kv: new MemoryKvStore(),
+			meterProvider,
+			queue: {
+				enqueue(message) {
+					enqueued.push(message);
+					return Promise.resolve();
+				},
+				listen() {
+					return Promise.resolve();
+				}
+			}
+		});
+		federation.setInboxListeners("/u/{identifier}/i", "/i");
+		const ctx = new ContextImpl({
+			url: new URL("https://example.com/"),
+			federation,
+			data: void 0,
+			documentLoader: mockDocumentLoader,
+			contextLoader: documentLoader
+		});
+		const signedOffer = await signObject(new vocab.Offer({ actor: new URL("https://example.com/person2") }), ed25519PrivateKey, ed25519Multikey.id);
+		assert(await ctx.routeActivity(null, signedOffer));
+		assertEquals(enqueued.length, 1);
+		const enqueuedMetrics = recorder.getMeasurements("fedify.queue.task.enqueued");
+		assertEquals(enqueuedMetrics.length, 1);
+		assertEquals(enqueuedMetrics[0].attributes["fedify.queue.role"], "inbox");
+		assertEquals(enqueuedMetrics[0].attributes["fedify.queue.task.attempt"], 0);
+	}
+});
+test({
+	name: "ContextImpl.routeActivity() records inbox.activity lifecycle metrics",
+	permissions: {
+		env: true,
+		read: true
+	},
+	async fn() {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = new FederationImpl({
+			kv: new MemoryKvStore(),
+			meterProvider,
+			queue: {
+				enqueue() {
+					return Promise.resolve();
+				},
+				listen() {
+					return Promise.resolve();
+				}
+			}
+		});
+		federation.setInboxListeners("/u/{identifier}/i", "/i");
+		const ctx = new ContextImpl({
+			url: new URL("https://example.com/"),
+			federation,
+			data: void 0,
+			documentLoader: mockDocumentLoader,
+			contextLoader: documentLoader
+		});
+		const signedOffer = await signObject(new vocab.Offer({
+			id: new URL("https://example.com/offer-queued"),
+			actor: new URL("https://example.com/person2")
+		}), ed25519PrivateKey, ed25519Multikey.id);
+		assert(await ctx.routeActivity(null, signedOffer));
+		const queued = recorder.getMeasurements("activitypub.inbox.activity");
+		assertEquals(queued.length, 1);
+		assertEquals(queued[0].type, "counter");
+		assertEquals(queued[0].attributes["activitypub.processing.result"], "queued");
+		assertEquals(queued[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Offer");
+	}
+});
+test({
+	name: "ContextImpl.routeActivity() records inbox.activity processed without queue",
+	permissions: {
+		env: true,
+		read: true
+	},
+	async fn() {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = new FederationImpl({
+			kv: new MemoryKvStore(),
+			meterProvider
+		});
+		federation.setInboxListeners("/u/{identifier}/i", "/i").on(vocab.Offer, () => {});
+		const ctx = new ContextImpl({
+			url: new URL("https://example.com/"),
+			federation,
+			data: void 0,
+			documentLoader: mockDocumentLoader,
+			contextLoader: documentLoader
+		});
+		const signedOffer = await signObject(new vocab.Offer({
+			id: new URL("https://example.com/offer-processed"),
+			actor: new URL("https://example.com/person2")
+		}), ed25519PrivateKey, ed25519Multikey.id);
+		assert(await ctx.routeActivity(null, signedOffer));
+		const processed = recorder.getMeasurements("activitypub.inbox.activity");
+		assertEquals(processed.length, 1);
+		assertEquals(processed[0].attributes["activitypub.processing.result"], "processed");
+		assertEquals(processed[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Offer");
+	}
+});
+test({
+	name: "ContextImpl.routeActivity() records inbox.activity rejected for unsupported type and duplicates",
+	permissions: {
+		env: true,
+		read: true
+	},
+	async fn() {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const federation = new FederationImpl({
+			kv: new MemoryKvStore(),
+			meterProvider
+		});
+		federation.setInboxListeners("/u/{identifier}/i", "/i").on(vocab.Offer, () => {});
+		const ctx = new ContextImpl({
+			url: new URL("https://example.com/"),
+			federation,
+			data: void 0,
+			documentLoader: mockDocumentLoader,
+			contextLoader: documentLoader
+		});
+		const signedCreate = await signObject(new vocab.Create({
+			id: new URL("https://example.com/create-unsupported"),
+			actor: new URL("https://example.com/person2")
+		}), ed25519PrivateKey, ed25519Multikey.id);
+		assert(await ctx.routeActivity(null, signedCreate));
+		const dupOffer = await signObject(new vocab.Offer({
+			id: new URL("https://example.com/offer-duplicate"),
+			actor: new URL("https://example.com/person2")
+		}), ed25519PrivateKey, ed25519Multikey.id);
+		assert(await ctx.routeActivity(null, dupOffer));
+		assert(await ctx.routeActivity(null, dupOffer));
+		const rejected = recorder.getMeasurements("activitypub.inbox.activity").filter((m) => m.attributes["activitypub.processing.result"] === "rejected");
+		assertEquals(rejected.length, 2);
+		assertEquals(rejected[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		assertEquals(rejected[1].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Offer");
+	}
+});
+test("ContextImpl.routeActivity() marks queued signed activities as non-LDS", async () => {
+	let queuedMessage = null;
+	const federation = new FederationImpl({
+		kv: new MemoryKvStore(),
+		queue: {
+			enqueue(message) {
+				queuedMessage = message;
+				return Promise.resolve();
+			},
+			async listen() {}
+		}
+	});
+	federation.setInboxListeners("/u/{identifier}/i", "/i").on(Offer, () => {
+		throw new Error("listener should not run for queued routeActivity");
+	});
+	const ctx = new ContextImpl({
+		url: new URL("https://example.com/"),
+		federation,
+		data: void 0,
+		documentLoader: mockDocumentLoader,
+		contextLoader: documentLoader
+	});
+	const signedOffer = await signObject(new Offer({ actor: new URL("https://example.com/person2") }), ed25519PrivateKey, ed25519Multikey.id);
+	assert(await ctx.routeActivity(null, signedOffer));
+	if (queuedMessage == null) throw new Error("Inbox message not queued.");
+	const inboxMessage = queuedMessage;
+	assertEquals(inboxMessage.ldSignatureVerified, false);
+	assertEquals(inboxMessage.normalizedActivity, void 0);
+});
 test("ContextImpl.getCollectionUri()", () => {
 	const federation = new FederationImpl({ kv: new MemoryKvStore() });
 	const base = "https://example.com";
@@ -3066,5 +6898,63 @@ test("KvSpecDeterminer", async (t) => {
 		assertEquals(spec, "rfc9421");
 	});
 });
+test("createFederation() instruments documentLoader with activitypub.document.fetch", async () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	await createFederation({
+		kv: new MemoryKvStore(),
+		meterProvider,
+		documentLoaderFactory: () => mockDocumentLoader,
+		contextLoaderFactory: () => mockDocumentLoader
+	}).createContext(new URL("https://example.com/"), void 0).documentLoader("https://example.com/object");
+	const counters = recorder.getMeasurements("activitypub.document.fetch");
+	assertEquals(counters.length, 1);
+	assertEquals(counters[0].attributes["activitypub.lookup.kind"], "object");
+	assertEquals(counters[0].attributes["activitypub.lookup.result"], "fetched");
+	assertEquals(counters[0].attributes["activitypub.remote.host"], "example.com");
+	assertFalse("activitypub.cache.enabled" in counters[0].attributes);
+});
+test("createFederation() records kind=context on contextLoader fetches", async () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	await createFederation({
+		kv: new MemoryKvStore(),
+		meterProvider,
+		documentLoaderFactory: () => mockDocumentLoader,
+		contextLoaderFactory: () => mockDocumentLoader
+	}).createContext(new URL("https://example.com/"), void 0).contextLoader("https://example.com/object");
+	const counters = recorder.getMeasurements("activitypub.document.fetch");
+	assertEquals(counters.length, 1);
+	assertEquals(counters[0].attributes["activitypub.lookup.kind"], "context");
+});
+test("createFederation() forwards DocumentLoaderFactoryOptions to a user-supplied authenticatedDocumentLoaderFactory", () => {
+	const kv = new MemoryKvStore();
+	const seen = [];
+	createFederation({
+		kv,
+		authenticatedDocumentLoaderFactory: (_identity, opts) => {
+			seen.push(opts);
+			return mockDocumentLoader;
+		}
+	}).authenticatedDocumentLoaderFactory({
+		keyId: new URL("https://example.com/users/alice#main-key"),
+		privateKey: {}
+	}, {
+		allowPrivateAddress: true,
+		userAgent: "test-ua"
+	});
+	assertEquals(seen.length, 1);
+	assertEquals(seen[0], {
+		allowPrivateAddress: true,
+		userAgent: "test-ua"
+	});
+});
+test("createFederation() omits instrumentation when no meterProvider is set", () => {
+	const ctx = createFederation({
+		kv: new MemoryKvStore(),
+		documentLoaderFactory: () => mockDocumentLoader,
+		contextLoaderFactory: () => mockDocumentLoader
+	}).createContext(new URL("https://example.com/"), void 0);
+	assertStrictEquals(ctx.documentLoader, mockDocumentLoader);
+	assertStrictEquals(ctx.contextLoader, mockDocumentLoader);
+});
 //#endregion
 export {};