@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

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

@@ -0,0 +1,832 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+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 { a as signObject, c as verifyPortableObjectProof } from "../proof-Dxy6ByqI.mjs";
+import { n as ed25519PrivateKey, r as ed25519PublicKey } from "../keys-DIJNHW-Y.mjs";
+import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-D7_LO-Vs.mjs";
+import { t as verifyPortableObject } from "../portable-collection-C74P1vtC.mjs";
+import { c as verifyServedPortableObjects } from "../compound-proof-B-9mXxFW.mjs";
+import { n as RouterError } from "../router-u5O5KCQr.mjs";
+import { configure, reset } from "@logtape/logtape";
+import { Create, Note, Object as Object$1, OrderedCollection, PUBLIC_COLLECTION, Person, Tombstone, lookupObject, traverseCollection } from "@fedify/vocab";
+import { FetchError, exportDidKey, formatIri, parseIri, toCompatibleEf61Id } from "@fedify/vocab-runtime";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+//#region src/federation/portable-collection.test.ts
+const did = await exportDidKey(ed25519PublicKey.publicKey);
+const keyId = new URL(`${did}#${did.slice(8)}`);
+const otherKeyPair = await crypto.subtle.generateKey("Ed25519", true, ["sign", "verify"]);
+const otherDid = await exportDidKey(otherKeyPair.publicKey);
+const otherKeyId = new URL(`${otherDid}#${otherDid.slice(8)}`);
+const ORIGIN = "https://example.com";
+const ACCEPT = "application/activity+json";
+function gatewayUrl(path, authority = did) {
+	return `${ORIGIN}/.well-known/apgateway/${authority}${path}`;
+}
+function portableId(path, authority = did) {
+	return `ap+ef61://${authority}${path}`;
+}
+async function fetchJson(federation, url, init = {}) {
+	const response = await federation.fetch(new Request(url, {
+		...init,
+		headers: {
+			Accept: ACCEPT,
+			...init.headers
+		}
+	}), { contextData: void 0 });
+	const body = await response.text();
+	const json = response.headers.get("Content-Type")?.includes("json");
+	return [response, body === "" || !json ? null : JSON.parse(body)];
+}
+async function sign(object, privateKey = ed25519PrivateKey, key = keyId) {
+	return await signObject(object, privateKey, key, { contextLoader: mockDocumentLoader });
+}
+/**
+* The DIDs of the actors that this server hosts, which the actor dispatcher
+* looks up by identifier, like an application would in its database.
+*/
+const users = {
+	alice: did,
+	bob: did,
+	carol: otherDid,
+	compatible: did,
+	mismatch: did,
+	"no-outbox": did,
+	https: did,
+	tombstone: did,
+	"request-did": did
+};
+const NOTES_PER_PAGE = 2;
+const PAGES = [
+	"0",
+	"1",
+	"2"
+];
+function getNoteValues(identifier, cursor, index) {
+	return { id: `${identifier}-${cursor}-${index}` };
+}
+function createTestFederation(options = {}) {
+	const calls = options.calls ?? [];
+	const federation = createFederation({
+		kv: new MemoryKvStore(),
+		documentLoaderFactory: () => mockDocumentLoader,
+		contextLoaderFactory: () => mockDocumentLoader
+	});
+	const noteCache = /* @__PURE__ */ new Map();
+	const getNote = async (ctx, id, authority) => {
+		const key = `${authority} ${id}`;
+		let note = noteCache.get(key);
+		if (note == null) {
+			note = await sign(new Note({
+				id: ctx.getPortableObjectUri(Note, { id }, authority),
+				to: PUBLIC_COLLECTION,
+				content: `Note ${id}`
+			}), authority === did ? ed25519PrivateKey : otherKeyPair.privateKey, authority === did ? keyId : otherKeyId);
+			noteCache.set(key, note);
+		}
+		return note;
+	};
+	federation.setActorDispatcher("/users/{identifier}", async (ctx, identifier) => {
+		calls.push(`actor ${identifier}`);
+		const userDid = users[identifier];
+		if (userDid == null) return null;
+		switch (identifier) {
+			case "https": return new Person({
+				id: ctx.getActorUri(identifier),
+				outbox: ctx.getOutboxUri(identifier)
+			});
+			case "tombstone": return new Tombstone({ id: ctx.getPortableActorUri(identifier, userDid) });
+			case "request-did": {
+				const authority = ctx.portableRequest?.authority;
+				return new Person({
+					id: ctx.getPortableActorUri(identifier, authority ?? userDid),
+					outbox: ctx.getPortableOutboxUri(identifier, authority ?? userDid),
+					gateways: [new URL(ORIGIN)]
+				});
+			}
+			case "compatible": {
+				const compatible = (id) => toCompatibleEf61Id(id, ORIGIN);
+				return new Person({
+					id: compatible(ctx.getPortableActorUri(identifier, userDid)),
+					outbox: compatible(ctx.getPortableOutboxUri(identifier, userDid)),
+					gateways: [new URL(ORIGIN), new URL("https://other.example")]
+				});
+			}
+		}
+		return await sign(new Person({
+			id: ctx.getPortableActorUri(identifier, userDid),
+			preferredUsername: identifier,
+			inbox: ctx.getPortableInboxUri(identifier, userDid),
+			outbox: identifier === "no-outbox" ? null : identifier === "mismatch" ? ctx.getPortableOutboxUri("alice", userDid) : ctx.getPortableOutboxUri(identifier, userDid),
+			followers: ctx.getPortableFollowersUri(identifier, userDid),
+			featured: ctx.getPortableFeaturedUri(identifier, userDid),
+			gateways: [new URL(ORIGIN)]
+		}), userDid === did ? ed25519PrivateKey : otherKeyPair.privateKey, userDid === did ? keyId : otherKeyId);
+	});
+	const createCache = /* @__PURE__ */ new Map();
+	const getCreate = async (ctx, id, authority) => {
+		const key = `${authority} ${id}`;
+		let create = createCache.get(key);
+		if (create == null) {
+			create = await sign(new Create({
+				id: ctx.getPortableObjectUri(Create, { id }, authority),
+				actor: ctx.getPortableActorUri("alice", authority),
+				to: PUBLIC_COLLECTION,
+				object: await getNote(ctx, id, authority)
+			}), authority === did ? ed25519PrivateKey : otherKeyPair.privateKey, authority === did ? keyId : otherKeyId);
+			createCache.set(key, create);
+		}
+		return create;
+	};
+	federation.setObjectDispatcher(Note, "/notes/{id}", (ctx, values) => ctx.portableRequest == null ? null : getNote(ctx, values.id, ctx.portableRequest.authority));
+	federation.setObjectDispatcher(Create, "/creates/{id}", (ctx, values) => ctx.portableRequest == null ? null : getCreate(ctx, values.id, ctx.portableRequest.authority));
+	const outbox = federation.setOutboxDispatcher("/users/{identifier}/outbox", async (ctx, identifier, cursor) => {
+		calls.push(`outbox ${identifier} ${cursor}`);
+		if (cursor == null) return null;
+		const authority = users[identifier];
+		const items = [];
+		for (let i = 0; i < NOTES_PER_PAGE; i++) items.push(await getCreate(ctx, getNoteValues(identifier, cursor, i).id, authority));
+		const index = PAGES.indexOf(cursor);
+		return {
+			items,
+			prevCursor: index > 0 ? PAGES[index - 1] : null,
+			nextCursor: index < PAGES.length - 1 ? PAGES[index + 1] : null
+		};
+	}).setFirstCursor((_ctx, identifier) => {
+		calls.push(`firstCursor ${identifier}`);
+		return PAGES[0];
+	}).setLastCursor(() => PAGES[PAGES.length - 1]).setCounter((_ctx, identifier) => {
+		calls.push(`counter ${identifier}`);
+		return PAGES.length * NOTES_PER_PAGE;
+	});
+	if (options.authorize) outbox.authorize((ctx, identifier) => {
+		calls.push(`authorize ${identifier} ${ctx.portableRequest?.authority ?? ""}`);
+		return ctx.request.headers.get("X-Allowed") === "yes";
+	});
+	federation.setFollowersDispatcher("/users/{identifier}/followers", (_ctx, _identifier) => ({ items: [{
+		id: new URL("https://a.example/users/1"),
+		inboxId: null
+	}, {
+		id: new URL("https://b.example/users/2"),
+		inboxId: null
+	}] }));
+	federation.setFeaturedDispatcher("/users/{identifier}/featured", () => ({ items: [] }));
+	if (options.inboxDispatcher ?? true) federation.setInboxDispatcher("/users/{identifier}/inbox", () => ({ items: [] }));
+	federation.setInboxListeners("/users/{identifier}/inbox");
+	federation.setOrderedCollectionDispatcher("bookmarks", Note, "/users/{identifier}/bookmarks", async (ctx, values, cursor) => {
+		calls.push(`bookmarks ${values.identifier} ${cursor}`);
+		const authority = users[values.identifier];
+		const tag = ctx.url.searchParams.get("tag") ?? "all";
+		return {
+			items: [await getNote(ctx, `${tag}-${cursor ?? "all"}`, authority)],
+			nextCursor: cursor === "0" ? "1" : null,
+			prevCursor: cursor === "1" ? "0" : null
+		};
+	}).setFirstCursor(() => "0").mapPortableOwner((_ctx, values) => values.identifier === "nobody" ? null : values.identifier);
+	federation.setCollectionDispatcher("drafts", Note, "/users/{identifier}/drafts", () => ({ items: [] }));
+	federation.setCollectionDispatcher("embedded", Object$1, "/embedded/{kind}", async (ctx, values) => {
+		const note = await getNote(ctx, values.kind, did);
+		switch (values.kind) {
+			case "signed": return { items: [note] };
+			case "other-did": return { items: [await getNote(ctx, "other", otherDid)] };
+			case "unsigned": return { items: [new Note({
+				id: ctx.getPortableObjectUri(Note, { id: "u" }, did),
+				content: "Unsigned"
+			})] };
+			case "tampered": return { items: [note.clone({ content: "Tampered" })] };
+			case "ordinary": return { items: [new Note({
+				id: new URL("https://example.com/notes/ordinary"),
+				content: "Ordinary"
+			})] };
+			case "nested": return { items: [await sign(new Create({
+				id: ctx.getPortableObjectUri(Note, { id: "create" }, did),
+				actor: ctx.getPortableActorUri("alice", did),
+				object: new Note({
+					id: ctx.getPortableObjectUri(Note, { id: "inner" }, did),
+					content: "Unsigned inner"
+				})
+			}))] };
+			case "replies": return { items: [await sign(new Note({
+				id: ctx.getPortableObjectUri(Note, { id: "replies" }, did),
+				content: "Replies",
+				replies: new OrderedCollection({
+					id: new URL(ctx.getPortableObjectUri(Note, { id: "replies" }, did).href + "/replies"),
+					totalItems: 0
+				})
+			}))] };
+		}
+		return null;
+	}).mapPortableOwner(() => "alice");
+	return federation;
+}
+test("Federation.fetch() serves portable outboxes", async (t) => {
+	const federation = createTestFederation();
+	await t.step("collection", async () => {
+		const [response, json] = await fetchJson(federation, gatewayUrl("/users/alice/outbox"));
+		assertEquals(response.status, 200);
+		assertEquals(response.headers.get("Content-Type"), PORTABLE_OBJECT_CONTENT_TYPE);
+		assertEquals(json?.id, portableId("/users/alice/outbox"));
+		assertEquals(json?.type, "OrderedCollection");
+		assertEquals(json?.attributedTo, portableId("/users/alice"));
+		assertEquals(json?.totalItems, PAGES.length * NOTES_PER_PAGE);
+		assertEquals(json?.first, portableId("/users/alice/outbox?cursor=0"));
+		assertEquals(json?.last, portableId("/users/alice/outbox?cursor=2"));
+	});
+	await t.step("pages", async () => {
+		const [response, json] = await fetchJson(federation, gatewayUrl("/users/alice/outbox?cursor=1"));
+		assertEquals(response.status, 200);
+		assertEquals(json?.id, portableId("/users/alice/outbox?cursor=1"));
+		assertEquals(json?.type, "OrderedCollectionPage");
+		assertEquals(json?.partOf, portableId("/users/alice/outbox"));
+		assertEquals(json?.attributedTo, portableId("/users/alice"));
+		assertEquals(json?.prev, portableId("/users/alice/outbox?cursor=0"));
+		assertEquals(json?.next, portableId("/users/alice/outbox?cursor=2"));
+		const items = json?.orderedItems;
+		assertEquals(items.map((item) => item.id), [0, 1].map((i) => portableId(`/creates/${getNoteValues("alice", "1", i).id}`)));
+		assert(items.every((item) => item.proof != null));
+		assert(items.every((item) => item["@context"] != null));
+	});
+	await t.step("HEAD", async () => {
+		const response = await federation.fetch(new Request(gatewayUrl("/users/alice/outbox?cursor=0"), {
+			method: "HEAD",
+			headers: { Accept: ACCEPT }
+		}), { contextData: void 0 });
+		assertEquals(response.status, 200);
+		assertEquals(await response.text(), "");
+	});
+	await t.step("location hints and other parameters", async () => {
+		const [response, json] = await fetchJson(federation, gatewayUrl("/users/alice/outbox?cursor=1&@gateway=https%3A%2F%2Fexample.com"));
+		assertEquals(response.status, 200);
+		assertEquals(json?.id, portableId("/users/alice/outbox?cursor=1"));
+		assertEquals(json?.partOf, portableId("/users/alice/outbox"));
+	});
+	await t.step("actors sharing a DID", async () => {
+		const [response, json] = await fetchJson(federation, gatewayUrl("/users/bob/outbox"));
+		assertEquals(response.status, 200);
+		assertEquals(json?.id, portableId("/users/bob/outbox"));
+		assertEquals(json?.attributedTo, portableId("/users/bob"));
+	});
+	await t.step("another DID", async () => {
+		const [response, json] = await fetchJson(federation, gatewayUrl("/users/carol/outbox", otherDid));
+		assertEquals(response.status, 200);
+		assertEquals(json?.id, portableId("/users/carol/outbox", otherDid));
+	});
+	await t.step("compatible identifiers", async () => {
+		const [response, json] = await fetchJson(federation, gatewayUrl("/users/compatible/outbox"));
+		assertEquals(response.status, 200);
+		assertEquals(json?.id, gatewayUrl("/users/compatible/outbox"));
+		assertEquals(json?.attributedTo, gatewayUrl("/users/compatible"));
+		assertEquals(json?.first, gatewayUrl("/users/compatible/outbox?cursor=0"));
+	});
+	await t.step("not acceptable", async () => {
+		assertEquals((await federation.fetch(new Request(gatewayUrl("/users/alice/outbox"), { headers: { Accept: "text/html" } }), { contextData: void 0 })).status, 406);
+	});
+});
+test("Federation.fetch() does not serve collections of other DIDs", async (t) => {
+	const calls = [];
+	const federation = createTestFederation({ calls });
+	const cases = {
+		"a DID that is not the actor's": gatewayUrl("/users/alice/outbox", otherDid),
+		"an actor that is not portable": gatewayUrl("/users/https/outbox"),
+		"an actor whose outbox is another": gatewayUrl("/users/mismatch/outbox"),
+		"an actor without an outbox": gatewayUrl("/users/no-outbox/outbox"),
+		"a deleted actor": gatewayUrl("/users/tombstone/outbox"),
+		"an unknown actor": gatewayUrl("/users/unknown/outbox"),
+		"an actor dispatcher taking the DID from the request": gatewayUrl("/users/request-did/outbox", otherDid),
+		"an unregistered collection": gatewayUrl("/users/alice/liked"),
+		"a custom collection without an owner mapper": gatewayUrl("/users/alice/drafts"),
+		"a custom collection whose owner mapper returns null": gatewayUrl("/users/nobody/bookmarks"),
+		"a custom collection of another DID": gatewayUrl("/users/alice/bookmarks", otherDid)
+	};
+	for (const [name, url] of Object.entries(cases)) await t.step(name, async () => {
+		calls.length = 0;
+		const [response] = await fetchJson(federation, url);
+		assertEquals(response.status, 404);
+		assertFalse(calls.some((call) => call.startsWith("outbox ")));
+		assertFalse(calls.some((call) => call.startsWith("bookmarks ")));
+	});
+	await t.step("malformed DIDs", async () => {
+		const [response] = await fetchJson(federation, gatewayUrl("/users/alice/outbox", "did:key:u" + did.slice(9)));
+		assertEquals(response.status, 400);
+	});
+});
+test("Federation.fetch() serves portable inbox collections only with an inbox dispatcher", async () => {
+	const [response, json] = await fetchJson(createTestFederation(), gatewayUrl("/users/alice/inbox"));
+	assertEquals(response.status, 200);
+	assertEquals(json?.id, portableId("/users/alice/inbox"));
+	const [response2] = await fetchJson(createTestFederation({ inboxDispatcher: false }), gatewayUrl("/users/alice/inbox"));
+	assertEquals(response2.status, 404);
+});
+test("Federation.fetch() filters portable followers collections", async () => {
+	const federation = createTestFederation();
+	const [response, json] = await fetchJson(federation, gatewayUrl("/users/alice/followers?base-url=" + encodeURIComponent("https://a.example/path")));
+	assertEquals(response.status, 200);
+	assertEquals(json?.id, portableId("/users/alice/followers?base-url=" + encodeURIComponent("https://a.example/")));
+	assertEquals(json?.orderedItems, ["https://a.example/users/1"]);
+	const collectionId = json?.id;
+	const [pageResponse, page] = await fetchJson(federation, gatewayUrl("/users/alice/followers?base-url=" + encodeURIComponent("https://a.example/path") + "&cursor=0"));
+	assertEquals(pageResponse.status, 200);
+	assertEquals(page?.id, `${collectionId}&cursor=0`);
+	assertEquals(page?.partOf, collectionId);
+	const [invalidResponse, invalidPage] = await fetchJson(federation, gatewayUrl("/users/alice/followers?base-url=invalid&cursor=0"));
+	assertEquals(invalidResponse.status, 200);
+	assertEquals(invalidPage?.id, portableId("/users/alice/followers?cursor=0"));
+	assertEquals(invalidPage?.partOf, portableId("/users/alice/followers"));
+});
+test("Federation.fetch() authorizes portable collection requests", async (t) => {
+	const calls = [];
+	const federation = createTestFederation({
+		authorize: true,
+		calls
+	});
+	await t.step("denied", async () => {
+		calls.length = 0;
+		const [response] = await fetchJson(federation, gatewayUrl("/users/alice/outbox"));
+		assertEquals(response.status, 401);
+		assertEquals(calls, ["actor alice", `authorize alice ${did}`]);
+	});
+	await t.step("allowed", async () => {
+		calls.length = 0;
+		const [response] = await fetchJson(federation, gatewayUrl("/users/alice/outbox?cursor=0"), { headers: { "X-Allowed": "yes" } });
+		assertEquals(response.status, 200);
+		assertEquals(calls.filter((call) => call.startsWith("authorize ")), [`authorize alice ${did}`]);
+	});
+	await t.step("a DID that is not the actor's", async () => {
+		calls.length = 0;
+		const [response] = await fetchJson(federation, gatewayUrl("/users/alice/outbox", otherDid), { headers: { "X-Allowed": "yes" } });
+		assertEquals(response.status, 404);
+		assertEquals(calls, ["actor alice"]);
+	});
+});
+test("Federation.fetch() serves portable custom collections", async (t) => {
+	const federation = createTestFederation();
+	await t.step("collection", async () => {
+		const [response, json] = await fetchJson(federation, gatewayUrl("/users/alice/bookmarks?tag=fedify"));
+		assertEquals(response.status, 200);
+		assertEquals(json?.id, portableId("/users/alice/bookmarks?tag=fedify"));
+		assertEquals(json?.attributedTo, portableId("/users/alice"));
+		assertEquals(json?.first, portableId("/users/alice/bookmarks?tag=fedify&cursor=0"));
+	});
+	await t.step("pages", async () => {
+		const [response, json] = await fetchJson(federation, gatewayUrl("/users/alice/bookmarks?tag=fedify&cursor=0"));
+		assertEquals(response.status, 200);
+		assertEquals(json?.id, portableId("/users/alice/bookmarks?tag=fedify&cursor=0"));
+		assertEquals(json?.partOf, portableId("/users/alice/bookmarks?tag=fedify"));
+		assertEquals(json?.next, portableId("/users/alice/bookmarks?tag=fedify&cursor=1"));
+		assertEquals((json?.orderedItems)[0].id, portableId("/notes/fedify-0"));
+	});
+	await t.step("compatible identifiers", async () => {
+		const [response, json] = await fetchJson(federation, gatewayUrl("/users/compatible/bookmarks"));
+		assertEquals(response.status, 200);
+		assertEquals(json?.id, gatewayUrl("/users/compatible/bookmarks"));
+		assertEquals(json?.attributedTo, gatewayUrl("/users/compatible"));
+	});
+});
+test("Federation.fetch() applies the proof policy to embedded portable objects", async (t) => {
+	const federation = createTestFederation();
+	for (const [kind, status] of Object.entries({
+		signed: 200,
+		"other-did": 200,
+		ordinary: 200,
+		replies: 200,
+		unsigned: 500,
+		tampered: 500,
+		nested: 500
+	})) await t.step(kind, async () => {
+		const [response] = await fetchJson(federation, gatewayUrl(`/embedded/${kind}`));
+		assertEquals(response.status, status);
+	});
+	await t.step("HEAD", async () => {
+		const response = await federation.fetch(new Request(gatewayUrl("/embedded/unsigned"), {
+			method: "HEAD",
+			headers: { Accept: ACCEPT }
+		}), { contextData: void 0 });
+		assertEquals(response.status, 500);
+		assertEquals(await response.text(), "");
+	});
+});
+test("Context builds portable collection IDs", async (t) => {
+	const ctx = createTestFederation().createContext(new URL(ORIGIN), void 0);
+	const helpers = {
+		getPortableOutboxUri: [(authority) => ctx.getPortableOutboxUri("alice", authority), "/users/alice/outbox"],
+		getPortableFollowersUri: [(authority) => ctx.getPortableFollowersUri("alice", authority), "/users/alice/followers"],
+		getPortableFeaturedUri: [(authority) => ctx.getPortableFeaturedUri("alice", authority), "/users/alice/featured"],
+		getPortableCollectionUri: [(authority) => ctx.getPortableCollectionUri("bookmarks", { identifier: "alice" }, authority), "/users/alice/bookmarks"]
+	};
+	for (const [name, [helper, path]] of Object.entries(helpers)) await t.step(name, () => {
+		assertEquals(formatIri(helper(did)), portableId(path));
+		assertThrows(() => helper(void 0), TypeError);
+		assertThrows(() => helper("https://example.com"), TypeError);
+	});
+	await t.step("unregistered collections", () => {
+		assertThrows(() => ctx.getPortableLikedUri("alice", did), RouterError);
+		assertThrows(() => ctx.getPortableFollowingUri("alice", did), RouterError);
+		assertThrows(() => ctx.getPortableFeaturedTagsUri("alice", did), RouterError);
+		assertThrows(() => ctx.getPortableCollectionUri("unknown", {}, did), RouterError);
+	});
+	await t.step("default authority of RequestContext", async () => {
+		const federation = createFederation({
+			kv: new MemoryKvStore(),
+			documentLoaderFactory: () => mockDocumentLoader,
+			contextLoaderFactory: () => mockDocumentLoader
+		});
+		const built = [];
+		federation.setActorDispatcher("/users/{identifier}", (ctx, identifier) => new Person({
+			id: ctx.getPortableActorUri(identifier, did),
+			outbox: ctx.getPortableOutboxUri(identifier, did)
+		}));
+		federation.setOutboxDispatcher("/users/{identifier}/outbox", (ctx, identifier) => {
+			built.push(formatIri(ctx.getPortableOutboxUri(identifier)));
+			return { items: [] };
+		});
+		const [response] = await fetchJson(federation, gatewayUrl("/users/alice/outbox"));
+		assertEquals(response.status, 200);
+		assertEquals(built, [portableId("/users/alice/outbox")]);
+		const requestContext = federation.createContext(new Request(`${ORIGIN}/`), void 0);
+		assertThrows(() => requestContext.getPortableOutboxUri("alice"), TypeError);
+	});
+});
+/**
+* Captures Fedify's warnings logged while `run` executes.
+*/
+async function captureWarnings(run) {
+	const records = [];
+	await reset();
+	try {
+		await configure({
+			sinks: { buffer: (record) => records.push(record) },
+			filters: {},
+			loggers: [{
+				category: ["logtape", "meta"],
+				sinks: []
+			}, {
+				category: [],
+				sinks: ["buffer"],
+				lowestLevel: "warning"
+			}]
+		});
+		await run();
+	} finally {
+		await reset();
+	}
+	return records.filter((record) => record.category[0] === "fedify");
+}
+test("Actor dispatchers warn about mismatching portable collections", async () => {
+	const federation = createTestFederation();
+	const mismatches = (await captureWarnings(async () => {
+		for (const identifier of [
+			"alice",
+			"mismatch",
+			"https"
+		]) await fetchJson(federation, `${ORIGIN}/users/${identifier}`);
+	})).filter((record) => String(record.rawMessage).includes("does not match the portable ID"));
+	assertEquals(mismatches.map((record) => record.properties.property), ["outbox"]);
+	assertEquals(mismatches[0].properties.value, ctxOutbox("alice"));
+});
+function ctxOutbox(identifier) {
+	return new URL(`ap+ef61://${encodeURIComponent(did)}/users/${identifier}/outbox`).href;
+}
+test("Fedify traverses portable collections that Fedify serves", async () => {
+	const federation = createTestFederation();
+	const loader = (origin) => async (url) => {
+		if (!/^https?:/.test(url)) throw new Error(`Not found: ${url}`);
+		const target = new URL(url);
+		const request = new URL(target.pathname + target.search, ORIGIN);
+		const response = await federation.fetch(new Request(request, { headers: { Accept: ACCEPT } }), { contextData: void 0 });
+		if (!response.ok) throw new FetchError(url, `HTTP ${response.status}`, response);
+		return {
+			contextUrl: null,
+			documentUrl: new URL(target.pathname + target.search, origin).href,
+			document: await response.json()
+		};
+	};
+	const options = {
+		documentLoader: loader(ORIGIN),
+		contextLoader: mockDocumentLoader,
+		gateways: [ORIGIN],
+		verifyPortableObject
+	};
+	const actorUri = (gateway) => `${portableId("/users/alice")}?@gateway=${encodeURIComponent(gateway)}`;
+	const actor = await lookupObject(actorUri(ORIGIN), options);
+	assert(actor instanceof Person);
+	const outbox = await actor.getOutbox(options);
+	assert(outbox instanceof OrderedCollection);
+	assertEquals((await Array.fromAsync(traverseCollection(outbox, options))).map((item) => item instanceof Create ? formatIri(item.id) : null), PAGES.flatMap((cursor) => [0, 1].map((i) => portableId(`/creates/${getNoteValues("alice", cursor, i).id}`))));
+	assertEquals(await actor.getFeatured(options), null);
+	const evil = "https://evil.example";
+	const evilOptions = {
+		...options,
+		documentLoader: loader(evil),
+		gateways: [evil]
+	};
+	const actor2 = await lookupObject(actorUri(evil), evilOptions);
+	assert(actor2 instanceof Person);
+	assertEquals(await actor2.getOutbox(evilOptions), null);
+});
+test("Fedify traverses portable collections through their owners' gateways", async () => {
+	const federation = createTestFederation();
+	const requests = [];
+	const documentLoader = async (url) => {
+		requests.push(url);
+		if (!/^https?:/.test(url)) throw new Error(`Not found: ${url}`);
+		const target = new URL(url);
+		const response = await federation.fetch(new Request(new URL(target.pathname + target.search, ORIGIN), { headers: { Accept: ACCEPT } }), { contextData: void 0 });
+		if (!response.ok) throw new FetchError(url, `HTTP ${response.status}`, response);
+		return {
+			contextUrl: null,
+			documentUrl: url,
+			document: await response.json()
+		};
+	};
+	const options = {
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		verifyPortableObject
+	};
+	const actor = await lookupObject(portableId("/users/alice"), {
+		...options,
+		gateways: [ORIGIN]
+	});
+	assert(actor instanceof Person);
+	const outbox = await actor.getOutbox(options);
+	assert(outbox instanceof OrderedCollection);
+	assertEquals((await Array.fromAsync(traverseCollection(outbox, options))).length, PAGES.length * NOTES_PER_PAGE);
+	assert(requests.every((url) => url.startsWith(`${ORIGIN}/`)));
+});
+test("Fedify accepts empty portable collections that Fedify serves", async () => {
+	const federation = createTestFederation();
+	const [response, json] = await fetchJson(federation, gatewayUrl("/users/alice/inbox"));
+	assertEquals(response.status, 200);
+	assertEquals(json?.totalItems, 0);
+	assertEquals(await verifyPortableObjectProof(json, { contextLoader: mockDocumentLoader }), {
+		verified: false,
+		reason: { type: "unsecuredCollection" }
+	});
+	const documentLoader = async (url) => {
+		const target = new URL(url);
+		const response = await federation.fetch(new Request(new URL(target.pathname + target.search, ORIGIN), { headers: { Accept: ACCEPT } }), { contextData: void 0 });
+		if (!response.ok) throw new FetchError(url, `HTTP ${response.status}`, response);
+		return {
+			contextUrl: null,
+			documentUrl: url,
+			document: await response.json()
+		};
+	};
+	const options = {
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		gateways: [ORIGIN],
+		verifyPortableObject
+	};
+	const actor = await lookupObject(portableId("/users/alice"), options);
+	assert(actor instanceof Person);
+	const inbox = await actor.getInbox(options);
+	assert(inbox instanceof OrderedCollection);
+	assertEquals(inbox.totalItems, 0);
+	assertEquals(await Array.fromAsync(traverseCollection(inbox, options)), []);
+});
+test("verifyServedPortableObjects() classifies unsigned maps under their effective contexts", async () => {
+	const AS = "https://www.w3.org/ns/activitystreams";
+	const collection = (member) => ({
+		"@context": AS,
+		id: portableId("/collection"),
+		type: "OrderedCollection",
+		orderedItems: [member]
+	});
+	assertEquals(await verifyServedPortableObjects(collection({
+		id: portableId("/replies"),
+		totalItems: 0
+	})), { verified: true });
+	assertEquals(await verifyServedPortableObjects(collection({ id: portableId("/notes/1") })), { verified: true });
+	assertEquals(await verifyServedPortableObjects(collection({
+		id: portableId("/notes/1"),
+		content: "Hi"
+	})), {
+		verified: false,
+		path: "/orderedItems/0",
+		id: portableId("/notes/1"),
+		reason: "missingProof"
+	});
+	assertEquals(await verifyServedPortableObjects(collection({
+		"@context": { totalItems: `${AS}#content` },
+		type: "Note",
+		tag: {
+			id: portableId("/notes/2"),
+			totalItems: "Hi"
+		}
+	})), {
+		verified: false,
+		path: "/orderedItems/0/tag",
+		id: portableId("/notes/2"),
+		reason: "missingProof"
+	});
+	assertEquals(await verifyServedPortableObjects(collection({
+		"@context": { tag: {
+			"@id": `${AS}#tag`,
+			"@context": {}
+		} },
+		type: "Note",
+		tag: {
+			id: portableId("/replies"),
+			totalItems: 0
+		}
+	})), {
+		verified: false,
+		path: "/orderedItems/0",
+		id: "",
+		reason: "unsupportedContext"
+	});
+});
+test("verifyServedPortableObjects() verifies embedded maps as they are served", async () => {
+	const AS = "https://www.w3.org/ns/activitystreams";
+	const signed = await (await sign(new Note({
+		id: parseIri(portableId("/notes/signed")),
+		content: "Hi"
+	}))).toJsonLd({
+		format: "compact",
+		contextLoader: mockDocumentLoader
+	});
+	const collection = (member) => ({
+		"@context": AS,
+		id: portableId("/collection"),
+		type: "OrderedCollection",
+		orderedItems: [member]
+	});
+	assertEquals(await verifyServedPortableObjects(collection(signed), { contextLoader: mockDocumentLoader }), { verified: true });
+	const context = signed["@context"];
+	assertEquals((await verifyServedPortableObjects(collection({
+		...signed,
+		"@context": [...Array.isArray(context) ? context : [context], { content: `${AS}#summary` }]
+	}), { contextLoader: mockDocumentLoader })).verified, false);
+	assertEquals(await verifyServedPortableObjects(collection({
+		"@context": { uri: "@id" },
+		uri: portableId("/notes/aliased"),
+		type: "Note",
+		content: "Unsigned"
+	})), {
+		verified: false,
+		path: "",
+		id: portableId("/notes/aliased"),
+		reason: "hiddenPortableObject"
+	});
+});
+test("verifyServedPortableObjects() finds portable objects hidden by contexts", async () => {
+	const AS = "https://www.w3.org/ns/activitystreams";
+	const collection = (member) => ({
+		"@context": AS,
+		id: portableId("/collection"),
+		type: "OrderedCollection",
+		orderedItems: [member]
+	});
+	assertEquals(await verifyServedPortableObjects(collection({
+		"@context": { uri: "id" },
+		uri: portableId("/notes/aliased"),
+		type: "Note",
+		content: "Unsigned"
+	})), {
+		verified: false,
+		path: "",
+		id: portableId("/notes/aliased"),
+		reason: "hiddenPortableObject"
+	});
+	for (const decoy of [{
+		id: portableId("/notes/decoy"),
+		totalItems: 0
+	}, null]) {
+		const id = decoy == null ? portableId("/collection") : decoy.id;
+		const document = collection({
+			"@context": { uri: "id" },
+			uri: id,
+			type: "Note",
+			content: "Unsigned"
+		});
+		if (decoy != null) document.orderedItems.push(decoy);
+		assertEquals(await verifyServedPortableObjects(document), {
+			verified: false,
+			path: "",
+			id,
+			reason: "hiddenPortableObject"
+		});
+	}
+	assertEquals(await verifyServedPortableObjects(collection({
+		"@context": { proof: `${AS}#tag` },
+		id: "https://example.com/notes/ordinary",
+		type: "Note",
+		proof: {
+			id: portableId("/notes/hidden"),
+			type: "Note",
+			content: "Unsigned"
+		}
+	})), {
+		verified: false,
+		path: "",
+		id: portableId("/notes/hidden"),
+		reason: "hiddenPortableObject"
+	});
+});
+test("verifyServedPortableObjects() leaves non-portable remote objects alone", async () => {
+	const AS = "https://www.w3.org/ns/activitystreams";
+	const collection = (member) => ({
+		"@context": AS,
+		id: portableId("/collection"),
+		type: "OrderedCollection",
+		orderedItems: [member]
+	});
+	assertEquals(await verifyServedPortableObjects(collection({
+		"@context": [AS, {
+			toot: "http://joinmastodon.org/ns#",
+			focalPoint: {
+				"@container": "@list",
+				"@id": "toot:focalPoint"
+			}
+		}],
+		id: "https://mastodon.example/users/bob/statuses/1",
+		type: "Note",
+		content: `<p>AP: see ${gatewayUrl("/users/alice")}, ap://${did}/users/alice, and did:plc:abcdefghijklmnop</p>`,
+		url: gatewayUrl("/users/alice")
+	})), { verified: true });
+	assertEquals(await verifyServedPortableObjects(collection({
+		"@context": [AS, "https://evil.example/context.jsonld"],
+		id: "https://evil.example/activities/1",
+		type: "Create",
+		object: {
+			id: "x:notes/1",
+			type: "Note",
+			content: "Forged"
+		}
+	})), {
+		verified: false,
+		path: "/orderedItems/0",
+		id: "https://evil.example/activities/1",
+		reason: "unsupportedContext"
+	});
+	assertEquals(await verifyServedPortableObjects(collection({
+		"@context": [AS, { x: {
+			"@id": `ap+ef61://${did}/`,
+			"@prefix": true
+		} }],
+		id: "https://example.com/objects/2",
+		type: "Note",
+		tag: {
+			id: "x:notes/1",
+			type: "Note"
+		}
+	})), {
+		verified: false,
+		path: "",
+		id: portableId("/notes/1"),
+		reason: "hiddenPortableObject"
+	});
+	assertEquals(await verifyServedPortableObjects(collection({
+		"@context": [AS, {
+			toot: "http://joinmastodon.org/ns#",
+			id: "toot:notId",
+			focalPoint: {
+				"@container": "@list",
+				"@id": "toot:focalPoint"
+			}
+		}],
+		id: "https://example.com/objects/3",
+		type: "Note",
+		tag: {
+			id: portableId("/notes/3"),
+			type: "Note"
+		}
+	})), {
+		verified: false,
+		path: "/orderedItems/0",
+		id: "https://example.com/objects/3",
+		reason: "unsupportedContext"
+	});
+});
+test("Federation.fetch() authorizes portable custom collection requests", async () => {
+	const federation = createFederation({
+		kv: new MemoryKvStore(),
+		documentLoaderFactory: () => mockDocumentLoader,
+		contextLoaderFactory: () => mockDocumentLoader
+	});
+	const calls = [];
+	federation.setActorDispatcher("/users/{identifier}", (ctx, identifier) => new Person({ id: ctx.getPortableActorUri(identifier, did) }));
+	federation.setCollectionDispatcher("bookmarks", Note, "/users/{identifier}/bookmarks", (_ctx, values) => {
+		calls.push(`dispatch ${values.identifier}`);
+		return { items: [] };
+	}).mapPortableOwner((_ctx, values) => values.identifier).authorize((ctx, values) => {
+		calls.push(`authorize ${values.identifier} ${ctx.portableRequest?.authority}`);
+		return ctx.request.headers.get("X-Allowed") === "yes";
+	});
+	const [denied] = await fetchJson(federation, gatewayUrl("/users/alice/bookmarks"));
+	assertEquals(denied.status, 401);
+	assertEquals(calls, [`authorize alice ${did}`]);
+	calls.length = 0;
+	const [allowed, json] = await fetchJson(federation, gatewayUrl("/users/alice/bookmarks"), { headers: { "X-Allowed": "yes" } });
+	assertEquals(allowed.status, 200);
+	assertEquals(json?.id, portableId("/users/alice/bookmarks"));
+	assertEquals(calls, [`authorize alice ${did}`, "dispatch alice"]);
+});
+//#endregion
+export {};