@fedify/fedify 2.4.0-dev.2065 → 2.4.0-dev.2073

package/dist/federation/portable-inbox.test.mjs

@@ -0,0 +1,546 @@
+import { Temporal } from "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
+import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { p as signJsonLd } from "../ld-DT3e2hOv.mjs";
+import { r as signObject } from "../proof-CxsVG6vM.mjs";
+import { s as signRequest } from "../http-C7qHlv-b.mjs";
+import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
+import { c as forwardPortableInboxActivity, l as resolvePortableInboxForwardingOptions, o as createFederation } from "../middleware-CpyCNOW_.mjs";
+import { Create, Follow, Note, Person, Tombstone } from "@fedify/vocab";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { exportDidKey, formatIri, parseIri } from "@fedify/vocab-runtime";
+//#region src/federation/portable-inbox.test.ts
+const did = await exportDidKey(ed25519PublicKey.publicKey);
+const keyId = new URL(`${did}#${did.substring(8)}`);
+const otherKeyPair = await crypto.subtle.generateKey("Ed25519", true, ["sign", "verify"]);
+const otherDid = await exportDidKey(otherKeyPair.publicKey);
+const LOCAL = "https://example.com";
+const GATEWAY2 = "https://example.org";
+const GATEWAY3 = "https://example.net";
+function inboxUrl(authority = did, path = "/users/alice/inbox", origin = LOCAL) {
+	return `${origin}/.well-known/apgateway/${authority}${path}`;
+}
+function post(url, body, headers = {}) {
+	return new Request(url, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/activity+json",
+			...headers
+		},
+		body: JSON.stringify(body)
+	});
+}
+var RecordingQueue = class {
+	messages = [];
+	failFor;
+	enqueue(message) {
+		if (this.failFor != null && message.type === "outbox" && message.inbox.startsWith(this.failFor)) return Promise.reject(/* @__PURE__ */ new Error("Enqueue failed."));
+		this.messages.push(message);
+		return Promise.resolve();
+	}
+	listen() {
+		return Promise.resolve();
+	}
+	get outbox() {
+		return this.messages.filter((m) => m.type === "outbox");
+	}
+};
+function setup({ gateways = [
+	LOCAL,
+	GATEWAY2,
+	GATEWAY3
+], kv = new MemoryKvStore(), queue, options = {}, actor, listenerError = false, keyPairs = true, onSharedInboxKey } = {}) {
+	const federation = createFederation({
+		kv,
+		...options.allowPrivateAddress ? {} : {
+			documentLoaderFactory: () => mockDocumentLoader,
+			contextLoaderFactory: () => mockDocumentLoader
+		},
+		manuallyStartQueue: true,
+		...queue == null ? {} : { queue: { outbox: queue } },
+		...options
+	});
+	const received = [];
+	const actorCallbacks = federation.setActorDispatcher("/users/{identifier}", actor ?? ((ctx, identifier) => {
+		if (identifier === "ordinary") return new Person({
+			id: ctx.getActorUri(identifier),
+			inbox: ctx.getInboxUri(identifier)
+		});
+		if (identifier !== "alice") return null;
+		return new Person({
+			id: parseIri(`ap+ef61://${did}/users/alice`),
+			inbox: ctx.getPortableInboxUri(identifier, did),
+			gateways: gateways.map((g) => new URL(g))
+		});
+	}));
+	if (keyPairs) actorCallbacks.setKeyPairsDispatcher((_ctx, identifier) => identifier === "ordinary" ? [{
+		privateKey: rsaPrivateKey2,
+		publicKey: rsaPublicKey2.publicKey
+	}] : []);
+	const inboxListeners = federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
+	if (onSharedInboxKey != null) inboxListeners.setSharedKeyDispatcher(() => {
+		onSharedInboxKey();
+		return null;
+	});
+	inboxListeners.on(Follow, (ctx, activity) => {
+		received.push({
+			activity,
+			recipient: ctx.recipient
+		});
+		if (listenerError) throw new Error("Listener failed.");
+	}).on(Create, (ctx, activity) => {
+		received.push({
+			activity,
+			recipient: ctx.recipient
+		});
+	});
+	return {
+		federation,
+		received,
+		kv,
+		queue
+	};
+}
+let activityCounter = 0;
+async function signedFollow(authority = did, privateKey = ed25519PrivateKey, signingKeyId = keyId) {
+	return await (await signObject(new Follow({
+		id: parseIri(`ap+ef61://${authority}/follows/${++activityCounter}`),
+		actor: parseIri(`ap+ef61://${authority}/users/bob`),
+		object: parseIri(`ap+ef61://${did}/users/alice`)
+	}), privateKey, signingKeyId, { contextLoader: mockDocumentLoader })).toJsonLd({ contextLoader: mockDocumentLoader });
+}
+test("Federation.fetch() delivers to portable inboxes", async (t) => {
+	const queue = new RecordingQueue();
+	const { federation, received } = setup({ queue });
+	const json = await signedFollow();
+	await t.step("routes to the existing inbox listeners", async () => {
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 202);
+		assertEquals(received.length, 1);
+		assertEquals(received[0].recipient, "alice");
+		assert(received[0].activity instanceof Follow);
+	});
+	await t.step("forwards the activity to the other gateways", () => {
+		assertEquals(queue.outbox.map((m) => m.inbox).sort(), [inboxUrl(did, "/users/alice/inbox", GATEWAY3), inboxUrl(did, "/users/alice/inbox", GATEWAY2)]);
+		for (const message of queue.outbox) {
+			assertEquals(message.keys, []);
+			assertEquals(message.activity, json);
+			assertFalse(message.sharedInbox);
+		}
+	});
+	await t.step("neither forwards nor dispatches duplicates", async () => {
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 202);
+		assertEquals(received.length, 1);
+		assertEquals(queue.outbox.length, 2);
+	});
+	await t.step("accepts ap: and percent-encoded DIDs", async () => {
+		assertEquals((await federation.fetch(post(inboxUrl(did.replaceAll(":", "%3A")), await signedFollow()), { contextData: void 0 })).status, 202);
+		assertEquals(received.length, 2);
+	});
+});
+test("Federation.fetch() delivers to portable inboxes without key pairs", async () => {
+	const queue = new RecordingQueue();
+	const { federation, received } = setup({
+		queue,
+		keyPairs: false
+	});
+	assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+	assertEquals(received.length, 1);
+	assertEquals(queue.outbox.length, 2);
+});
+test("Federation.fetch() refuses portable inbox deliveries it does not accept", async (t) => {
+	const { federation, received } = setup({ gateways: [GATEWAY2] });
+	const json = await signedFollow();
+	await t.step("this server is not a gateway of the actor", async () => {
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 404);
+	});
+	const accepting = setup();
+	const cases = [
+		["unknown actor", inboxUrl(did, "/users/unknown/inbox")],
+		["non-portable actor", inboxUrl(did, "/users/ordinary/inbox")],
+		["DID mismatch", inboxUrl(otherDid)],
+		["shared inbox", inboxUrl(did, "/inbox")],
+		["actor path", inboxUrl(did, "/users/alice")],
+		["unregistered path", inboxUrl(did, "/unknown/alice/inbox")]
+	];
+	for (const [name, url] of cases) await t.step(name, async () => {
+		assertEquals((await accepting.federation.fetch(post(url, json), { contextData: void 0 })).status, 404);
+	});
+	await t.step("inbox mismatch", async () => {
+		const { federation } = setup({ actor: () => new Person({
+			id: parseIri(`ap+ef61://${did}/users/alice`),
+			inbox: parseIri(`ap+ef61://${did}/users/alice/other-inbox`),
+			gateways: [new URL(LOCAL)]
+		}) });
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 404);
+	});
+	await t.step("tombstone", async () => {
+		const { federation } = setup({ actor: () => new Tombstone({ id: parseIri(`ap+ef61://${did}/users/alice`) }) });
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 404);
+	});
+	await t.step("malformed DID", async () => {
+		assertEquals((await accepting.federation.fetch(post(`${LOCAL}/.well-known/apgateway/did:key:/users/alice/inbox`, json), { contextData: void 0 })).status, 400);
+	});
+	await t.step("listeners are not called", () => {
+		assertEquals(received.length, 0);
+		assertEquals(accepting.received.length, 0);
+	});
+});
+test("Federation.fetch() applies the proof policy to portable inbox deliveries", async (t) => {
+	const queue = new RecordingQueue();
+	const { federation, received } = setup({ queue });
+	await t.step("unsigned portable activity", async () => {
+		const json = await new Follow({
+			id: parseIri(`ap+ef61://${did}/follows/unsigned`),
+			actor: parseIri(`ap+ef61://${did}/users/bob`),
+			object: parseIri(`ap+ef61://${did}/users/alice`)
+		}).toJsonLd({ contextLoader: mockDocumentLoader });
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 401);
+	});
+	await t.step("proof made by another DID", async () => {
+		const json = await signedFollow(did, otherKeyPair.privateKey, new URL(`${otherDid}#${otherDid.substring(8)}`));
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 401);
+	});
+	await t.step("unsigned portable object in a signed activity", async () => {
+		const json = await (await signObject(new Create({
+			id: parseIri(`ap+ef61://${did}/creates/1`),
+			actor: parseIri(`ap+ef61://${did}/users/bob`),
+			object: new Note({
+				id: parseIri(`ap+ef61://${did}/notes/1`),
+				content: "Hello"
+			})
+		}), ed25519PrivateKey, keyId, { contextLoader: mockDocumentLoader })).toJsonLd({ contextLoader: mockDocumentLoader });
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 401);
+	});
+	await t.step("nothing is dispatched or forwarded", () => {
+		assertEquals(received.length, 0);
+		assertEquals(queue.outbox.length, 0);
+	});
+});
+test("Federation.fetch() does not forward activities authenticated only by HTTP Signatures", async () => {
+	const queue = new RecordingQueue();
+	const { federation, received } = setup({ queue });
+	const activity = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://example.com/follows/http",
+		type: "Follow",
+		actor: "https://example.com/person2",
+		object: formatIri(parseIri(`ap+ef61://${did}/users/alice`))
+	};
+	const request = await signRequest(post(inboxUrl(), activity), rsaPrivateKey3, new URL("https://example.com/person2#key3"));
+	assertEquals((await federation.fetch(request, { contextData: void 0 })).status, 202);
+	assertEquals(received.length, 1);
+	assertEquals(queue.outbox.length, 0);
+});
+test("Federation.fetch() forwards activities authenticated by Linked Data Signatures", async () => {
+	const queue = new RecordingQueue();
+	const { federation, received } = setup({ queue });
+	const activity = await signJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://example.com/follows/lds",
+		type: "Follow",
+		actor: "https://example.com/person2",
+		object: formatIri(parseIri(`ap+ef61://${did}/users/alice`))
+	}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+	assertEquals((await federation.fetch(post(inboxUrl(), activity), { contextData: void 0 })).status, 202);
+	assertEquals(received.length, 1);
+	assertEquals(queue.outbox.length, 2);
+	for (const message of queue.outbox) assertEquals(message.activity, activity);
+});
+test("Federation.fetch() does not forward portable inbox deliveries without verification", async () => {
+	const queue = new RecordingQueue();
+	const { federation, received } = setup({
+		queue,
+		options: { skipSignatureVerification: true }
+	});
+	assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+	assertEquals(received.length, 1);
+	assertEquals(queue.outbox.length, 0);
+});
+test("Federation.fetch() does not forward portable inbox deliveries whose listener failed", async () => {
+	const queue = new RecordingQueue();
+	const { federation } = setup({
+		queue,
+		listenerError: true
+	});
+	const json = await signedFollow();
+	let response = await federation.fetch(post(inboxUrl(), json), { contextData: void 0 });
+	assertEquals(response.status, 500);
+	assertEquals(queue.outbox.length, 0);
+	response = await federation.fetch(post(inboxUrl(), json), { contextData: void 0 });
+	assertEquals(response.status, 500);
+	assertEquals(queue.outbox.length, 0);
+});
+test("Federation.fetch() forwards each portable inbox delivery at most once", async (t) => {
+	await t.step("concurrent deliveries", async () => {
+		const queue = new RecordingQueue();
+		const { federation } = setup({ queue });
+		const json = await signedFollow();
+		const responses = await Promise.all([
+			federation.fetch(post(inboxUrl(), json), { contextData: void 0 }),
+			federation.fetch(post(inboxUrl(), json), { contextData: void 0 }),
+			federation.fetch(post(inboxUrl(), json), { contextData: void 0 })
+		]);
+		for (const response of responses) assertEquals(response.status, 202);
+		assertEquals(queue.outbox.map((m) => m.inbox).sort(), [inboxUrl(did, "/users/alice/inbox", GATEWAY3), inboxUrl(did, "/users/alice/inbox", GATEWAY2)]);
+	});
+	await t.step("failed hand-offs are not retried", async () => {
+		const queue = new RecordingQueue();
+		queue.failFor = GATEWAY2;
+		const { federation, received } = setup({ queue });
+		const json = await signedFollow();
+		let response = await federation.fetch(post(inboxUrl(), json), { contextData: void 0 });
+		assertEquals(response.status, 202);
+		assertEquals(queue.outbox.map((m) => m.inbox), [inboxUrl(did, "/users/alice/inbox", GATEWAY3)]);
+		queue.failFor = void 0;
+		response = await federation.fetch(post(inboxUrl(), json), { contextData: void 0 });
+		assertEquals(response.status, 202);
+		assertEquals(queue.outbox.length, 1);
+		assertEquals(received.length, 1);
+	});
+	await t.step("a delivery forwarded back is not forwarded again", async () => {
+		const queue = new RecordingQueue();
+		const local = setup({
+			queue,
+			kv: new MemoryKvStore()
+		});
+		const json = await signedFollow();
+		await local.federation.fetch(post(inboxUrl(), json), { contextData: void 0 });
+		assertEquals(queue.outbox.length, 2);
+		assertEquals((await local.federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 202);
+		assertEquals(queue.outbox.length, 2);
+		assertEquals(local.received.length, 1);
+	});
+	await t.step("without KvStore.cas()", async () => {
+		const queue = new RecordingQueue();
+		const memory = new MemoryKvStore();
+		const { federation, received } = setup({
+			queue,
+			kv: {
+				get: (key) => memory.get(key),
+				set: (key, value, options) => memory.set(key, value, options),
+				delete: (key) => memory.delete(key),
+				list: (prefix) => memory.list(prefix)
+			}
+		});
+		assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+		assertEquals(received.length, 1);
+		assertEquals(queue.outbox.length, 0);
+	});
+	await t.step("configured origin", async () => {
+		const queue = new RecordingQueue();
+		const { federation } = setup({
+			queue,
+			gateways: [
+				GATEWAY2,
+				LOCAL,
+				GATEWAY3
+			],
+			options: { origin: GATEWAY2 }
+		});
+		assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+		assertEquals(queue.outbox.map((m) => m.inbox), [inboxUrl(did, "/users/alice/inbox", GATEWAY3)]);
+	});
+	await t.step("gateway cap", async () => {
+		const queue = new RecordingQueue();
+		const gateways = [LOCAL];
+		for (let i = 0; i < 15; i++) gateways.push(`https://gw${i}.example.net`);
+		const { federation } = setup({
+			queue,
+			gateways
+		});
+		assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+		assertEquals(queue.outbox.length, 10);
+	});
+});
+test("FederationOptions.portableInboxForwarding", async (t) => {
+	await t.step("maxTargets", async () => {
+		const queue = new RecordingQueue();
+		const { federation } = setup({
+			queue,
+			options: { portableInboxForwarding: { maxTargets: 1 } }
+		});
+		assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+		assertEquals(queue.outbox.map((m) => m.inbox), [inboxUrl(did, "/users/alice/inbox", GATEWAY2)]);
+	});
+	await t.step("maxTargets: 0 turns off forwarding", async () => {
+		const queue = new RecordingQueue();
+		const { federation, received } = setup({
+			queue,
+			options: { portableInboxForwarding: { maxTargets: 0 } }
+		});
+		assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+		assertEquals(received.length, 1);
+		assertEquals(queue.outbox.length, 0);
+	});
+	await t.step("ttl", async () => {
+		const queue = new RecordingQueue();
+		const memory = new MemoryKvStore();
+		const claimTtls = [];
+		const { federation } = setup({
+			queue,
+			kv: {
+				get: (key) => memory.get(key),
+				set: (key, value, options) => memory.set(key, value, options),
+				delete: (key) => memory.delete(key),
+				list: (prefix) => memory.list(prefix),
+				cas: (key, expected, value, options) => {
+					if (key[1] === "portableInboxForwarding") claimTtls.push(options?.ttl);
+					return memory.cas(key, expected, value, options);
+				}
+			},
+			options: { portableInboxForwarding: { ttl: Temporal.Duration.from({ days: 7 }) } }
+		});
+		assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+		assertEquals(queue.outbox.length, 2);
+		assertEquals(claimTtls.map((ttl) => ttl?.total("day")), [7, 7]);
+	});
+	await t.step("longest deadline", () => {
+		assertEquals(resolvePortableInboxForwardingOptions({ deadline: { milliseconds: 2 ** 31 - 1 } }).deadline.total("millisecond"), 2 ** 31 - 1);
+	});
+	await t.step("defaults", () => {
+		const resolved = resolvePortableInboxForwardingOptions();
+		assertEquals(resolved.maxTargets, 10);
+		assertEquals(resolved.ttl.total("day"), 30);
+		assertEquals(resolved.deadline.total("second"), 10);
+	});
+	await t.step("invalid values", () => {
+		for (const portableInboxForwarding of [
+			{ maxTargets: -1 },
+			{ maxTargets: 1.5 },
+			{ maxTargets: NaN },
+			{ ttl: { seconds: 0 } },
+			{ ttl: { weeks: 1 } },
+			{ ttl: { months: 1 } },
+			{ deadline: { seconds: -1 } },
+			{ deadline: { years: 1 } },
+			{ deadline: { milliseconds: 2 ** 31 } }
+		]) assertThrows(() => setup({ options: { portableInboxForwarding } }), RangeError);
+	});
+});
+test("Federation.fetch() forwards portable inbox deliveries immediately without a queue", async () => {
+	esm_default.spyGlobal();
+	const requests = [];
+	esm_default.post(`begin:${GATEWAY2}/`, async (callLog) => {
+		const request = callLog.request;
+		requests.push({
+			url: request.url,
+			headers: new Headers(request.headers),
+			body: await request.json()
+		});
+		return new Response(null, { status: 202 });
+	});
+	esm_default.post(`begin:${GATEWAY3}/`, () => {
+		throw new TypeError("Connection refused.");
+	});
+	try {
+		const { federation, received } = setup({ options: { allowPrivateAddress: true } });
+		const json = await signedFollow();
+		let response = await federation.fetch(post(inboxUrl(), json), { contextData: void 0 });
+		assertEquals(response.status, 202);
+		assertEquals(received.length, 1);
+		assertEquals(requests.length, 1);
+		assertEquals(requests[0].url, inboxUrl(did, "/users/alice/inbox", GATEWAY2));
+		assertFalse(requests[0].headers.has("Signature"));
+		assertFalse(requests[0].headers.has("Signature-Input"));
+		assertEquals(requests[0].body, json);
+		response = await federation.fetch(post(inboxUrl(), json), { contextData: void 0 });
+		assertEquals(response.status, 202);
+		assertEquals(requests.length, 1);
+		assertEquals(esm_default.callHistory.calls(`begin:${GATEWAY3}/`).length, 1);
+	} finally {
+		esm_default.hardReset();
+	}
+});
+test("Federation.fetch() forwards portable inbox deliveries when it enqueues them", async () => {
+	const queue = new RecordingQueue();
+	const inboxQueue = new RecordingQueue();
+	let sharedInboxKeyCalls = 0;
+	const { federation, received } = setup({
+		queue,
+		keyPairs: false,
+		onSharedInboxKey: () => sharedInboxKeyCalls++,
+		options: { queue: {
+			inbox: inboxQueue,
+			outbox: queue
+		} }
+	});
+	assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+	assertEquals(received.length, 0);
+	assertEquals(inboxQueue.messages.length, 1);
+	assertEquals(inboxQueue.messages[0].type, "inbox");
+	assertEquals(queue.outbox.length, 2);
+	await federation.processQueuedTask(void 0, inboxQueue.messages[0]);
+	assertEquals(received.length, 1);
+	assertEquals(received[0].recipient, "alice");
+	assertEquals(sharedInboxKeyCalls, 0);
+});
+test("forwardPortableInboxActivity() does not wait for slow gateways", async () => {
+	esm_default.spyGlobal();
+	let release = () => {};
+	const pending = new Promise((resolve) => release = resolve);
+	esm_default.post(`begin:${GATEWAY2}/`, async () => {
+		await pending;
+		throw new TypeError("Connection reset.");
+	});
+	try {
+		const kv = new MemoryKvStore();
+		const activityId = parseIri(`ap+ef61://${did}/follows/slow`);
+		const parameters = {
+			recipient: {
+				inboxId: parseIri(`ap+ef61://${did}/users/alice/inbox`),
+				canonicalInboxId: `ap://${did}/users/alice/inbox`,
+				gateways: [new URL(LOCAL), new URL(GATEWAY2)]
+			},
+			activity: { id: formatIri(activityId) },
+			activityId,
+			activityType: "https://www.w3.org/ns/activitystreams#Follow",
+			excludedOrigins: [LOCAL],
+			baseUrl: LOCAL,
+			kv,
+			kvPrefix: ["_fedify", "portableInboxForwarding"],
+			options: resolvePortableInboxForwardingOptions({ deadline: { milliseconds: 10 } }),
+			allowPrivateAddress: true
+		};
+		const started = performance.now();
+		const forwarded = await forwardPortableInboxActivity(parameters);
+		assert(performance.now() - started < 5e3);
+		assertEquals(forwarded.map((u) => u.href), [inboxUrl(did, "/users/alice/inbox", GATEWAY2)]);
+		release();
+		await new Promise((resolve) => setTimeout(resolve, 10));
+		assertEquals(await forwardPortableInboxActivity(parameters), []);
+		assertEquals(esm_default.callHistory.calls().length, 1);
+	} finally {
+		esm_default.hardReset();
+	}
+});
+test("Context.getPortableInboxUri()", async (t) => {
+	const { federation } = setup();
+	await t.step("Context", () => {
+		const ctx = federation.createContext(new URL(LOCAL), void 0);
+		const uri = ctx.getPortableInboxUri("alice", did);
+		assertEquals(uri.protocol, "ap+ef61:");
+		assertEquals(formatIri(uri), `ap+ef61://${did}/users/alice/inbox`);
+		assertThrows(() => ctx.getPortableInboxUri("alice", "not-a-did"), TypeError);
+	});
+	await t.step("RequestContext without portable request", () => {
+		const ctx = federation.createContext(new Request(LOCAL), void 0);
+		assertThrows(() => ctx.getPortableInboxUri("alice"), TypeError);
+		assertEquals(formatIri(ctx.getPortableInboxUri("alice", did)), `ap+ef61://${did}/users/alice/inbox`);
+	});
+});
+test("Federation.fetch() keeps ordinary inbox deliveries unchanged", async () => {
+	const queue = new RecordingQueue();
+	const { federation, received } = setup({ queue });
+	assertEquals((await federation.fetch(post(`${LOCAL}/users/alice/inbox`, await signedFollow()), { contextData: void 0 })).status, 202);
+	assertEquals(received.length, 1);
+	assertEquals(queue.outbox.length, 0);
+});
+//#endregion
+export {};

package/dist/federation/portable.test.mjs

@@ -7,10 +7,10 @@ import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
 import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertStrictEquals } from "../assert_strict_equals-CYvBmkpC.mjs";
-import { s as signRequest } from "../http-f1qaBtOh.mjs";
+import { o as verifyPortableObjectProof, r as signObject } from "../proof-CxsVG6vM.mjs";
+import { s as signRequest } from "../http-C7qHlv-b.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { g as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-s-AZzx4r.mjs";
-import { o as verifyPortableObjectProof, r as signObject } from "../proof-B03JXhrk.mjs";
+import { o as createFederation, v as PORTABLE_OBJECT_CONTENT_TYPE } from "../middleware-CpyCNOW_.mjs";
 import { Collection, Create, Note, Object as Object$1, Person, Tombstone, lookupObject } from "@fedify/vocab";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { exportDidKey, formatIri, parseIri } from "@fedify/vocab-runtime";

package/dist/federation/send.test.mjs

@@ -10,10 +10,10 @@ import { t as assertNotEquals } from "../assert_not_equals-CpPK2t89.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { l as verifyRequest } from "../http-f1qaBtOh.mjs";
+import { l as verifyRequest } from "../http-C7qHlv-b.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { t as doesActorOwnKey } from "../owner-D_F22lfM.mjs";
-import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-NNkfKtVN.mjs";
+import { t as doesActorOwnKey } from "../owner-CDsVeZI7.mjs";
+import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-BZJ7NsVV.mjs";
 import { Activity, Application, Endpoints, Group, Person, Service } from "@fedify/vocab";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, UrlError } from "@fedify/vocab-runtime";

package/dist/federation/tasks/enqueue.test.mjs

@@ -3,8 +3,8 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../../kv-DCHkaJ9-.mjs";
 import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../tasks-dbCShlCb.mjs";
-import "../../testing-By1YYsIK.mjs";
-import { o as createFederation } from "../../middleware-s-AZzx4r.mjs";
+import "../../testing-CO_cEvQc.mjs";
+import { o as createFederation } from "../../middleware-CpyCNOW_.mjs";
 import { n as ParallelMessageQueue } from "../../mq-Dm1Wmtm-.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { delay } from "es-toolkit";

package/dist/federation/tasks/tasks.test.mjs

@@ -3,9 +3,9 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../../kv-DCHkaJ9-.mjs";
 import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../tasks-dbCShlCb.mjs";
-import "../../testing-By1YYsIK.mjs";
-import { o as createFederation } from "../../middleware-s-AZzx4r.mjs";
-import { r as createFederationBuilder } from "../../builder-CMkrnYbY.mjs";
+import "../../testing-CO_cEvQc.mjs";
+import { o as createFederation } from "../../middleware-CpyCNOW_.mjs";
+import { r as createFederationBuilder } from "../../builder-CVHpPAjK.mjs";
 import { t as TaskCodec } from "../../codec-C6rTrpIp.mjs";
 import { t as InProcessMessageQueue } from "../../mq-Dm1Wmtm-.mjs";
 import { W3CTraceContextPropagator } from "@opentelemetry/core";

package/dist/federation/temporal.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { t as hasMalformedKnownTemporalLiteral } from "../temporal-VVVSuruq.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "../temporal-CLzSfIOV.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/temporal.test.ts
 test("hasMalformedKnownTemporalLiteral() detects expanded proof timestamps", async () => {

package/dist/federation/webfinger.test.mjs

@@ -1,12 +1,12 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { r as createRequestContext } from "../context-DG5QeQ8W.mjs";
+import { r as createRequestContext } from "../context-DlZhxdFT.mjs";
 import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import { t as assertNotEquals } from "../assert_not_equals-CpPK2t89.mjs";
 import "../std__assert-DvMDRPes.mjs";
-import { o as createFederation, s as handleWebFinger } from "../middleware-s-AZzx4r.mjs";
+import { o as createFederation, s as handleWebFinger } from "../middleware-CpyCNOW_.mjs";
 import { Image, Link, Person, Tombstone } from "@fedify/vocab";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { parseIri } from "@fedify/vocab-runtime";