@fedify/vocab 2.4.0-dev.2056 → 2.4.0-dev.2065

package/dist-tests/gateway.test.mjs

@@ -1,11 +1,12 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { O as Note, l as Create } from "./vocab-BJGPw--L.mjs";
-import { t as esm_default } from "./esm-Df0Yo-Tp.mjs";
+import { F as Person, M as OrderedCollection, c as CollectionPage, k as Note, s as Collection, u as Create } from "./vocab-BHtBRusa.mjs";
+import { t as esm_default } from "./esm-C9nxP5_e.mjs";
+import { n as traverseCollection } from "./lookup-BnzAXNN7.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
-import { FetchError, getDocumentLoader } from "@fedify/vocab-runtime";
+import { FetchError, getDocumentLoader, parseIri } from "@fedify/vocab-runtime";
 //#region src/gateway.test.ts
 const did = "did:key:z6Mkabc";
 const objectId = `ap+ef61://${did}/objects/1`;
@@ -506,11 +507,16 @@ test("getObject() shares context documents within a dereference", async (t) => {
 		const loaded = [];
 		const contextLoader = async (url) => {
 			loaded.push(url);
+			if (url === contextUrl) return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": {} }
+			};
 			return await mockDocumentLoader(url);
 		};
 		const object = await (await createActivity()).getObject({
 			documentLoader: createLoader({ [`https://gw1.example${gatewayPath}`]: {
-				...note(),
+				...document,
 				attributedTo: "https://example.com/person"
 			} }),
 			contextLoader,
@@ -518,13 +524,13 @@ test("getObject() shares context documents within a dereference", async (t) => {
 			verifyPortableObject: createVerifier()
 		});
 		assertInstanceOf(object, Note);
-		deepStrictEqual(loaded, []);
+		deepStrictEqual(loaded, [contextUrl]);
 		deepStrictEqual((await object.getAttribution({ documentLoader: createLoader({ "https://example.com/person": {
-			"@context": "https://www.w3.org/ns/activitystreams",
+			"@context": ["https://www.w3.org/ns/activitystreams", contextUrl],
 			id: "https://example.com/person",
 			type: "Person"
 		} }) }))?.id, new URL("https://example.com/person"));
-		ok(loaded.includes("https://www.w3.org/ns/activitystreams"));
+		deepStrictEqual(loaded, [contextUrl, contextUrl]);
 	});
 	await t.step("failed context loads are retried", async () => {
 		let failures = 1;
@@ -600,5 +606,687 @@ test("getObject() sends the ActivityStreams Accept header to gateways", {
 		esm_default.hardReset();
 	}
 });
+const AS = "https://www.w3.org/ns/activitystreams#";
+function gatewayUrl(gateway, path) {
+	return `${gateway}/.well-known/apgateway/${did}${path}`;
+}
+function createRecordingVerifier(decide = () => ({ verified: true })) {
+	const calls = [];
+	const verifier = async (document, options) => {
+		calls.push({
+			document,
+			options
+		});
+		return decide(document, options);
+	};
+	return Object.assign(verifier, { calls });
+}
+function portableCollection(path, extra = {}) {
+	return {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: `ap://${did}${path}`,
+		type: "OrderedCollection",
+		totalItems: 0,
+		...extra
+	};
+}
+test("getOutbox() passes the fetch source and referrer to the verifier", async () => {
+	const person = await Person.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: `ap://${did}/actor`,
+		type: "Person",
+		inbox: `ap://${did}/actor/inbox`,
+		outbox: `ap://${did}/actor/outbox?@gateway=${encodeURIComponent("https://hint.example")}`
+	}, { contextLoader: mockDocumentLoader });
+	const documentLoader = createLoader({ [gatewayUrl("https://hint.example", "/actor/outbox")]: portableCollection("/actor/outbox") });
+	const verifier = createRecordingVerifier();
+	assertInstanceOf(await person.getOutbox({
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		verifyPortableObject: verifier
+	}), Collection);
+	deepStrictEqual(verifier.calls.length, 1);
+	const { options } = verifier.calls[0];
+	deepStrictEqual(options.documentUrl, new URL(gatewayUrl("https://hint.example", "/actor/outbox")));
+	deepStrictEqual(options.gateways, void 0);
+	deepStrictEqual(options.gatewayHints, [new URL("https://hint.example")]);
+	ok(options.referrer?.object === person);
+	deepStrictEqual(options.referrer?.property, `${AS}outbox`);
+	deepStrictEqual(options.referrer?.acceptance, void 0);
+	const person2 = await Person.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: `ap://${did}/actor`,
+		type: "Person",
+		inbox: `ap://${did}/actor/inbox`,
+		outbox: `ap://${did}/actor/outbox`
+	}, { contextLoader: mockDocumentLoader });
+	const verifier2 = createRecordingVerifier();
+	await person2.getOutbox({
+		documentLoader: createLoader({ [gatewayUrl("https://gw.example", "/actor/outbox")]: portableCollection("/actor/outbox") }),
+		contextLoader: mockDocumentLoader,
+		gateways: ["https://gw.example"],
+		verifyPortableObject: verifier2
+	});
+	deepStrictEqual(verifier2.calls[0].options.gateways, [new URL("https://gw.example")]);
+	deepStrictEqual(verifier2.calls[0].options.gatewayHints, void 0);
+});
+test("getFirst() passes the referrer chain and collection context", async () => {
+	const context = Object.freeze({});
+	const documentLoader = createLoader({
+		[gatewayUrl("https://gw.example", "/actor")]: {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: `ap://${did}/actor`,
+			type: "Person",
+			inbox: `ap://${did}/actor/inbox`,
+			outbox: `ap://${did}/actor/outbox`
+		},
+		[gatewayUrl("https://gw.example", "/actor/outbox")]: portableCollection("/actor/outbox", { first: {
+			id: `ap://${did}/actor/outbox?page=1`,
+			type: "OrderedCollectionPage",
+			next: `ap://${did}/actor/outbox?page=2`
+		} }),
+		[gatewayUrl("https://gw.example", "/actor/outbox?page=2")]: {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: `ap://${did}/actor/outbox?page=2`,
+			type: "OrderedCollectionPage",
+			orderedItems: []
+		}
+	});
+	const verifier = createRecordingVerifier((document) => document.type === "OrderedCollection" ? {
+		verified: true,
+		collectionContext: context
+	} : { verified: true });
+	const options = {
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		gateways: ["https://gw.example"],
+		verifyPortableObject: verifier
+	};
+	const create = await createActivity(`ap://${did}/actor`);
+	const actor = await create.getObject(options);
+	assertInstanceOf(actor, Person);
+	const outbox = await actor.getOutbox(options);
+	assertInstanceOf(outbox, Collection);
+	const first = await outbox.getFirst(options);
+	assertInstanceOf(first, CollectionPage);
+	assertInstanceOf(await first.getNext(options), CollectionPage);
+	const { referrer } = verifier.calls[verifier.calls.length - 1].options;
+	ok(referrer?.object === first);
+	deepStrictEqual(referrer?.property, `${AS}next`);
+	deepStrictEqual(referrer?.acceptance, void 0);
+	ok(referrer?.referrer?.object === outbox);
+	deepStrictEqual(referrer?.referrer?.property, `${AS}first`);
+	deepStrictEqual(referrer?.referrer?.acceptance, "verified");
+	ok(referrer?.referrer?.collectionContext === context);
+	ok(referrer?.referrer?.referrer?.object === actor);
+	deepStrictEqual(referrer?.referrer?.referrer?.property, `${AS}outbox`);
+	deepStrictEqual(referrer?.referrer?.referrer?.acceptance, "verified");
+	ok(referrer?.referrer?.referrer?.referrer?.object === create);
+});
+test("accessors do not trust objects embedded in unsecured collections", async () => {
+	const itemPath = "/objects/1";
+	const options = {
+		documentLoader: createLoader({
+			[gatewayUrl("https://gw.example", "/actor/outbox")]: portableCollection("/actor/outbox", { orderedItems: [{
+				id: `ap://${did}${itemPath}`,
+				type: "Note",
+				content: "Forged"
+			}, {
+				type: "Note",
+				content: "Anonymous"
+			}] }),
+			[gatewayUrl("https://gw.example", itemPath)]: note()
+		}),
+		contextLoader: mockDocumentLoader,
+		gateways: ["https://gw.example"],
+		verifyPortableObject: createRecordingVerifier((document) => document.type === "OrderedCollection" ? {
+			verified: true,
+			unsecured: true
+		} : { verified: true })
+	};
+	const createPerson = () => Person.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: `ap://${did}/actor`,
+		type: "Person",
+		inbox: `ap://${did}/actor/inbox`,
+		outbox: `ap://${did}/actor/outbox`
+	}, { contextLoader: mockDocumentLoader });
+	const outbox = await (await createPerson()).getOutbox(options);
+	assertInstanceOf(outbox, Collection);
+	deepStrictEqual((await Array.fromAsync(outbox.getItems(options))).map((item) => item instanceof Note ? item.content : null), ["Portable note"]);
+	const outbox2 = await (await createPerson()).getOutbox(options);
+	assertInstanceOf(outbox2, Collection);
+	deepStrictEqual((await Array.fromAsync(outbox2.getItems({
+		...options,
+		crossOrigin: "trust"
+	}))).length, 1);
+	const outbox3 = await (await createPerson()).getOutbox(options);
+	assertInstanceOf(outbox3, Collection);
+	deepStrictEqual(await Array.fromAsync(outbox3.clone().getItems({
+		...options,
+		documentLoader: createLoader({}),
+		suppressError: true
+	})), []);
+});
+function createRedirectingLoader(responses) {
+	const fetched = [];
+	const loader = async (url) => {
+		fetched.push(url);
+		const response = responses[url];
+		if (response == null) throw new FetchError(url, "HTTP 404", new globalThis.Response(null, { status: 404 }));
+		return {
+			contextUrl: null,
+			...response
+		};
+	};
+	return Object.assign(loader, { fetched });
+}
+function createHttpActivity(object) {
+	return Create.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Create",
+		id: "https://example.com/activities/1",
+		object
+	}, { contextLoader: mockDocumentLoader });
+}
+const compatibleNoteId = gatewayUrl("https://gw.example", "/objects/1");
+test("accessors dereference compatible identifiers through their gateways", async (t) => {
+	await t.step("through the named gateway", async () => {
+		const documentLoader = createLoader({ [compatibleNoteId]: note() });
+		const verifier = createRecordingVerifier();
+		const activity = await createHttpActivity(compatibleNoteId);
+		const object = await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(object.id, parseIri(objectId));
+		deepStrictEqual(documentLoader.fetched, [compatibleNoteId]);
+		deepStrictEqual(verifier.calls.length, 1);
+		const { options } = verifier.calls[0];
+		deepStrictEqual(options.documentUrl, new URL(compatibleNoteId));
+		deepStrictEqual(options.gateways, void 0);
+		deepStrictEqual(options.gatewayHints, [new URL("https://gw.example")]);
+		ok(options.referrer?.object === activity);
+		ok(await activity.getObject({ documentLoader: createLoader({}) }) === object);
+	});
+	await t.step("then through explicit gateways", async () => {
+		const documentLoader = createLoader({ [gatewayUrl("https://gw2.example", "/objects/1")]: note() });
+		const verifier = createRecordingVerifier();
+		assertInstanceOf(await (await createHttpActivity(compatibleNoteId)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			gateways: ["https://gw2.example", "https://gw.example"],
+			verifyPortableObject: verifier
+		}), Note);
+		deepStrictEqual(documentLoader.fetched, [compatibleNoteId, gatewayUrl("https://gw2.example", "/objects/1")]);
+		deepStrictEqual(verifier.calls[0].options.gateways, [new URL("https://gw2.example"), new URL("https://gw.example")]);
+		deepStrictEqual(verifier.calls[0].options.gatewayHints, void 0);
+		const documentLoader2 = createLoader({ [compatibleNoteId]: note() });
+		assertInstanceOf(await (await createHttpActivity(compatibleNoteId)).getObject({
+			documentLoader: documentLoader2,
+			contextLoader: mockDocumentLoader,
+			gateways: [],
+			verifyPortableObject: createVerifier()
+		}), Note);
+		deepStrictEqual(documentLoader2.fetched, [compatibleNoteId]);
+	});
+	await t.step("in plural accessors", async () => {
+		const documentLoader = createLoader({ [compatibleNoteId]: note() });
+		deepStrictEqual((await Array.fromAsync((await createHttpActivity([compatibleNoteId])).getObjects({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier()
+		}))).map((o) => o.id), [parseIri(objectId)]);
+		deepStrictEqual(documentLoader.fetched, [compatibleNoteId]);
+	});
+});
+test("accessors reject forged objects at compatible identifiers", async () => {
+	const forgedId = gatewayUrl("https://evil.example", "/objects/1");
+	const forged = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: forgedId,
+		type: "Note",
+		attributedTo: gatewayUrl("https://evil.example", "/actor"),
+		content: "Forged"
+	};
+	for (const crossOrigin of [
+		void 0,
+		"ignore",
+		"trust"
+	]) {
+		const verifier = createRecordingVerifier();
+		deepStrictEqual(await (await createHttpActivity(forgedId)).getObject({
+			documentLoader: createLoader({ [forgedId]: forged }),
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier,
+			crossOrigin
+		}), null);
+		deepStrictEqual(verifier.calls, []);
+		deepStrictEqual(await (await createHttpActivity(forgedId)).getObject({
+			documentLoader: createLoader({ [forgedId]: note() }),
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier(false),
+			crossOrigin
+		}), null);
+	}
+	await rejects(async () => await (await createHttpActivity(forgedId)).getObject({
+		documentLoader: createLoader({ [forgedId]: note() }),
+		contextLoader: mockDocumentLoader,
+		verifyPortableObject: createVerifier(false),
+		crossOrigin: "throw"
+	}), /No gateway returned a valid portable object/);
+});
+test("accessors reject malformed compatible identifiers", async () => {
+	const malformed = [`${compatibleNoteId}?@gateway=https%3A%2F%2Fgw2.example`, compatibleNoteId.replace("https://", "https://user:pass@")];
+	for (const url of malformed) {
+		const documentLoader = createLoader({ [url]: note() });
+		const verifier = createRecordingVerifier();
+		const activity = await createHttpActivity(url);
+		deepStrictEqual(await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		}), null);
+		deepStrictEqual(await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier,
+			crossOrigin: "throw",
+			suppressError: true
+		}), null);
+		await rejects(async () => await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier,
+			crossOrigin: "throw"
+		}), /malformed FEP-ef61 compatible identifier/);
+		deepStrictEqual(documentLoader.fetched, []);
+		deepStrictEqual(verifier.calls, []);
+	}
+});
+test("accessors keep fetching compatible identifiers as HTTP(S) URLs without verifyPortableObject", async (t) => {
+	const document = {
+		...note(),
+		id: compatibleNoteId
+	};
+	await t.step("singular accessors", async () => {
+		const documentLoader = createLoader({ [compatibleNoteId]: document });
+		const activity = await createHttpActivity(compatibleNoteId);
+		const object = await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(object.id, new URL(compatibleNoteId));
+		deepStrictEqual(await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier()
+		}), null);
+		deepStrictEqual(documentLoader.fetched, [compatibleNoteId, compatibleNoteId]);
+	});
+	await t.step("plural accessors", async () => {
+		const documentLoader = createLoader({ [compatibleNoteId]: document });
+		const activity = await createHttpActivity([compatibleNoteId]);
+		deepStrictEqual((await Array.fromAsync(activity.getObjects({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		}))).map((o) => o.id), [new URL(compatibleNoteId)]);
+		deepStrictEqual(await Array.fromAsync(activity.getObjects({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier()
+		})), []);
+	});
+	await t.step("redirects to ordinary objects", async () => {
+		const plainUrl = "https://gw.example/notes/1";
+		const documentLoader = createRedirectingLoader({ [compatibleNoteId]: {
+			documentUrl: plainUrl,
+			document: {
+				...note(),
+				id: plainUrl
+			}
+		} });
+		for (const activity of [await createHttpActivity(compatibleNoteId)]) {
+			deepStrictEqual((await activity.getObject({
+				documentLoader,
+				contextLoader: mockDocumentLoader
+			}))?.id, new URL(plainUrl));
+			deepStrictEqual(await activity.getObject({
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				verifyPortableObject: createVerifier()
+			}), null);
+		}
+		const activity = await createHttpActivity([compatibleNoteId]);
+		deepStrictEqual((await Array.fromAsync(activity.getObjects({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		}))).length, 1);
+		deepStrictEqual(await Array.fromAsync(activity.getObjects({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier()
+		})), []);
+	});
+	await t.step("embedded objects", async () => {
+		deepStrictEqual((await (await createHttpActivity({
+			type: "Note",
+			id: gatewayUrl("https://example.com", "/objects/1"),
+			content: "Embedded"
+		})).getObject({
+			documentLoader: createLoader({}),
+			contextLoader: mockDocumentLoader
+		}))?.id, new URL(gatewayUrl("https://example.com", "/objects/1")));
+	});
+});
+test("accessors dereference compatible identifiers from portable objects", async () => {
+	const compatibleOutbox = gatewayUrl("https://gw.example", "/actor/outbox");
+	const person = (outbox) => Person.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: `ap://${did}/actor`,
+		type: "Person",
+		inbox: `ap://${did}/actor/inbox`,
+		outbox
+	}, { contextLoader: mockDocumentLoader });
+	const documentLoader = createRedirectingLoader({
+		[compatibleOutbox]: {
+			documentUrl: compatibleOutbox,
+			document: portableCollection("/actor/outbox")
+		},
+		"https://example.com/outbox": {
+			documentUrl: compatibleOutbox,
+			document: portableCollection("/actor/outbox")
+		}
+	});
+	for (const crossOrigin of [void 0, "trust"]) for (const outbox of [
+		compatibleOutbox,
+		"https://example.com/outbox",
+		{
+			...portableCollection("/actor/outbox"),
+			id: compatibleOutbox
+		}
+	]) {
+		const verifier = createRecordingVerifier();
+		const collection = await (await person(outbox)).getOutbox({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier,
+			crossOrigin
+		});
+		assertInstanceOf(collection, OrderedCollection);
+		deepStrictEqual(collection.id, parseIri(`ap://${did}/actor/outbox`));
+		deepStrictEqual(verifier.calls.length, 1);
+		deepStrictEqual(verifier.calls[0].options.documentUrl, new URL(compatibleOutbox));
+		deepStrictEqual(verifier.calls[0].options.gatewayHints, [new URL("https://gw.example")]);
+	}
+	await rejects(async () => await (await person(compatibleOutbox)).getOutbox({
+		documentLoader,
+		contextLoader: mockDocumentLoader
+	}), TypeError);
+	deepStrictEqual(await (await person(compatibleOutbox)).getOutbox({
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		suppressError: true
+	}), null);
+});
+test("accessors verify fetched documents that stand for portable objects", async (t) => {
+	const plainUrl = "https://example.com/notes/1";
+	await t.step("a redirect to a compatible identifier", async () => {
+		const documentLoader = createRedirectingLoader({ [plainUrl]: {
+			documentUrl: compatibleNoteId,
+			document: note()
+		} });
+		const verifier = createRecordingVerifier();
+		const object = await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(object.id, parseIri(objectId));
+		deepStrictEqual(documentLoader.fetched, [plainUrl]);
+		deepStrictEqual(verifier.calls.length, 1);
+		deepStrictEqual(verifier.calls[0].options.documentUrl, new URL(compatibleNoteId));
+		deepStrictEqual(verifier.calls[0].options.gatewayHints, [new URL("https://gw.example")]);
+		deepStrictEqual(await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier(false)
+		}), null);
+		await rejects(async () => await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier(false),
+			crossOrigin: "throw"
+		}), /No gateway returned a valid portable object/);
+	});
+	await t.step("a document that claims another object", async () => {
+		for (const id of [
+			`ap://${did}/objects/2`,
+			compatibleNoteId,
+			"https://gw.example/notes/1"
+		]) {
+			const verifier = createRecordingVerifier();
+			deepStrictEqual(await (await createHttpActivity(plainUrl)).getObject({
+				documentLoader: createRedirectingLoader({ [plainUrl]: {
+					documentUrl: compatibleNoteId,
+					document: note(id)
+				} }),
+				contextLoader: mockDocumentLoader,
+				verifyPortableObject: verifier
+			}), null);
+			deepStrictEqual(verifier.calls, []);
+		}
+	});
+	await t.step("a portable @id", async () => {
+		const verifier = createRecordingVerifier();
+		assertInstanceOf(await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader: createLoader({ [plainUrl]: note() }),
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier,
+			crossOrigin: "trust"
+		}), Note);
+		deepStrictEqual(verifier.calls.length, 1);
+		deepStrictEqual(verifier.calls[0].options.documentUrl, new URL(plainUrl));
+		deepStrictEqual(await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader: createLoader({ [plainUrl]: note() }),
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier(false),
+			crossOrigin: "trust"
+		}), null);
+	});
+	await t.step("a compatible @id", async () => {
+		const verifier = createRecordingVerifier();
+		const url = "https://gw.example/notes/1";
+		deepStrictEqual(await (await createHttpActivity(url)).getObject({
+			documentLoader: createLoader({ [url]: note(compatibleNoteId) }),
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		}), null);
+		deepStrictEqual(verifier.calls, []);
+	});
+	await t.step("a portable final URL", async () => {
+		for (const [id, expected] of [[objectId, true], [`ap://${did}/objects/2`, false]]) deepStrictEqual(await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader: createRedirectingLoader({ [plainUrl]: {
+				documentUrl: `ap://${did}/objects/1`,
+				document: note(id)
+			} }),
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier()
+		}) instanceof Note, expected);
+		deepStrictEqual(await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader: createRedirectingLoader({ [plainUrl]: {
+				documentUrl: `ap://${did}/objects/x/../1`,
+				document: note()
+			} }),
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier()
+		}), null);
+	});
+	await t.step("a malformed compatible final URL", async () => {
+		const malformed = `${compatibleNoteId}?@gateway=https%3A%2F%2Fgw2.example`;
+		const documentLoader = createRedirectingLoader({ [plainUrl]: {
+			documentUrl: malformed,
+			document: note()
+		} });
+		deepStrictEqual(await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier()
+		}), null);
+		await rejects(async () => await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier(),
+			crossOrigin: "throw"
+		}), /malformed FEP-ef61 compatible identifier/);
+	});
+	await t.step("context documents are shared", async () => {
+		const contextUrl = "https://example.com/portable-context";
+		let version = 0;
+		const contextLoader = async (url) => {
+			if (url === contextUrl) {
+				version++;
+				return {
+					contextUrl: null,
+					documentUrl: url,
+					document: { "@context": { version: `urn:version:${version}` } }
+				};
+			}
+			return await mockDocumentLoader(url);
+		};
+		const contexts = [];
+		assertInstanceOf(await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader: createRedirectingLoader({ [plainUrl]: {
+				documentUrl: compatibleNoteId,
+				document: {
+					...note(),
+					"@context": ["https://www.w3.org/ns/activitystreams", contextUrl]
+				}
+			} }),
+			contextLoader,
+			verifyPortableObject: async (_, { contextLoader }) => {
+				contexts.push((await contextLoader(contextUrl)).document);
+				return { verified: true };
+			}
+		}), Note);
+		deepStrictEqual(version, 1);
+		deepStrictEqual(contexts, [{ "@context": { version: "urn:version:1" } }]);
+	});
+	await t.step("without verifyPortableObject", async () => {
+		deepStrictEqual(await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader: createLoader({ [plainUrl]: note() }),
+			contextLoader: mockDocumentLoader
+		}), null);
+		assertInstanceOf(await (await createHttpActivity(plainUrl)).getObject({
+			documentLoader: createRedirectingLoader({ [plainUrl]: {
+				documentUrl: gatewayUrl("https://example.com", "/objects/1"),
+				document: note(gatewayUrl("https://example.com", "/objects/1"))
+			} }),
+			contextLoader: mockDocumentLoader
+		}), Note);
+	});
+});
+test("accessors verify embedded objects that stand for portable objects", async () => {
+	const forgedId = gatewayUrl("https://example.com", "/objects/1");
+	const forged = {
+		type: "Note",
+		id: forgedId,
+		content: "Forged"
+	};
+	for (const crossOrigin of [void 0, "trust"]) {
+		const documentLoader = createLoader({ [forgedId]: note() });
+		const verifier = createRecordingVerifier(() => ({ verified: false }));
+		deepStrictEqual(await (await createHttpActivity(forged)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier,
+			crossOrigin
+		}), null);
+		deepStrictEqual(documentLoader.fetched, [forgedId]);
+		deepStrictEqual(verifier.calls.length, 1);
+		deepStrictEqual(await Array.fromAsync((await createHttpActivity([forged])).getObjects({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier,
+			crossOrigin
+		})), []);
+		const documentLoader2 = createLoader({ [gatewayUrl("https://gw.example", "/objects/1")]: note() });
+		const verifier2 = createRecordingVerifier();
+		const object = await (await createHttpActivity({
+			type: "Note",
+			id: objectId,
+			content: "Forged"
+		})).getObject({
+			documentLoader: documentLoader2,
+			contextLoader: mockDocumentLoader,
+			gateways: ["https://gw.example"],
+			verifyPortableObject: verifier2,
+			crossOrigin
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(object.content, "Portable note");
+		deepStrictEqual(verifier2.calls.length, 1);
+	}
+	const otherDid = "did:key:z6Mkother";
+	const otherId = `ap://${otherDid}/objects/1`;
+	const documentLoader = createLoader({ [`https://gw.example/.well-known/apgateway/${otherDid}/objects/1`]: note(otherId) });
+	const verifier = createRecordingVerifier();
+	const crossDid = await (await createActivity({
+		type: "Note",
+		id: otherId,
+		content: "Forged"
+	})).getObject({
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		gateways: ["https://gw.example"],
+		verifyPortableObject: verifier,
+		crossOrigin: "trust"
+	});
+	assertInstanceOf(crossDid, Note);
+	deepStrictEqual(crossDid.content, "Portable note");
+	deepStrictEqual(verifier.calls.length, 1);
+	const object = await (await createActivity({
+		type: "Note",
+		id: objectId,
+		content: "Embedded"
+	})).getObject({
+		documentLoader: createLoader({}),
+		contextLoader: mockDocumentLoader,
+		verifyPortableObject: createVerifier(false)
+	});
+	assertInstanceOf(object, Note);
+	deepStrictEqual(object.content, "Embedded");
+});
+test("singular accessors drop anonymous objects embedded in unsecured collections", async () => {
+	const options = {
+		documentLoader: createLoader({ [gatewayUrl("https://gw.example", "/actor/outbox")]: portableCollection("/actor/outbox", { first: {
+			type: "OrderedCollectionPage",
+			orderedItems: [{
+				type: "Note",
+				content: "Anonymous"
+			}]
+		} }) }),
+		contextLoader: mockDocumentLoader,
+		gateways: ["https://gw.example"],
+		verifyPortableObject: createRecordingVerifier(() => ({
+			verified: true,
+			unsecured: true
+		}))
+	};
+	const outbox = await (await Person.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: `ap://${did}/actor`,
+		type: "Person",
+		inbox: `ap://${did}/actor/inbox`,
+		outbox: `ap://${did}/actor/outbox`
+	}, { contextLoader: mockDocumentLoader })).getOutbox(options);
+	assertInstanceOf(outbox, OrderedCollection);
+	deepStrictEqual(await outbox.getFirst(options), null);
+	deepStrictEqual(await Array.fromAsync(traverseCollection(outbox, options)), []);
+});
 //#endregion
 export {};