@fedify/fedify 1.6.0-dev.813 → 1.6.0-experiment.0

package/dist/federation/middleware.test.js

@@ -0,0 +1,1491 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { getTypeId } from "../vocab/type.js";
+import { FetchError, fetchDocumentLoader } from "../runtime/docloader.js";
+import { Activity, Announce, Create, Invite, Multikey, Note, Object as Object$1, Offer, Person } from "../vocab/vocab.js";
+import { RouterError } from "./router.js";
+import { signRequest, verifyRequest } from "../sig/http.js";
+import { detachSignature, signJsonLd, verifyJsonLd } from "../sig/ld.js";
+import { doesActorOwnKey } from "../sig/owner.js";
+import { signObject, verifyObject } from "../sig/proof.js";
+import { MemoryKvStore } from "./kv.js";
+import { getAuthenticatedDocumentLoader } from "../runtime/authdocloader.js";
+import { lookupObject } from "../vocab/lookup.js";
+import { ContextImpl, FederationImpl, InboxContextImpl, createFederation } from "./middleware.js";
+import { assert } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert.js";
+import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
+import { assertInstanceOf } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_instance_of.js";
+import { test } from "../testing/mod.js";
+import { assertFalse } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_false.js";
+import { assertNotEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_not_equals.js";
+import { assertRejects } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_rejects.js";
+import { assertStrictEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_strict_equals.js";
+import { assertThrows } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_throws.js";
+import { dirname } from "../node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/dirname.js";
+import { join } from "../node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/join.js";
+import { mockDocumentLoader } from "../testing/docloader.js";
+import { ed25519Multikey, ed25519PrivateKey, ed25519PublicKey, rsaPrivateKey2, rsaPrivateKey3, rsaPublicKey2, rsaPublicKey3 } from "../testing/keys.js";
+import { install, mock, uninstall } from "../node_modules/.pnpm/@jsr_hongminhee__deno-mock-fetch@0.3.2/node_modules/@jsr/hongminhee__deno-mock-fetch/mod.js";
+import { readFile } from "node:fs/promises";
+
+//#region federation/middleware.test.ts
+test("createFederation()", async (t) => {
+	const kv = new MemoryKvStore();
+	await t.step("allowPrivateAddress", () => {
+		assertThrows(() => createFederation({
+			kv,
+			documentLoader: mockDocumentLoader,
+			allowPrivateAddress: true
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			contextLoader: mockDocumentLoader,
+			allowPrivateAddress: true
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			authenticatedDocumentLoaderFactory: () => mockDocumentLoader,
+			allowPrivateAddress: true
+		}), TypeError);
+	});
+	await t.step("origin", () => {
+		const f = createFederation({
+			kv,
+			origin: "http://example.com:8080"
+		});
+		assertInstanceOf(f, FederationImpl);
+		assertEquals(f.origin, {
+			handleHost: "example.com:8080",
+			webOrigin: "http://example.com:8080"
+		});
+		assertThrows(() => createFederation({
+			kv,
+			origin: "example.com"
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: "ftp://example.com"
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: "https://example.com/foo"
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: "https://example.com/?foo"
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: "https://example.com/#foo"
+		}), TypeError);
+		const f2 = createFederation({
+			kv,
+			origin: {
+				handleHost: "example.com:8080",
+				webOrigin: "https://ap.example.com"
+			}
+		});
+		assertInstanceOf(f2, FederationImpl);
+		assertEquals(f2.origin, {
+			handleHost: "example.com:8080",
+			webOrigin: "https://ap.example.com"
+		});
+		assertThrows(() => createFederation({
+			kv,
+			origin: {
+				handleHost: "https://example.com",
+				webOrigin: "https://example.com"
+			}
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: {
+				handleHost: "example.com/",
+				webOrigin: "https://example.com"
+			}
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: {
+				handleHost: "example.com",
+				webOrigin: "example.com"
+			}
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: {
+				handleHost: "example.com",
+				webOrigin: "ftp://example.com"
+			}
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: {
+				handleHost: "example.com",
+				webOrigin: "https://example.com/foo"
+			}
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: {
+				handleHost: "example.com",
+				webOrigin: "https://example.com/?foo"
+			}
+		}), TypeError);
+		assertThrows(() => createFederation({
+			kv,
+			origin: {
+				handleHost: "example.com",
+				webOrigin: "https://example.com/#foo"
+			}
+		}), TypeError);
+	});
+});
+test("Federation.createContext()", async (t) => {
+	const kv = new MemoryKvStore();
+	const documentLoader = (url) => {
+		throw new FetchError(new URL(url), "Not found");
+	};
+	install();
+	mock("GET@/object", async (req) => {
+		const v = await verifyRequest(req, {
+			contextLoader: mockDocumentLoader,
+			documentLoader: mockDocumentLoader,
+			currentTime: Temporal.Now.instant()
+		});
+		return new Response(JSON.stringify(v != null), { headers: { "Content-Type": "application/json" } });
+	});
+	await t.step("Context", async () => {
+		const federation = createFederation({
+			kv,
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		let ctx = federation.createContext(new URL("https://example.com:1234/"), 123);
+		assertEquals(ctx.data, 123);
+		assertEquals(ctx.origin, "https://example.com:1234");
+		assertEquals(ctx.canonicalOrigin, "https://example.com:1234");
+		assertEquals(ctx.host, "example.com:1234");
+		assertEquals(ctx.hostname, "example.com");
+		assertStrictEquals(ctx.documentLoader, documentLoader);
+		assertStrictEquals(ctx.contextLoader, mockDocumentLoader);
+		assertThrows(() => ctx.getNodeInfoUri(), RouterError);
+		assertThrows(() => ctx.getActorUri("handle"), RouterError);
+		assertThrows(() => ctx.getObjectUri(Note, {
+			handle: "handle",
+			id: "id"
+		}), RouterError);
+		assertThrows(() => ctx.getInboxUri(), RouterError);
+		assertThrows(() => ctx.getInboxUri("handle"), RouterError);
+		assertThrows(() => ctx.getOutboxUri("handle"), RouterError);
+		assertThrows(() => ctx.getFollowingUri("handle"), RouterError);
+		assertThrows(() => ctx.getFollowersUri("handle"), RouterError);
+		assertThrows(() => ctx.getLikedUri("handle"), RouterError);
+		assertThrows(() => ctx.getFeaturedUri("handle"), RouterError);
+		assertThrows(() => ctx.getFeaturedTagsUri("handle"), RouterError);
+		assertEquals(ctx.parseUri(new URL("https://example.com/")), null);
+		assertEquals(ctx.parseUri(null), null);
+		assertEquals(await ctx.getActorKeyPairs("handle"), []);
+		await assertRejects(() => ctx.getDocumentLoader({ identifier: "handle" }), Error, "No actor key pairs dispatcher registered");
+		await assertRejects(() => ctx.sendActivity({ identifier: "handle" }, [], new Create({})), Error, "No actor key pairs dispatcher registered");
+		federation.setNodeInfoDispatcher("/nodeinfo/2.1", () => ({
+			software: {
+				name: "Example",
+				version: {
+					major: 1,
+					minor: 2,
+					patch: 3
+				}
+			},
+			protocols: ["activitypub"],
+			usage: {
+				users: {},
+				localPosts: 123,
+				localComments: 456
+			}
+		}));
+		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 Person({})).setKeyPairsDispatcher(() => [{
+			privateKey: rsaPrivateKey2,
+			publicKey: rsaPublicKey2.publicKey
+		}, {
+			privateKey: ed25519PrivateKey,
+			publicKey: ed25519PublicKey.publicKey
+		}]).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.parseUri(new URL("https://example.com/")), null);
+		assertEquals(ctx.parseUri(new URL("https://example.com/users/handle")), {
+			type: "actor",
+			identifier: "handle",
+			handle: "handle"
+		});
+		assertEquals(ctx.parseUri(null), null);
+		assertEquals(await ctx.getActorKeyPairs("handle"), [{
+			keyId: new URL("https://example.com/users/handle#main-key"),
+			privateKey: rsaPrivateKey2,
+			publicKey: rsaPublicKey2.publicKey,
+			cryptographicKey: rsaPublicKey2.clone({
+				id: new URL("https://example.com/users/handle#main-key"),
+				owner: new URL("https://example.com/users/handle")
+			}),
+			multikey: new Multikey({
+				id: new URL("https://example.com/users/handle#main-key"),
+				controller: new URL("https://example.com/users/handle"),
+				publicKey: rsaPublicKey2.publicKey
+			})
+		}, {
+			keyId: new URL("https://example.com/users/handle#key-2"),
+			privateKey: ed25519PrivateKey,
+			publicKey: ed25519PublicKey.publicKey,
+			cryptographicKey: ed25519PublicKey.clone({
+				id: new URL("https://example.com/users/handle#key-2"),
+				owner: new URL("https://example.com/users/handle")
+			}),
+			multikey: new Multikey({
+				id: new URL("https://example.com/users/handle#key-2"),
+				controller: new URL("https://example.com/users/handle"),
+				publicKey: ed25519PublicKey.publicKey
+			})
+		}]);
+		const loader = await ctx.getDocumentLoader({ identifier: "handle" });
+		assertEquals(await loader("https://example.com/object"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: true
+		});
+		const loader2 = await ctx.getDocumentLoader({ username: "HANDLE" });
+		assertEquals(await loader2("https://example.com/object"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: true
+		});
+		const loader3 = ctx.getDocumentLoader({
+			keyId: new URL("https://example.com/key2"),
+			privateKey: rsaPrivateKey2
+		});
+		assertEquals(await loader3("https://example.com/object"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: true
+		});
+		assertEquals(await ctx.lookupObject("https://example.com/object"), null);
+		await assertRejects(() => ctx.sendActivity({ identifier: "handle" }, [], new Create({})), TypeError, "The activity to send must have at least one actor property.");
+		await ctx.sendActivity({ identifier: "handle" }, [], new Create({ actor: new URL("https://example.com/users/handle") }));
+		const federation2 = createFederation({
+			kv,
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		const ctx2 = federation2.createContext(new URL("https://example.com/"), 123);
+		assertEquals(await ctx2.lookupObject("https://example.com/object"), new Object$1({
+			id: new URL("https://example.com/object"),
+			name: "Fetched object"
+		}));
+		federation.setObjectDispatcher(Note, "/users/{identifier}/notes/{id}", (_ctx, values) => {
+			return new Note({ summary: `Note ${values.id} by ${values.identifier}` });
+		});
+		ctx = federation.createContext(new URL("https://example.com/"), 123);
+		assertEquals(ctx.getObjectUri(Note, {
+			identifier: "john",
+			id: "123"
+		}), new URL("https://example.com/users/john/notes/123"));
+		assertEquals(ctx.parseUri(new URL("https://example.com/users/john/notes/123")), {
+			type: "object",
+			class: Note,
+			typeId: new URL("https://www.w3.org/ns/activitystreams#Note"),
+			values: {
+				identifier: "john",
+				id: "123"
+			}
+		});
+		assertEquals(ctx.parseUri(null), null);
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
+		ctx = federation.createContext(new URL("https://example.com/"), 123);
+		assertEquals(ctx.getInboxUri(), new URL("https://example.com/inbox"));
+		assertEquals(ctx.getInboxUri("handle"), new URL("https://example.com/users/handle/inbox"));
+		assertEquals(ctx.parseUri(new URL("https://example.com/inbox")), {
+			type: "inbox",
+			identifier: void 0,
+			handle: void 0
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com/users/handle/inbox")), {
+			type: "inbox",
+			identifier: "handle",
+			handle: "handle"
+		});
+		assertEquals(ctx.parseUri(null), null);
+		federation.setOutboxDispatcher("/users/{identifier}/outbox", () => ({ items: [] }));
+		ctx = federation.createContext(new URL("https://example.com/"), 123);
+		assertEquals(ctx.getOutboxUri("handle"), new URL("https://example.com/users/handle/outbox"));
+		assertEquals(ctx.parseUri(new URL("https://example.com/users/handle/outbox")), {
+			type: "outbox",
+			identifier: "handle",
+			handle: "handle"
+		});
+		assertEquals(ctx.parseUri(null), null);
+		federation.setFollowingDispatcher("/users/{identifier}/following", () => ({ items: [] }));
+		ctx = federation.createContext(new URL("https://example.com/"), 123);
+		assertEquals(ctx.getFollowingUri("handle"), new URL("https://example.com/users/handle/following"));
+		assertEquals(ctx.parseUri(new URL("https://example.com/users/handle/following")), {
+			type: "following",
+			identifier: "handle",
+			handle: "handle"
+		});
+		assertEquals(ctx.parseUri(null), null);
+		federation.setFollowersDispatcher("/users/{identifier}/followers", () => ({ items: [] }));
+		ctx = federation.createContext(new URL("https://example.com/"), 123);
+		assertEquals(ctx.getFollowersUri("handle"), new URL("https://example.com/users/handle/followers"));
+		assertEquals(ctx.parseUri(new URL("https://example.com/users/handle/followers")), {
+			type: "followers",
+			identifier: "handle",
+			handle: "handle"
+		});
+		assertEquals(ctx.parseUri(null), null);
+		federation.setLikedDispatcher("/users/{identifier}/liked", () => ({ items: [] }));
+		ctx = federation.createContext(new URL("https://example.com/"), 123);
+		assertEquals(ctx.getLikedUri("handle"), new URL("https://example.com/users/handle/liked"));
+		assertEquals(ctx.parseUri(new URL("https://example.com/users/handle/liked")), {
+			type: "liked",
+			identifier: "handle",
+			handle: "handle"
+		});
+		assertEquals(ctx.parseUri(null), null);
+		federation.setFeaturedDispatcher("/users/{identifier}/featured", () => ({ items: [] }));
+		ctx = federation.createContext(new URL("https://example.com/"), 123);
+		assertEquals(ctx.getFeaturedUri("handle"), new URL("https://example.com/users/handle/featured"));
+		assertEquals(ctx.parseUri(new URL("https://example.com/users/handle/featured")), {
+			type: "featured",
+			identifier: "handle",
+			handle: "handle"
+		});
+		assertEquals(ctx.parseUri(null), null);
+		federation.setFeaturedTagsDispatcher("/users/{identifier}/tags", () => ({ items: [] }));
+		ctx = federation.createContext(new URL("https://example.com/"), 123);
+		assertEquals(ctx.getFeaturedTagsUri("handle"), new URL("https://example.com/users/handle/tags"));
+		assertEquals(ctx.parseUri(new URL("https://example.com/users/handle/tags")), {
+			type: "featuredTags",
+			identifier: "handle",
+			handle: "handle"
+		});
+		assertEquals(ctx.parseUri(null), null);
+	});
+	await t.step("Context with origin", () => {
+		const federation = createFederation({
+			kv,
+			origin: "https://ap.example.com",
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		const ctx = federation.createContext(new URL("https://example.com:1234/"));
+		assertEquals(ctx.origin, "https://example.com:1234");
+		assertEquals(ctx.canonicalOrigin, "https://ap.example.com");
+		assertEquals(ctx.host, "example.com:1234");
+		assertEquals(ctx.hostname, "example.com");
+		federation.setNodeInfoDispatcher("/nodeinfo/2.1", () => ({
+			software: {
+				name: "Example",
+				version: {
+					major: 1,
+					minor: 2,
+					patch: 3
+				}
+			},
+			protocols: ["activitypub"],
+			usage: {
+				users: {},
+				localPosts: 123,
+				localComments: 456
+			}
+		}));
+		assertEquals(ctx.getNodeInfoUri(), new URL("https://ap.example.com/nodeinfo/2.1"));
+		federation.setActorDispatcher("/users/{identifier}", () => new Person({}));
+		assertEquals(ctx.getActorUri("handle"), new URL("https://ap.example.com/users/handle"));
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/users/handle")), {
+			type: "actor",
+			handle: "handle",
+			identifier: "handle"
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/users/handle")), {
+			type: "actor",
+			handle: "handle",
+			identifier: "handle"
+		});
+		federation.setObjectDispatcher(Note, "/users/{identifier}/notes/{id}", (_ctx, values) => {
+			return new Note({ summary: `Note ${values.id} by ${values.identifier}` });
+		});
+		assertEquals(ctx.getObjectUri(Note, {
+			identifier: "john",
+			id: "123"
+		}), new URL("https://ap.example.com/users/john/notes/123"));
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/users/john/notes/123")), {
+			type: "object",
+			class: Note,
+			typeId: new URL("https://www.w3.org/ns/activitystreams#Note"),
+			values: {
+				identifier: "john",
+				id: "123"
+			}
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/users/john/notes/123")), {
+			type: "object",
+			class: Note,
+			typeId: new URL("https://www.w3.org/ns/activitystreams#Note"),
+			values: {
+				identifier: "john",
+				id: "123"
+			}
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox");
+		assertEquals(ctx.getInboxUri(), new URL("https://ap.example.com/inbox"));
+		assertEquals(ctx.getInboxUri("handle"), new URL("https://ap.example.com/users/handle/inbox"));
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/inbox")), {
+			type: "inbox",
+			handle: void 0,
+			identifier: void 0
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/inbox")), {
+			type: "inbox",
+			handle: void 0,
+			identifier: void 0
+		});
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/users/handle/inbox")), {
+			type: "inbox",
+			handle: "handle",
+			identifier: "handle"
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/users/handle/inbox")), {
+			type: "inbox",
+			handle: "handle",
+			identifier: "handle"
+		});
+		federation.setOutboxDispatcher("/users/{identifier}/outbox", () => ({ items: [] }));
+		assertEquals(ctx.getOutboxUri("handle"), new URL("https://ap.example.com/users/handle/outbox"));
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/users/handle/outbox")), {
+			type: "outbox",
+			handle: "handle",
+			identifier: "handle"
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/users/handle/outbox")), {
+			type: "outbox",
+			handle: "handle",
+			identifier: "handle"
+		});
+		federation.setFollowingDispatcher("/users/{identifier}/following", () => ({ items: [] }));
+		assertEquals(ctx.getFollowingUri("handle"), new URL("https://ap.example.com/users/handle/following"));
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/users/handle/following")), {
+			type: "following",
+			handle: "handle",
+			identifier: "handle"
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/users/handle/following")), {
+			type: "following",
+			handle: "handle",
+			identifier: "handle"
+		});
+		federation.setFollowersDispatcher("/users/{identifier}/followers", () => ({ items: [] }));
+		assertEquals(ctx.getFollowersUri("handle"), new URL("https://ap.example.com/users/handle/followers"));
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/users/handle/followers")), {
+			type: "followers",
+			handle: "handle",
+			identifier: "handle"
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/users/handle/followers")), {
+			type: "followers",
+			handle: "handle",
+			identifier: "handle"
+		});
+		federation.setLikedDispatcher("/users/{identifier}/liked", () => ({ items: [] }));
+		assertEquals(ctx.getLikedUri("handle"), new URL("https://ap.example.com/users/handle/liked"));
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/users/handle/liked")), {
+			type: "liked",
+			handle: "handle",
+			identifier: "handle"
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/users/handle/liked")), {
+			type: "liked",
+			handle: "handle",
+			identifier: "handle"
+		});
+		federation.setFeaturedDispatcher("/users/{identifier}/featured", () => ({ items: [] }));
+		assertEquals(ctx.getFeaturedUri("handle"), new URL("https://ap.example.com/users/handle/featured"));
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/users/handle/featured")), {
+			type: "featured",
+			handle: "handle",
+			identifier: "handle"
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/users/handle/featured")), {
+			type: "featured",
+			handle: "handle",
+			identifier: "handle"
+		});
+		federation.setFeaturedTagsDispatcher("/users/{identifier}/tags", () => ({ items: [] }));
+		assertEquals(ctx.getFeaturedTagsUri("handle"), new URL("https://ap.example.com/users/handle/tags"));
+		assertEquals(ctx.parseUri(new URL("https://ap.example.com/users/handle/tags")), {
+			type: "featuredTags",
+			handle: "handle",
+			identifier: "handle"
+		});
+		assertEquals(ctx.parseUri(new URL("https://example.com:1234/users/handle/tags")), {
+			type: "featuredTags",
+			handle: "handle",
+			identifier: "handle"
+		});
+	});
+	mock("GET@/.well-known/nodeinfo", (req) => {
+		assertEquals(new URL(req.url).host, "example.com");
+		assertEquals(req.headers.get("User-Agent"), "CustomUserAgent/1.2.3");
+		return new Response(JSON.stringify({ links: [{
+			rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
+			href: "https://example.com/nodeinfo/2.1"
+		}] }));
+	});
+	mock("GET@/nodeinfo/2.1", (req) => {
+		assertEquals(new URL(req.url).host, "example.com");
+		assertEquals(req.headers.get("User-Agent"), "CustomUserAgent/1.2.3");
+		return new Response(JSON.stringify({
+			software: {
+				name: "foo",
+				version: "1.2.3"
+			},
+			protocols: ["activitypub", "diaspora"],
+			usage: {
+				users: {},
+				localPosts: 123,
+				localComments: 456
+			}
+		}));
+	});
+	await t.step("Context.lookupNodeInfo()", async () => {
+		const federation = createFederation({
+			kv,
+			userAgent: "CustomUserAgent/1.2.3"
+		});
+		const ctx = federation.createContext(new URL("https://example.com/"), 123);
+		const nodeInfo = await ctx.lookupNodeInfo("https://example.com/");
+		assertEquals(nodeInfo, {
+			software: {
+				name: "foo",
+				version: {
+					major: 1,
+					minor: 2,
+					patch: 3,
+					build: [],
+					prerelease: []
+				}
+			},
+			protocols: ["activitypub", "diaspora"],
+			usage: {
+				users: {},
+				localPosts: 123,
+				localComments: 456
+			}
+		});
+		const rawNodeInfo = await ctx.lookupNodeInfo("https://example.com/", { parse: "none" });
+		assertEquals(rawNodeInfo, {
+			software: {
+				name: "foo",
+				version: "1.2.3"
+			},
+			protocols: ["activitypub", "diaspora"],
+			usage: {
+				users: {},
+				localPosts: 123,
+				localComments: 456
+			}
+		});
+	});
+	await t.step("RequestContext", async () => {
+		const federation = createFederation({
+			kv,
+			documentLoader: mockDocumentLoader
+		});
+		const req = new Request("https://example.com/");
+		const ctx = federation.createContext(req, 123);
+		assertEquals(ctx.request, req);
+		assertEquals(ctx.url, new URL("https://example.com/"));
+		assertEquals(ctx.origin, "https://example.com");
+		assertEquals(ctx.host, "example.com");
+		assertEquals(ctx.hostname, "example.com");
+		assertEquals(ctx.data, 123);
+		await assertRejects(() => ctx.getActor("someone"), Error);
+		await assertRejects(() => ctx.getObject(Note, {
+			handle: "someone",
+			id: "123"
+		}), Error);
+		assertEquals(await ctx.getSignedKey(), null);
+		assertEquals(await ctx.getSignedKeyOwner(), null);
+		assertEquals(await ctx.getSignedKey(), null);
+		assertEquals(await ctx.getSignedKeyOwner(), null);
+		await assertRejects(() => ctx.getActor("someone"), Error, "No actor dispatcher registered");
+		const signedReq = await signRequest(new Request("https://example.com/"), rsaPrivateKey2, rsaPublicKey2.id);
+		const signedCtx = federation.createContext(signedReq, 456);
+		assertEquals(signedCtx.request, signedReq);
+		assertEquals(signedCtx.url, new URL("https://example.com/"));
+		assertEquals(signedCtx.data, 456);
+		assertEquals(await signedCtx.getSignedKey(), rsaPublicKey2);
+		assertEquals(await signedCtx.getSignedKeyOwner(), null);
+		assertEquals(await signedCtx.getSignedKey(), rsaPublicKey2);
+		assertEquals(await signedCtx.getSignedKeyOwner(), null);
+		const signedReq2 = await signRequest(new Request("https://example.com/"), rsaPrivateKey3, rsaPublicKey3.id);
+		const signedCtx2 = federation.createContext(signedReq2, 456);
+		assertEquals(signedCtx2.request, signedReq2);
+		assertEquals(signedCtx2.url, new URL("https://example.com/"));
+		assertEquals(signedCtx2.data, 456);
+		assertEquals(await signedCtx2.getSignedKey(), rsaPublicKey3);
+		const expectedOwner = await lookupObject("https://example.com/person2", {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		assertEquals(await signedCtx2.getSignedKeyOwner(), expectedOwner);
+		assertEquals(await signedCtx2.getSignedKey(), rsaPublicKey3);
+		assertEquals(await signedCtx2.getSignedKeyOwner(), expectedOwner);
+		federation.setActorDispatcher("/users/{identifier}", (_ctx, identifier) => new Person({ preferredUsername: identifier }));
+		const ctx2 = federation.createContext(req, 789);
+		assertEquals(ctx2.request, req);
+		assertEquals(ctx2.url, new URL("https://example.com/"));
+		assertEquals(ctx2.data, 789);
+		assertEquals(await ctx2.getActor("john"), new Person({ preferredUsername: "john" }));
+		federation.setObjectDispatcher(Note, "/users/{identifier}/notes/{id}", (_ctx, values) => {
+			return new Note({ summary: `Note ${values.id} by ${values.identifier}` });
+		});
+		const ctx3 = federation.createContext(req, 123);
+		assertEquals(ctx3.request, req);
+		assertEquals(ctx3.url, new URL("https://example.com/"));
+		assertEquals(ctx3.data, 123);
+		assertEquals(await ctx2.getObject(Note, {
+			identifier: "john",
+			id: "123"
+		}), new Note({ summary: "Note 123 by john" }));
+	});
+	uninstall();
+});
+test("Federation.setInboxListeners()", async (t) => {
+	const kv = new MemoryKvStore();
+	install();
+	mock("GET@/key2", async () => {
+		return new Response(JSON.stringify(await rsaPublicKey2.toJsonLd({ contextLoader: mockDocumentLoader })), { headers: { "Content-Type": "application/activity+json" } });
+	});
+	mock("GET@/person", async () => {
+		return new Response(await readFile(join(dirname(import.meta.dirname), "testing", "fixtures", "example.com", "person")), { headers: { "Content-Type": "application/activity+json" } });
+	});
+	mock("GET@/person2", async () => {
+		return new Response(await readFile(join(dirname(import.meta.dirname), "testing", "fixtures", "example.com", "person2")), { headers: { "Content-Type": "application/activity+json" } });
+	});
+	await t.step("path match", () => {
+		const federation = createFederation({
+			kv,
+			documentLoader: mockDocumentLoader
+		});
+		federation.setInboxDispatcher("/users/{identifier}/inbox", () => ({ items: [] }));
+		assertThrows(() => federation.setInboxListeners("/users/{identifier}/inbox2"), RouterError);
+	});
+	await t.step("wrong variables in path", () => {
+		const federation = createFederation({
+			kv,
+			documentLoader: mockDocumentLoader
+		});
+		assertThrows(() => federation.setInboxListeners("/users/inbox"), RouterError);
+		assertThrows(() => federation.setInboxListeners("/users/{identifier}/inbox/{id2}"), RouterError);
+		assertThrows(() => federation.setInboxListeners("/users/{identifier}/inbox/{handle}"), RouterError);
+		assertThrows(() => federation.setInboxListeners("/users/{identifier2}/inbox"), RouterError);
+	});
+	await t.step("on()", async () => {
+		const authenticatedRequests = [];
+		const federation = createFederation({
+			kv,
+			documentLoader: mockDocumentLoader,
+			authenticatedDocumentLoaderFactory(identity) {
+				const docLoader = getAuthenticatedDocumentLoader(identity);
+				return (url) => {
+					const urlObj = new URL(url);
+					authenticatedRequests.push([url, identity.keyId.href]);
+					if (urlObj.host === "example.com") return docLoader(url);
+					return mockDocumentLoader(url);
+				};
+			}
+		});
+		const inbox = [];
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, (ctx, create) => {
+			inbox.push([ctx, create]);
+		});
+		let response = await federation.fetch(new Request("https://example.com/inbox", { method: "POST" }), { contextData: void 0 });
+		assertEquals(inbox, []);
+		assertEquals(response.status, 404);
+		federation.setActorDispatcher("/users/{identifier}", (_, identifier) => identifier === "john" ? new Person({}) : null).setKeyPairsDispatcher(() => [{
+			privateKey: rsaPrivateKey2,
+			publicKey: rsaPublicKey2.publicKey
+		}]);
+		const options = {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		};
+		const activity = () => new Create({
+			id: new URL("https://example.com/activities/" + crypto.randomUUID()),
+			actor: new URL("https://example.com/person2")
+		});
+		response = await federation.fetch(new Request("https://example.com/inbox", {
+			method: "POST",
+			body: JSON.stringify(await activity().toJsonLd(options))
+		}), { contextData: void 0 });
+		assertEquals(inbox, []);
+		assertEquals(response.status, 401);
+		response = await federation.fetch(new Request("https://example.com/users/no-one/inbox", { method: "POST" }), { contextData: void 0 });
+		assertEquals(inbox, []);
+		assertEquals(response.status, 404);
+		response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
+			method: "POST",
+			body: JSON.stringify(await activity().toJsonLd(options))
+		}), { contextData: void 0 });
+		assertEquals(inbox, []);
+		assertEquals(response.status, 401);
+		const activityPayload = await activity().toJsonLd(options);
+		let request = new Request("https://example.com/users/john/inbox", {
+			method: "POST",
+			headers: { "Content-Type": "application/activity+json" },
+			body: JSON.stringify(activityPayload)
+		});
+		request = await signRequest(request, rsaPrivateKey3, new URL("https://example.com/person2#key3"));
+		response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(inbox.length, 1);
+		assertEquals(inbox[0][1].actorId, new URL("https://example.com/person2"));
+		assertEquals(response.status, 202);
+		while (authenticatedRequests.length > 0) authenticatedRequests.shift();
+		assertEquals(authenticatedRequests, []);
+		await inbox[0][0].documentLoader("https://example.com/person");
+		assertEquals(authenticatedRequests, [["https://example.com/person", "https://example.com/users/john#main-key"]]);
+		response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(inbox.length, 1);
+		inbox.shift();
+		request = new Request("https://another.host/users/john/inbox", {
+			method: "POST",
+			headers: { "Content-Type": "application/activity+json" },
+			body: JSON.stringify(activityPayload)
+		});
+		request = await signRequest(request, rsaPrivateKey3, new URL("https://example.com/person2#key3"));
+		response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(inbox.length, 1);
+		assertEquals(inbox[0][1].actorId, new URL("https://example.com/person2"));
+		assertEquals(response.status, 202);
+		while (authenticatedRequests.length > 0) authenticatedRequests.shift();
+		assertEquals(authenticatedRequests, []);
+		await inbox[0][0].documentLoader("https://example.com/person");
+		assertEquals(authenticatedRequests, [["https://example.com/person", "https://another.host/users/john#main-key"]]);
+		inbox.shift();
+		request = new Request("https://example.com/inbox", {
+			method: "POST",
+			headers: { "Content-Type": "application/activity+json" },
+			body: JSON.stringify(await activity().toJsonLd(options))
+		});
+		request = await signRequest(request, rsaPrivateKey3, new URL("https://example.com/person2#key3"));
+		response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(inbox.length, 1);
+		assertEquals(inbox[0][1].actorId, new URL("https://example.com/person2"));
+		assertEquals(response.status, 202);
+		while (authenticatedRequests.length > 0) authenticatedRequests.shift();
+		assertEquals(authenticatedRequests, []);
+		await inbox[0][0].documentLoader("https://example.com/person");
+		assertEquals(authenticatedRequests, []);
+		inbox.shift();
+		request = new Request("https://example.com/users/john/inbox", {
+			method: "POST",
+			headers: { "Content-Type": "application/activity+json" },
+			body: JSON.stringify(await (await signObject(activity(), ed25519PrivateKey, ed25519Multikey.id, options)).toJsonLd(options))
+		});
+		response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(inbox.length, 1);
+		assertEquals(inbox[0][1].actorId, new URL("https://example.com/person2"));
+		assertEquals(response.status, 202);
+		while (authenticatedRequests.length > 0) authenticatedRequests.shift();
+		assertEquals(authenticatedRequests, []);
+		await inbox[0][0].documentLoader("https://example.com/person");
+		assertEquals(authenticatedRequests, [["https://example.com/person", "https://example.com/users/john#main-key"]]);
+	});
+	await t.step("onError()", async () => {
+		const federation = createFederation({
+			kv,
+			documentLoader: mockDocumentLoader,
+			authenticatedDocumentLoaderFactory(identity) {
+				const docLoader = getAuthenticatedDocumentLoader(identity);
+				return (url) => {
+					const urlObj = new URL(url);
+					if (urlObj.host === "example.com") return docLoader(url);
+					return mockDocumentLoader(url);
+				};
+			}
+		});
+		federation.setActorDispatcher("/users/{identifier}", (_, identifier) => identifier === "john" ? new Person({}) : null).setKeyPairsDispatcher(() => [{
+			privateKey: rsaPrivateKey2,
+			publicKey: rsaPublicKey2.publicKey
+		}]);
+		const error = new Error("test");
+		const errors = [];
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, () => {
+			throw error;
+		}).onError((_, e) => {
+			errors.push(e);
+		});
+		const activity = new Create({ actor: new URL("https://example.com/person") });
+		let request = new Request("https://example.com/users/john/inbox", {
+			method: "POST",
+			headers: { "Content-Type": "application/activity+json" },
+			body: JSON.stringify(await activity.toJsonLd({ contextLoader: mockDocumentLoader }))
+		});
+		request = await signRequest(request, rsaPrivateKey2, new URL("https://example.com/key2"));
+		const response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(errors.length, 1);
+		assertEquals(errors[0], error);
+		assertEquals(response.status, 500);
+	});
+	uninstall();
+});
+test("Federation.setInboxDispatcher()", async (t) => {
+	const kv = new MemoryKvStore();
+	await t.step("path match", () => {
+		const federation = createFederation({
+			kv,
+			documentLoader: mockDocumentLoader
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox");
+		assertThrows(() => federation.setInboxDispatcher("/users/{identifier}/inbox2", () => ({ items: [] })), RouterError);
+	});
+	await t.step("path match", () => {
+		const federation = createFederation({
+			kv,
+			documentLoader: mockDocumentLoader
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox");
+		federation.setInboxDispatcher("/users/{identifier}/inbox", () => ({ items: [] }));
+	});
+	await t.step("wrong variables in path", () => {
+		const federation = createFederation({
+			kv,
+			documentLoader: mockDocumentLoader
+		});
+		assertThrows(() => federation.setInboxDispatcher("/users/inbox", () => ({ items: [] })), RouterError);
+		assertThrows(() => federation.setInboxDispatcher("/users/{identifier}/inbox/{identifier2}", () => ({ items: [] })), RouterError);
+		assertThrows(() => federation.setInboxDispatcher("/users/{identifier2}/inbox", () => ({ items: [] })), RouterError);
+	});
+});
+test("FederationImpl.sendActivity()", async (t) => {
+	install();
+	let verified = null;
+	let request = null;
+	mock("POST@/inbox", async (req) => {
+		verified = [];
+		request = req.clone();
+		const options = {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		};
+		let json = await req.json();
+		if (await verifyJsonLd(json, options)) verified.push("ld");
+		json = detachSignature(json);
+		let activity = await verifyObject(Activity, json, options);
+		if (activity == null) activity = await Activity.fromJsonLd(json, options);
+		else verified.push("proof");
+		const key = await verifyRequest(request, options);
+		if (key != null && await doesActorOwnKey(activity, key, options)) verified.push("http");
+		if (verified.length > 0) return new Response(null, { status: 202 });
+		return new Response(null, { status: 401 });
+	});
+	const kv = new MemoryKvStore();
+	const federation = new FederationImpl({
+		kv,
+		contextLoader: mockDocumentLoader
+	});
+	const context = federation.createContext(new URL("https://example.com/"));
+	await t.step("success", async () => {
+		const activity = new Create({
+			id: new URL("https://example.com/activity/1"),
+			actor: new URL("https://example.com/person")
+		});
+		const inboxes = { "https://example.com/inbox": {
+			actorIds: ["https://example.com/recipient"],
+			sharedInbox: false
+		} };
+		await federation.sendActivity([{
+			privateKey: rsaPrivateKey2,
+			keyId: rsaPublicKey2.id
+		}], inboxes, activity, { context });
+		assertEquals(verified, ["http"]);
+		assertInstanceOf(request, Request);
+		assertEquals(request?.method, "POST");
+		assertEquals(request?.url, "https://example.com/inbox");
+		assertEquals(request?.headers.get("Content-Type"), "application/activity+json");
+		verified = null;
+		await federation.sendActivity([{
+			privateKey: rsaPrivateKey3,
+			keyId: rsaPublicKey3.id
+		}], inboxes, activity.clone({ actor: new URL("https://example.com/person2") }), { context });
+		assertEquals(verified, ["ld", "http"]);
+		assertInstanceOf(request, Request);
+		assertEquals(request?.method, "POST");
+		assertEquals(request?.url, "https://example.com/inbox");
+		assertEquals(request?.headers.get("Content-Type"), "application/activity+json");
+		verified = null;
+		await federation.sendActivity([{
+			privateKey: ed25519PrivateKey,
+			keyId: ed25519Multikey.id
+		}], inboxes, activity.clone({ actor: new URL("https://example.com/person2") }), { context });
+		assertEquals(verified, ["proof"]);
+		assertInstanceOf(request, Request);
+		assertEquals(request?.method, "POST");
+		assertEquals(request?.url, "https://example.com/inbox");
+		assertEquals(request?.headers.get("Content-Type"), "application/activity+json");
+		verified = null;
+		await federation.sendActivity([{
+			privateKey: rsaPrivateKey3,
+			keyId: rsaPublicKey3.id
+		}, {
+			privateKey: ed25519PrivateKey,
+			keyId: ed25519Multikey.id
+		}], inboxes, activity.clone({ actor: new URL("https://example.com/person2") }), { context });
+		assertEquals(verified, [
+			"ld",
+			"proof",
+			"http"
+		]);
+		assertInstanceOf(request, Request);
+		assertEquals(request?.method, "POST");
+		assertEquals(request?.url, "https://example.com/inbox");
+		assertEquals(request?.headers.get("Content-Type"), "application/activity+json");
+	});
+	uninstall();
+});
+test("ContextImpl.lookupObject()", async (t) => {
+	install();
+	mock("GET@/.well-known/webfinger", () => new Response(JSON.stringify({
+		subject: "acct:test@localhost",
+		links: [{
+			rel: "self",
+			type: "application/activity+json",
+			href: "https://localhost/actor"
+		}]
+	}), { headers: { "Content-Type": "application/jrd+json" } }));
+	mock("GET@/actor", () => new Response(JSON.stringify({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		"type": "Person",
+		"id": "https://localhost/actor",
+		"preferredUsername": "test"
+	}), { headers: { "Content-Type": "application/activity+json" } }));
+	await t.step("allowPrivateAddress: true", async () => {
+		const federation = createFederation({
+			kv: new MemoryKvStore(),
+			allowPrivateAddress: true
+		});
+		const ctx = federation.createContext(new URL("https://example.com/"));
+		const result = await ctx.lookupObject("@test@localhost");
+		assertInstanceOf(result, Person);
+		assertEquals(result.id, new URL("https://localhost/actor"));
+		assertEquals(result.preferredUsername, "test");
+	});
+	await t.step("allowPrivateAddress: false", async () => {
+		const federation = createFederation({
+			kv: new MemoryKvStore(),
+			allowPrivateAddress: false
+		});
+		const ctx = federation.createContext(new URL("https://example.com/"));
+		const result = await ctx.lookupObject("@test@localhost");
+		assertEquals(result, null);
+	});
+	uninstall();
+});
+test("ContextImpl.sendActivity()", async (t) => {
+	install();
+	let verified = null;
+	let request = null;
+	let collectionSyncHeader = null;
+	mock("POST@/inbox", async (req) => {
+		verified = [];
+		request = req.clone();
+		collectionSyncHeader = req.headers.get("Collection-Synchronization");
+		const options = {
+			async documentLoader(url) {
+				const response = await federation.fetch(new Request(url), { contextData: void 0 });
+				if (response.ok) return {
+					contextUrl: null,
+					document: await response.json(),
+					documentUrl: response.url
+				};
+				return await mockDocumentLoader(url);
+			},
+			contextLoader: mockDocumentLoader,
+			keyCache: {
+				async get(keyId) {
+					const ctx = federation.createContext(new URL("https://example.com/"), void 0);
+					const keys = await ctx.getActorKeyPairs("1");
+					for (const key$1 of keys) if (key$1.keyId.href === keyId.href) if (key$1.publicKey.algorithm.name === "Ed25519") return key$1.multikey;
+					else return key$1.cryptographicKey;
+					return void 0;
+				},
+				async set(_keyId, _key) {}
+			}
+		};
+		let json = await req.json();
+		if (await verifyJsonLd(json, options)) verified.push("ld");
+		json = detachSignature(json);
+		let activity = await verifyObject(Activity, json, options);
+		if (activity == null) activity = await Activity.fromJsonLd(json, options);
+		else verified.push("proof");
+		const key = await verifyRequest(request, options);
+		if (key != null && await doesActorOwnKey(activity, key, options)) verified.push("http");
+		if (verified.length > 0) return new Response(null, { status: 202 });
+		return new Response(null, { status: 401 });
+	});
+	const kv = new MemoryKvStore();
+	const federation = new FederationImpl({
+		kv,
+		contextLoader: mockDocumentLoader
+	});
+	federation.setActorDispatcher("/{identifier}", async (ctx, identifier) => {
+		if (identifier !== "1") return null;
+		const keys = await ctx.getActorKeyPairs(identifier);
+		return new Person({
+			id: ctx.getActorUri(identifier),
+			preferredUsername: "john",
+			publicKey: keys[0].cryptographicKey,
+			assertionMethods: keys.map((k) => k.multikey)
+		});
+	}).setKeyPairsDispatcher((_ctx, identifier) => {
+		if (identifier !== "1") return [];
+		return [{
+			privateKey: rsaPrivateKey2,
+			publicKey: rsaPublicKey2.publicKey
+		}, {
+			privateKey: ed25519PrivateKey,
+			publicKey: ed25519PublicKey.publicKey
+		}];
+	}).mapHandle((_ctx, username) => username === "john" ? "1" : null);
+	federation.setFollowersDispatcher("/users/{identifier}/followers", () => ({ items: [{
+		id: new URL("https://example.com/recipient"),
+		inboxId: new URL("https://example.com/inbox")
+	}] }));
+	await t.step("success", async () => {
+		const activity = new Create({ actor: new URL("https://example.com/person") });
+		const ctx = new ContextImpl({
+			data: void 0,
+			federation,
+			url: new URL("https://example.com/"),
+			documentLoader: fetchDocumentLoader,
+			contextLoader: fetchDocumentLoader
+		});
+		await ctx.sendActivity([{
+			privateKey: rsaPrivateKey2,
+			keyId: rsaPublicKey2.id
+		}], {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, activity);
+		assertEquals(verified, ["http"]);
+		assertInstanceOf(request, Request);
+		assertEquals(request?.method, "POST");
+		assertEquals(request?.url, "https://example.com/inbox");
+		assertEquals(request?.headers.get("Content-Type"), "application/activity+json");
+		verified = null;
+		await ctx.sendActivity([{
+			privateKey: rsaPrivateKey3,
+			keyId: rsaPublicKey3.id
+		}], {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, activity.clone({ actor: new URL("https://example.com/person2") }));
+		assertEquals(verified, ["ld", "http"]);
+		assertInstanceOf(request, Request);
+		assertEquals(request?.method, "POST");
+		assertEquals(request?.url, "https://example.com/inbox");
+		assertEquals(request?.headers.get("Content-Type"), "application/activity+json");
+		verified = null;
+		await ctx.sendActivity({ identifier: "1" }, {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, activity.clone({ actor: ctx.getActorUri("1") }));
+		assertEquals(verified, [
+			"ld",
+			"proof",
+			"http"
+		]);
+		assertInstanceOf(request, Request);
+		assertEquals(request?.method, "POST");
+		assertEquals(request?.url, "https://example.com/inbox");
+		assertEquals(request?.headers.get("Content-Type"), "application/activity+json");
+		verified = null;
+		await ctx.sendActivity({ username: "john" }, {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, activity.clone({ actor: ctx.getActorUri("1") }));
+		assertEquals(verified, [
+			"ld",
+			"proof",
+			"http"
+		]);
+		assertInstanceOf(request, Request);
+		assertEquals(request?.method, "POST");
+		assertEquals(request?.url, "https://example.com/inbox");
+		assertEquals(request?.headers.get("Content-Type"), "application/activity+json");
+		await assertRejects(() => ctx.sendActivity({ identifier: "not-found" }, {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, activity.clone({ actor: ctx.getActorUri("1") })));
+		await assertRejects(() => ctx.sendActivity({ username: "not-found" }, {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, activity.clone({ actor: ctx.getActorUri("1") })));
+	});
+	const queue = {
+		messages: [],
+		enqueue(message) {
+			this.messages.push(message);
+			return Promise.resolve();
+		},
+		async listen() {},
+		clear() {
+			while (this.messages.length > 0) this.messages.shift();
+		}
+	};
+	const federation2 = new FederationImpl({
+		kv,
+		contextLoader: mockDocumentLoader,
+		queue
+	});
+	federation2.setActorDispatcher("/{identifier}", async (ctx, identifier) => {
+		if (identifier !== "john") return null;
+		const keys = await ctx.getActorKeyPairs(identifier);
+		return new 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 ctx2 = new ContextImpl({
+		data: void 0,
+		federation: federation2,
+		url: new URL("https://example.com/"),
+		documentLoader: fetchDocumentLoader,
+		contextLoader: fetchDocumentLoader
+	});
+	await t.step("fanout: \"force\"", async () => {
+		const activity = new Create({
+			id: new URL("https://example.com/activity/1"),
+			actor: new URL("https://example.com/person")
+		});
+		await ctx2.sendActivity({ username: "john" }, {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, activity, { fanout: "force" });
+		assertEquals(queue.messages, [{
+			id: queue.messages[0].id,
+			type: "fanout",
+			activity: await activity.toJsonLd({
+				format: "compact",
+				contextLoader: fetchDocumentLoader
+			}),
+			activityId: "https://example.com/activity/1",
+			activityType: "https://www.w3.org/ns/activitystreams#Create",
+			baseUrl: "https://example.com",
+			collectionSync: void 0,
+			inboxes: { "https://example.com/inbox": {
+				actorIds: ["https://example.com/recipient"],
+				sharedInbox: false
+			} },
+			keys: queue.messages[0].type === "fanout" ? queue.messages[0].keys : [],
+			traceContext: {}
+		}]);
+	});
+	queue.clear();
+	await t.step("fanout: \"skip\"", async () => {
+		const activity = new Create({
+			id: new URL("https://example.com/activity/1"),
+			actor: new URL("https://example.com/person")
+		});
+		await ctx2.sendActivity({ username: "john" }, {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, activity, { fanout: "skip" });
+		assertEquals(queue.messages, [{
+			...queue.messages[0],
+			type: "outbox"
+		}]);
+	});
+	queue.clear();
+	await t.step("fanout: \"auto\"", async () => {
+		const activity = new Create({
+			id: new URL("https://example.com/activity/1"),
+			actor: new URL("https://example.com/person")
+		});
+		await ctx2.sendActivity({ username: "john" }, {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, activity, { fanout: "auto" });
+		assertEquals(queue.messages, [{
+			...queue.messages[0],
+			type: "outbox"
+		}]);
+		queue.clear();
+		await ctx2.sendActivity({ username: "john" }, [
+			{
+				id: new URL("https://example.com/recipient"),
+				inboxId: new URL("https://example.com/inbox")
+			},
+			{
+				id: new URL("https://example2.com/recipient"),
+				inboxId: new URL("https://example2.com/inbox")
+			},
+			{
+				id: new URL("https://example3.com/recipient"),
+				inboxId: new URL("https://example3.com/inbox")
+			},
+			{
+				id: new URL("https://example4.com/recipient"),
+				inboxId: new URL("https://example4.com/inbox")
+			},
+			{
+				id: new URL("https://example5.com/recipient"),
+				inboxId: new URL("https://example5.com/inbox")
+			}
+		], activity, { fanout: "auto" });
+		assertEquals(queue.messages, [{
+			...queue.messages[0],
+			type: "fanout"
+		}]);
+	});
+	collectionSyncHeader = null;
+	await t.step("followers collection without syncCollection", async () => {
+		const ctx = new ContextImpl({
+			data: void 0,
+			federation,
+			url: new URL("https://example.com/"),
+			documentLoader: fetchDocumentLoader,
+			contextLoader: fetchDocumentLoader
+		});
+		const activity = new Create({
+			id: new URL("https://example.com/activity/1"),
+			actor: ctx.getActorUri("1"),
+			to: ctx.getFollowersUri("1")
+		});
+		await ctx.sendActivity({ identifier: "1" }, "followers", activity);
+		assertEquals(collectionSyncHeader, null);
+	});
+	collectionSyncHeader = null;
+	await t.step("followers collection with syncCollection", async () => {
+		const ctx = new ContextImpl({
+			data: void 0,
+			federation,
+			url: new URL("https://example.com/"),
+			documentLoader: fetchDocumentLoader,
+			contextLoader: fetchDocumentLoader
+		});
+		const activity = new Create({
+			id: new URL("https://example.com/activity/2"),
+			actor: ctx.getActorUri("1"),
+			to: ctx.getFollowersUri("1")
+		});
+		await ctx.sendActivity({ identifier: "1" }, "followers", activity, {
+			syncCollection: true,
+			preferSharedInbox: true
+		});
+		assertNotEquals(collectionSyncHeader, null);
+	});
+});
+test("ContextImpl.routeActivity()", async () => {
+	const federation = new FederationImpl({ kv: new MemoryKvStore() });
+	const activities = [];
+	federation.setInboxListeners("/u/{identifier}/i", "/i").on(Offer, (ctx$1, offer) => {
+		activities.push([ctx$1.recipient, offer]);
+	});
+	const ctx = new ContextImpl({
+		url: new URL("https://example.com/"),
+		federation,
+		data: void 0,
+		documentLoader: mockDocumentLoader,
+		contextLoader: fetchDocumentLoader
+	});
+	assertFalse(await ctx.routeActivity(null, new Offer({ actor: new URL("https://example.com/person") })));
+	assertEquals(activities, []);
+	const signedOffer = await signObject(new Offer({ actor: new URL("https://example.com/person2") }), ed25519PrivateKey, ed25519Multikey.id);
+	assert(await ctx.routeActivity(null, signedOffer));
+	assertEquals(activities, [[null, signedOffer]]);
+	const signedInvite = await signObject(new Invite({ actor: new URL("https://example.com/person2") }), ed25519PrivateKey, ed25519Multikey.id);
+	assert(await ctx.routeActivity("id", signedInvite));
+	assertEquals(activities, [[null, signedOffer], ["id", signedInvite]]);
+	assertFalse(await ctx.routeActivity(null, new Create({
+		id: new URL("https://example.com/not-found"),
+		actor: new URL("https://example.com/person")
+	})));
+	assertEquals(activities, [[null, signedOffer], ["id", signedInvite]]);
+	assertFalse(await ctx.routeActivity(null, new Create({
+		id: new URL("https://example.com/person"),
+		actor: new URL("https://example.com/person")
+	})));
+	assertEquals(activities, [[null, signedOffer], ["id", signedInvite]]);
+	assertFalse(await ctx.routeActivity(null, new Announce({
+		id: new URL("https://example.com/announce#diffrent-id"),
+		actor: new URL("https://example.com/person")
+	})));
+	assertEquals(activities, [[null, signedOffer], ["id", signedInvite]]);
+	assertFalse(await ctx.routeActivity(null, new Announce({
+		id: new URL("https://example.com/announce"),
+		actor: new URL("https://example.com/person")
+	})));
+	assertEquals(activities, [[null, signedOffer], ["id", signedInvite]]);
+	assertFalse(await ctx.routeActivity(null, new Create({
+		id: new URL("https://example.com/cross-origin-actor"),
+		actor: new URL("https://cross-origin.com/actor")
+	})));
+	assertEquals(activities, [[null, signedOffer], ["id", signedInvite]]);
+	assert(await ctx.routeActivity(null, new Create({
+		id: new URL("https://example.com/create"),
+		actor: new URL("https://example.com/person")
+	})));
+	assertEquals(activities, [[null, signedOffer], ["id", signedInvite]]);
+	assert(await ctx.routeActivity(null, new Invite({
+		id: new URL("https://example.com/invite"),
+		actor: new URL("https://example.com/person")
+	})));
+	assertEquals(activities, [
+		[null, signedOffer],
+		["id", signedInvite],
+		[null, new Invite({
+			id: new URL("https://example.com/invite"),
+			actor: new URL("https://example.com/person"),
+			object: new URL("https://example.com/object")
+		})]
+	]);
+});
+test("InboxContextImpl.forwardActivity()", async (t) => {
+	install();
+	let verified = null;
+	let request = null;
+	mock("POST@/inbox", async (req) => {
+		verified = [];
+		request = req.clone();
+		const options = {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		};
+		let json = await req.json();
+		if (await verifyJsonLd(json, options)) verified.push("ld");
+		json = detachSignature(json);
+		let activity = await verifyObject(Activity, json, options);
+		if (activity == null) activity = await Activity.fromJsonLd(json, options);
+		else verified.push("proof");
+		const key = await verifyRequest(request, options);
+		if (key != null && await doesActorOwnKey(activity, key, options)) verified.push("http");
+		if (verified.length > 0) return new Response(null, { status: 202 });
+		return new Response(null, { status: 401 });
+	});
+	const kv = new MemoryKvStore();
+	const federation = new FederationImpl({
+		kv,
+		contextLoader: mockDocumentLoader
+	});
+	await t.step("skip", async () => {
+		const activity = {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			"type": "Create",
+			"id": "https://example.com/activity",
+			"actor": "https://example.com/person2"
+		};
+		const ctx = new InboxContextImpl(null, activity, "https://example.com/activity", "https://www.w3.org/ns/activitystreams#Create", {
+			data: void 0,
+			federation,
+			url: new URL("https://example.com/"),
+			documentLoader: fetchDocumentLoader,
+			contextLoader: fetchDocumentLoader
+		});
+		await ctx.forwardActivity([{
+			privateKey: rsaPrivateKey2,
+			keyId: rsaPublicKey2.id
+		}], {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, { skipIfUnsigned: true });
+		assertEquals(verified, null);
+	});
+	await t.step("unsigned", async () => {
+		const activity = {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			"type": "Create",
+			"id": "https://example.com/activity",
+			"actor": "https://example.com/person2"
+		};
+		const ctx = new InboxContextImpl(null, activity, "https://example.com/activity", "https://www.w3.org/ns/activitystreams#Create", {
+			data: void 0,
+			federation,
+			url: new URL("https://example.com/"),
+			documentLoader: fetchDocumentLoader,
+			contextLoader: fetchDocumentLoader
+		});
+		await assertRejects(() => ctx.forwardActivity([{
+			privateKey: rsaPrivateKey2,
+			keyId: rsaPublicKey2.id
+		}], {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}));
+		assertEquals(verified, []);
+	});
+	await t.step("Object Integrity Proofs", async () => {
+		const activity = await signObject(new Create({
+			id: new URL("https://example.com/activity"),
+			actor: new URL("https://example.com/person2")
+		}), ed25519PrivateKey, ed25519Multikey.id, {
+			contextLoader: mockDocumentLoader,
+			documentLoader: mockDocumentLoader
+		});
+		const ctx = new InboxContextImpl(null, await activity.toJsonLd({ contextLoader: mockDocumentLoader }), activity.id?.href, getTypeId(activity).href, {
+			data: void 0,
+			federation,
+			url: new URL("https://example.com/"),
+			documentLoader: fetchDocumentLoader,
+			contextLoader: fetchDocumentLoader
+		});
+		await ctx.forwardActivity([{
+			privateKey: rsaPrivateKey2,
+			keyId: rsaPublicKey2.id
+		}], {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, { skipIfUnsigned: true });
+		assertEquals(verified, ["proof"]);
+	});
+	await t.step("LD Signatures", async () => {
+		const activity = await signJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			"type": "Create",
+			"id": "https://example.com/activity",
+			"actor": "https://example.com/person2"
+		}, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader });
+		const ctx = new InboxContextImpl(null, activity, "https://example.com/activity", "https://www.w3.org/ns/activitystreams#Create", {
+			data: void 0,
+			federation,
+			url: new URL("https://example.com/"),
+			documentLoader: fetchDocumentLoader,
+			contextLoader: fetchDocumentLoader
+		});
+		await ctx.forwardActivity([{
+			privateKey: rsaPrivateKey2,
+			keyId: rsaPublicKey2.id
+		}], {
+			id: new URL("https://example.com/recipient"),
+			inboxId: new URL("https://example.com/inbox")
+		}, { skipIfUnsigned: true });
+		assertEquals(verified, ["ld"]);
+	});
+	uninstall();
+});
+
+//#endregion