@fedify/vocab 2.4.0-dev.2063 → 2.4.0-dev.2071

package/dist-tests/{actor-hpNVHQvY.mjs → actor-CPbEFVm1.mjs}

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-DZq1JW3s.mjs";
+import { F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-BHtBRusa.mjs";
 import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
 import { canonicalizePortableUri, formatIri, fromCompatibleEf61Id, isGatewayUrl } from "@fedify/vocab-runtime";
 import { lookupWebFinger } from "@fedify/webfinger";
@@ -8,7 +8,7 @@ import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { domainToASCII, domainToUnicode } from "node:url";
 //#region deno.json
 var name = "@fedify/vocab";
-var version = "2.4.0-dev.2063+366c0362";
+var version = "2.4.0-dev.2071+8b9dccb9";
 //#endregion
 //#region src/actor.ts
 const ACTOR_DISCOVERY_HISTOGRAM_BUCKETS = [

package/dist-tests/actor.test.mjs

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { F as Person, P as Organization, Q as __exportAll, U as Service, a as Application, b as Group } from "./vocab-DZq1JW3s.mjs";
-import { t as esm_default } from "./esm-CuilqPDu.mjs";
-import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-hpNVHQvY.mjs";
+import { F as Person, P as Organization, Q as __exportAll, U as Service, a as Application, b as Group } from "./vocab-BHtBRusa.mjs";
+import { t as esm_default } from "./esm-C9nxP5_e.mjs";
+import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-CPbEFVm1.mjs";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert/strict";
 //#region ../../node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/precondition/PreconditionFailure.js

package/dist-tests/{esm-CuilqPDu.mjs → esm-C9nxP5_e.mjs}

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { $ as __toESM, Z as __commonJSMin } from "./vocab-DZq1JW3s.mjs";
+import { $ as __toESM, Z as __commonJSMin } from "./vocab-BHtBRusa.mjs";
 //#endregion
 //#region ../../node_modules/.pnpm/regexparam@3.0.0/node_modules/regexparam/dist/index.mjs
 var import_glob_to_regexp = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {

package/dist-tests/gateway.test.mjs

@@ -1,12 +1,12 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { F as Person, M as OrderedCollection, c as CollectionPage, k as Note, s as Collection, u as Create } from "./vocab-DZq1JW3s.mjs";
-import { t as esm_default } from "./esm-CuilqPDu.mjs";
-import { n as traverseCollection } from "./lookup-Bi6dOTm_.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-e0QSMZGC.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`;
@@ -507,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,
@@ -519,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;
@@ -763,14 +768,222 @@ test("accessors do not trust objects embedded in unsecured collections", async (
 		suppressError: true
 	})), []);
 });
-test("accessors reject compatible identifiers from portable objects", async () => {
-	const compatibleId = gatewayUrl("https://evil.example", "/actor/outbox");
-	const collection = (id) => ({
+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",
-		id,
-		type: "OrderedCollection",
-		totalItems: 0
+		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`,
@@ -778,37 +991,275 @@ test("accessors reject compatible identifiers from portable objects", async () =
 		inbox: `ap://${did}/actor/inbox`,
 		outbox
 	}, { contextLoader: mockDocumentLoader });
-	const redirectingLoader = (url) => Promise.resolve({
-		contextUrl: null,
-		documentUrl: url === "https://example.com/outbox" ? compatibleId : url,
-		document: collection(url === "https://example.com/outbox" ? compatibleId : url)
+	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"]) {
-		const options = {
-			documentLoader: redirectingLoader,
+	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: createRecordingVerifier(),
+			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);
 		};
-		deepStrictEqual(await (await person(compatibleId)).getOutbox(options), null);
-		deepStrictEqual(await (await person("https://example.com/outbox")).getOutbox(options), null);
-		deepStrictEqual(await (await person(collection(compatibleId))).getOutbox(options), null);
+		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);
 	}
-	await rejects(async () => await (await person(compatibleId)).getOutbox({
-		documentLoader: redirectingLoader,
+	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,
-		crossOrigin: "throw"
-	}), /portable object/);
-	assertInstanceOf(await (await Person.fromJsonLd({
-		"@context": "https://www.w3.org/ns/activitystreams",
-		id: "https://evil.example/actor",
-		type: "Person",
-		inbox: "https://evil.example/actor/inbox",
-		outbox: compatibleId
-	}, { contextLoader: mockDocumentLoader })).getOutbox({
-		documentLoader: redirectingLoader,
-		contextLoader: mockDocumentLoader
-	}), OrderedCollection);
+		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 = {