@fedify/vocab 2.4.0-dev.2035 → 2.4.0-dev.2054

package/dist-tests/{lookup-B9lgdxnM.mjs → lookup-4fEg7Ybl.mjs}

@@ -1,12 +1,13 @@
 import { Temporal } from "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { k as Object$1 } from "./vocab-Dw_Vm0NE.mjs";
-import { i as isActor, o as name, s as version } from "./actor-BX07d5tK.mjs";
+import { k as Object$1 } from "./vocab-BJGPw--L.mjs";
+import { i as isActor, o as name, s as version } from "./actor-DT_jVPKe.mjs";
 import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
+import { canonicalizePortableUri, formatIri, fromCompatibleEf61Id, getDocumentLoader, haveSameFe34Origin, haveSameIriOrigin, parseIri } from "@fedify/vocab-runtime";
 import { lookupWebFinger } from "@fedify/webfinger";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { getLogger } from "@logtape/logtape";
-import { getDocumentLoader, haveSameFe34Origin, haveSameIriOrigin, parseIri } from "@fedify/vocab-runtime";
+import { PortableObjectRejectedError, dereferencePortableIri, getPortableGatewayCandidates, isPortableIri } from "@fedify/vocab-runtime/internal/portable-dereference";
 import { delay } from "es-toolkit";
 //#region src/handle.ts
 /**
@@ -79,11 +80,13 @@ function getObjectLookupCounter(meterProvider) {
 function getLookupRemoteHost(identifier) {
 	let url;
 	if (identifier instanceof URL) url = identifier;
+	else if (PORTABLE_IRI_PATTERN.test(identifier)) return;
 	else try {
 		url = new URL(identifier);
 	} catch {
 		return extractHandleHost(identifier.startsWith("@") ? identifier.slice(1) : identifier);
 	}
+	if (isPortableIri(url)) return void 0;
 	if (url.host !== "") return url.host;
 	if (url.protocol === "acct:") return extractHandleHost(url.pathname);
 }
@@ -104,6 +107,13 @@ const logger = getLogger([
 	"lookup"
 ]);
 /**
+* The maximum number of requests to FEP-ef61 gateways that a single
+* {@link lookupObject} call makes for portable objects.  Gateways come from
+* possibly untrusted WebFinger responses and location hints, so they are
+* bounded to keep a single lookup from fanning out to many servers.
+*/
+const MAX_PORTABLE_ATTEMPTS = 5;
+/**
 * Looks up an ActivityStreams object by its URI (including `acct:` URIs)
 * or a fediverse handle (e.g., `@user@server` or `user@server`).
 *
@@ -130,6 +140,12 @@ const logger = getLogger([
 * // returning a `Note` object.
 * ```
 *
+* [FEP-ef61] portable objects, including portable actors found through
+* WebFinger, are looked up only if the `verifyPortableObject` option is
+* given; see {@link LookupObjectOptions.verifyPortableObject}.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
 * @param identifier The URI or fediverse handle to look up.
 * @param options Lookup options.
 * @returns The object, or `null` if not found.
@@ -172,12 +188,42 @@ async function lookupObject(identifier, options = {}) {
 }
 async function lookupObjectInternal(identifier, options = {}) {
 	const documentLoader = options.documentLoader ?? getDocumentLoader({ userAgent: options.userAgent });
-	if (typeof identifier === "string") identifier = toAcctUrl(identifier) ?? new URL(identifier);
+	const portable = {
+		options,
+		documentLoader,
+		attempted: /* @__PURE__ */ new Set(),
+		remaining: MAX_PORTABLE_ATTEMPTS
+	};
+	if (typeof identifier === "string") {
+		if (PORTABLE_IRI_PATTERN.test(identifier)) {
+			const candidate = parsePortableCandidate(identifier);
+			if (candidate == null) return null;
+			return await lookupPortableObject(portable, candidate, void 0);
+		}
+		identifier = toAcctUrl(identifier) ?? new URL(identifier);
+	}
+	if (isPortableIri(identifier)) {
+		let candidate;
+		try {
+			candidate = parseIri(identifier);
+		} catch (error) {
+			if (error instanceof TypeError) return null;
+			throw error;
+		}
+		return await lookupPortableObject(portable, candidate, void 0);
+	}
 	let remoteDoc = null;
-	if (identifier.protocol === "http:" || identifier.protocol === "https:") try {
-		remoteDoc = await documentLoader(identifier.href, { signal: options.signal });
-	} catch (error) {
-		logger.debug("Failed to fetch remote document:\n{error}", { error });
+	if (identifier.protocol === "http:" || identifier.protocol === "https:") {
+		const compatible = getCompatibleCandidate(identifier.href, options);
+		if (compatible !== void 0) {
+			if (compatible == null) return null;
+			return await lookupPortableObject(portable, compatible.id, [compatible.gateway]);
+		}
+		try {
+			remoteDoc = await documentLoader(identifier.href, { signal: options.signal });
+		} catch (error) {
+			logger.debug("Failed to fetch remote document:\n{error}", { error });
+		}
 	}
 	if (remoteDoc == null) {
 		const jrd = await lookupWebFinger(identifier, {
@@ -188,8 +234,31 @@ async function lookupObjectInternal(identifier, options = {}) {
 			signal: options.signal
 		});
 		if (jrd?.links == null) return null;
+		const webFingerGateway = getWebFingerGateway(identifier);
 		for (const l of jrd.links) {
 			if (l.type !== "application/activity+json" && !l.type?.match(/application\/ld\+json;\s*profile="https:\/\/www.w3.org\/ns\/activitystreams"/) || l.rel !== "self" || l.href == null) continue;
+			if (PORTABLE_IRI_PATTERN.test(l.href)) {
+				if (options.verifyPortableObject == null) {
+					logger.debug("Skipping the portable self link {href}, as the verifyPortableObject option is not given.", { href: l.href });
+					continue;
+				}
+				const candidate = parsePortableCandidate(l.href);
+				if (candidate == null) continue;
+				const gateways = webFingerGateway == null ? [] : [webFingerGateway];
+				gateways.push(...getPortableGatewayCandidates(candidate));
+				const object = await lookupPortableObject(portable, candidate, gateways);
+				if (object != null) return object;
+				if (options.signal?.aborted) return null;
+				continue;
+			}
+			const compatible = getCompatibleCandidate(l.href, options);
+			if (compatible !== void 0) {
+				if (compatible == null) continue;
+				const object = await lookupPortableObject(portable, compatible.id, [compatible.gateway]);
+				if (object != null) return object;
+				if (options.signal?.aborted) return null;
+				continue;
+			}
 			try {
 				remoteDoc = await documentLoader(l.href, { signal: options.signal });
 				break;
@@ -220,7 +289,7 @@ async function lookupObjectInternal(identifier, options = {}) {
 		}
 		throw error;
 	}
-	if (options.crossOrigin !== "trust" && object.id != null && !haveSameIriOrigin(object.id, documentUrl) && !haveSameFe34Origin(object.id, documentUrl)) {
+	if (object.id != null && (options.crossOrigin !== "trust" || isPortableIri(object.id)) && !haveSameIriOrigin(object.id, documentUrl) && !haveSameFe34Origin(object.id, documentUrl)) {
 		if (options.crossOrigin === "throw") throw new Error(`The object's @id (${object.id.href}) has a different origin than the document URL (${remoteDoc.documentUrl}); refusing to return the object.  If you want to bypass this check and are aware of the security implications, set the crossOrigin option to "trust".`);
 		logger.warn("The object's @id ({objectId}) has a different origin than the document URL ({documentUrl}); refusing to return the object.  If you want to bypass this check and are aware of the security implications, set the crossOrigin option to \"trust\".", {
 			...remoteDoc,
@@ -230,6 +299,139 @@ async function lookupObjectInternal(identifier, options = {}) {
 	}
 	return object;
 }
+const PORTABLE_IRI_PATTERN = /^ap(?:\+ef61)?:/i;
+/**
+* Parses a raw portable IRI.  URL parsing normalizes dot segments in the
+* opaque path, which would make the parsed IRI identify another portable
+* object, so such IRIs are refused.
+*/
+function parsePortableCandidate(iri) {
+	try {
+		const parsed = parseIri(iri);
+		if (canonicalizePortableUri(iri) !== canonicalizePortableUri(formatIri(parsed))) {
+			logger.debug("Refusing to look up the portable IRI {iri}, as its path cannot be represented without changing the identified object.", { iri });
+			return null;
+		}
+		return parsed;
+	} catch (error) {
+		if (error instanceof TypeError) {
+			logger.debug("Invalid portable IRI {iri}: {error}", {
+				iri,
+				error
+			});
+			return null;
+		}
+		throw error;
+	}
+}
+/**
+* Recognizes an FEP-ef61 compatible identifier to look up as a portable
+* object.
+* @returns `undefined` if the URL should be fetched as an ordinary HTTP(S)
+*          URL, i.e., it is not a compatible identifier, or the
+*          `verifyPortableObject` option is not given; `null` if it is
+*          a malformed compatible identifier; otherwise, the portable ID and
+*          the gateway to ask.
+*/
+function getCompatibleCandidate(href, options) {
+	if (options.verifyPortableObject == null || !URL.canParse(href)) return;
+	const url = new URL(href);
+	try {
+		const id = fromCompatibleEf61Id(url);
+		if (id == null) return void 0;
+		return {
+			id,
+			gateway: new URL(url.origin)
+		};
+	} catch (error) {
+		if (error instanceof TypeError) {
+			logger.debug("Invalid FEP-ef61 compatible identifier {href}: {error}", {
+				href,
+				error
+			});
+			return null;
+		}
+		throw error;
+	}
+}
+/**
+* Gets the origin of the WebFinger server that {@link lookupWebFinger} asks
+* for the identifier, which is also the first gateway of a portable actor.
+*/
+function getWebFingerGateway(identifier) {
+	let url;
+	if (identifier.protocol === "acct:") {
+		const host = extractHandleHost(identifier.pathname);
+		if (host == null) return void 0;
+		url = new URL(`https://${host}/`);
+	} else if (identifier.protocol === "http:" || identifier.protocol === "https:") url = new URL(identifier.origin);
+	else return;
+	return url.username === "" && url.password === "" ? url : void 0;
+}
+/**
+* Looks up a portable object through FEP-ef61 gateways.
+* @param gateways The gateways to ask in order.  If omitted, the location
+*                 hints in the IRI are used, and if there are none, the
+*                 portable IRI itself is passed to the document loader.
+*/
+async function lookupPortableObject(lookup, id, gateways) {
+	const { options } = lookup;
+	const iri = formatIri(id);
+	if (options.verifyPortableObject == null) {
+		logger.debug("Cannot look up the portable object {iri}, as the verifyPortableObject option is not given.", { iri });
+		return null;
+	}
+	const canonicalId = canonicalizePortableUri(iri);
+	let candidates;
+	if (gateways == null) {
+		candidates = getPortableGatewayCandidates(id);
+		if (candidates.length < 1) {
+			const key = `${canonicalId} `;
+			if (lookup.remaining < 1 || lookup.attempted.has(key)) return null;
+			lookup.attempted.add(key);
+			lookup.remaining--;
+			return await dereference(lookup, id, []);
+		}
+	} else candidates = [...gateways];
+	const selected = [];
+	for (const gateway of candidates) {
+		if (selected.length >= lookup.remaining) break;
+		const key = `${canonicalId} ${gateway.href}`;
+		if (lookup.attempted.has(key)) continue;
+		lookup.attempted.add(key);
+		selected.push(gateway);
+	}
+	if (selected.length < 1) return null;
+	lookup.remaining -= selected.length;
+	return await dereference(lookup, id, selected);
+}
+async function dereference({ options, documentLoader }, id, gateways) {
+	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+	try {
+		return await dereferencePortableIri(id, {
+			documentLoader,
+			contextLoader: options.contextLoader ?? getDocumentLoader({ userAgent: options.userAgent }),
+			tracerProvider,
+			gateways,
+			verifyPortableObject: options.verifyPortableObject,
+			crossOrigin: options.crossOrigin === "throw" ? "throw" : "ignore",
+			signal: options.signal,
+			parse: (document, { contextLoader, baseUrl }) => Object$1.fromJsonLd(document, {
+				documentLoader,
+				contextLoader,
+				tracerProvider,
+				baseUrl
+			})
+		});
+	} catch (error) {
+		if (error instanceof PortableObjectRejectedError) throw error;
+		logger.debug("Failed to look up the portable object {iri}:\n{error}", {
+			iri: formatIri(id),
+			error
+		});
+		return null;
+	}
+}
 /**
 * Traverses a collection, yielding each item in the collection.
 * If the collection is paginated, it will fetch the next page

package/dist-tests/lookup.test.mjs

@@ -1,9 +1,9 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { O as Note, P as Person, k as Object$1, s as Collection } from "./vocab-Dw_Vm0NE.mjs";
-import { t as esm_default } from "./esm-C_FjLvhG.mjs";
-import { n as traverseCollection, t as lookupObject } from "./lookup-B9lgdxnM.mjs";
+import { O as Note, P as Person, k as Object$1, s as Collection } from "./vocab-BJGPw--L.mjs";
+import { t as esm_default } from "./esm-Df0Yo-Tp.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
+import { n as traverseCollection, t as lookupObject } from "./lookup-4fEg7Ybl.mjs";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, equal, ok, rejects } from "node:assert/strict";
 //#region src/lookup.test.ts

package/dist-tests/portable-lookup.test.mjs

@@ -0,0 +1,335 @@
+import "temporal-polyfill";
+globalThis.addEventListener = () => {};
+import { P as Person } from "./vocab-BJGPw--L.mjs";
+import { t as esm_default } from "./esm-Df0Yo-Tp.mjs";
+import { n as getActorHandle } from "./actor-DT_jVPKe.mjs";
+import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
+import { t as lookupObject } from "./lookup-4fEg7Ybl.mjs";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { deepStrictEqual, equal, rejects } from "node:assert/strict";
+import { FetchError, parseIri } from "@fedify/vocab-runtime";
+//#region src/portable-lookup.test.ts
+const did = "did:key:z6Mkabc";
+const actorId = `ap+ef61://${did}/actor`;
+const gatewayPath = `/.well-known/apgateway/${did}/actor`;
+const compatibleId = `https://example.com${gatewayPath}`;
+const webFingerPrefix = "begin:https://example.com/.well-known/webfinger";
+const AS_TYPE = "application/activity+json";
+function person(id = `ap://${did}/actor`, extra = {}) {
+	return {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id,
+		type: "Person",
+		name: "Alice",
+		...extra
+	};
+}
+function createLoader(responses) {
+	const fetched = [];
+	const loader = async (url, options) => {
+		fetched.push(url);
+		options?.signal?.throwIfAborted();
+		const document = responses[url];
+		if (document == null) throw new FetchError(url, "HTTP 404", new globalThis.Response(null, { status: 404 }));
+		return {
+			contextUrl: null,
+			documentUrl: url,
+			document
+		};
+	};
+	return Object.assign(loader, { fetched });
+}
+function createVerifier(verified = true) {
+	const documents = [];
+	const verifier = async (document) => {
+		documents.push(document);
+		return { verified };
+	};
+	return Object.assign(verifier, { documents });
+}
+function selfLinks(...hrefs) {
+	return {
+		subject: "acct:alice@example.com",
+		links: hrefs.map((href) => ({
+			rel: "self",
+			type: AS_TYPE,
+			href
+		}))
+	};
+}
+test("lookupObject() with FEP-ef61 portable actors", {
+	sanitizeResources: false,
+	sanitizeOps: false
+}, async (t) => {
+	esm_default.spyGlobal();
+	try {
+		await t.step("compatible self link, alias-free JRD", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, selfLinks(compatibleId));
+			const document = person();
+			const documentLoader = createLoader({ [compatibleId]: document });
+			const verifyPortableObject = createVerifier();
+			const actor = await lookupObject("@alice@example.com", {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				verifyPortableObject
+			});
+			assertInstanceOf(actor, Person);
+			deepStrictEqual(actor.id, parseIri(actorId));
+			deepStrictEqual(documentLoader.fetched, [compatibleId]);
+			deepStrictEqual(verifyPortableObject.documents, [document]);
+		});
+		await t.step("canonical self link asks the WebFinger host first", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, {
+				subject: "acct:alice@example.com",
+				links: [{
+					rel: "self",
+					type: "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
+					href: `ap://${did}/actor?@gateway=https%3A%2F%2Fhint.example`
+				}]
+			});
+			const hinted = `https://hint.example${gatewayPath}`;
+			const documentLoader = createLoader({ [hinted]: person() });
+			assertInstanceOf(await lookupObject("@alice@example.com", {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				verifyPortableObject: createVerifier()
+			}), Person);
+			deepStrictEqual(documentLoader.fetched, [compatibleId, hinted]);
+		});
+		await t.step("tries the next self link after a failure", async () => {
+			esm_default.removeRoutes();
+			const other = `https://other.example${gatewayPath}`;
+			esm_default.get(webFingerPrefix, selfLinks(`ap://${did}/actor`, compatibleId, other));
+			const documentLoader = createLoader({ [other]: person() });
+			assertInstanceOf(await lookupObject("@alice@example.com", {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				verifyPortableObject: createVerifier()
+			}), Person);
+			deepStrictEqual(documentLoader.fetched, [compatibleId, other]);
+		});
+		await t.step("rejects objects that fail the checks", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, selfLinks(compatibleId));
+			for (const [document, verified] of [
+				[person(), false],
+				[person(`ap://${did}/other`), true],
+				[person(compatibleId), true]
+			]) {
+				const documentLoader = createLoader({ [compatibleId]: document });
+				const verifyPortableObject = createVerifier(verified);
+				equal(await lookupObject("@alice@example.com", {
+					documentLoader,
+					contextLoader: mockDocumentLoader,
+					verifyPortableObject
+				}), null);
+				deepStrictEqual(documentLoader.fetched, [compatibleId]);
+				await rejects(() => lookupObject("@alice@example.com", {
+					documentLoader,
+					contextLoader: mockDocumentLoader,
+					verifyPortableObject,
+					crossOrigin: "throw"
+				}), { name: "PortableObjectRejectedError" });
+				equal(await lookupObject("@alice@example.com", {
+					documentLoader,
+					contextLoader: mockDocumentLoader,
+					verifyPortableObject,
+					crossOrigin: "trust"
+				}), null);
+			}
+		});
+		await t.step("without verifyPortableObject", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, selfLinks(`ap://${did}/actor`, compatibleId));
+			const documentLoader = createLoader({ [compatibleId]: person() });
+			for (const crossOrigin of ["ignore", "trust"]) equal(await lookupObject("@alice@example.com", {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				crossOrigin
+			}), null);
+			deepStrictEqual(documentLoader.fetched, [compatibleId, compatibleId]);
+			await rejects(() => lookupObject("@alice@example.com", {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				crossOrigin: "throw"
+			}), /has a different origin than the document URL/);
+			const actor = await lookupObject("@alice@example.com", {
+				documentLoader: createLoader({ [compatibleId]: person(compatibleId) }),
+				contextLoader: mockDocumentLoader
+			});
+			assertInstanceOf(actor, Person);
+			deepStrictEqual(actor.id, new URL(compatibleId));
+		});
+		await t.step("refuses portable IRIs changed by URL parsing", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, selfLinks(`ap://${did}/x/../actor`, `ap://${did}/x/%2e%2e/actor`));
+			const documentLoader = createLoader({ [compatibleId]: person() });
+			const options = {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				verifyPortableObject: createVerifier()
+			};
+			equal(await lookupObject("@alice@example.com", options), null);
+			equal(await lookupObject(`ap://${did}/x/../actor?@gateway=https%3A%2F%2Fexample.com`, options), null);
+			deepStrictEqual(documentLoader.fetched, []);
+		});
+		await t.step("bounds gateway requests", async () => {
+			esm_default.removeRoutes();
+			const hints = Array.from({ length: 5 }, (_, i) => `@gateway=https%3A%2F%2Fg${i}.example`).join("&");
+			esm_default.get(webFingerPrefix, selfLinks(`ap://${did}/actor?${hints}`, `ap://${did}/actor2?${hints}`, `https://g9.example/.well-known/apgateway/${did}/actor`));
+			const documentLoader = createLoader({});
+			equal(await lookupObject("@alice@example.com", {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				verifyPortableObject: createVerifier()
+			}), null);
+			deepStrictEqual(documentLoader.fetched, [compatibleId, ...[
+				0,
+				1,
+				2,
+				3
+			].map((i) => `https://g${i}.example${gatewayPath}`)]);
+		});
+		await t.step("cancellation", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, selfLinks(`ap://${did}/actor`, `https://other.example${gatewayPath}`));
+			const controller = new AbortController();
+			const verifyPortableObject = () => {
+				controller.abort();
+				return Promise.resolve({ verified: true });
+			};
+			const documentLoader = createLoader({ [compatibleId]: person() });
+			equal(await lookupObject("@alice@example.com", {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				verifyPortableObject,
+				signal: controller.signal
+			}), null);
+			deepStrictEqual(documentLoader.fetched, [compatibleId]);
+		});
+	} finally {
+		esm_default.removeRoutes();
+		esm_default.hardReset();
+	}
+});
+test("lookupObject() looks up portable identifiers directly", async () => {
+	const verifyPortableObject = createVerifier();
+	const hinted = `https://gw.example${gatewayPath}`;
+	const documentLoader = createLoader({
+		[hinted]: person(),
+		[`https://example.com${gatewayPath}`]: person(),
+		[actorId]: person()
+	});
+	const options = {
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		verifyPortableObject
+	};
+	for (const identifier of [
+		`ap://${did}/actor?@gateway=https%3A%2F%2Fgw.example`,
+		compatibleId,
+		new URL(compatibleId),
+		`ap://${did}/actor`,
+		parseIri(`ap://${did}/actor`)
+	]) {
+		const actor = await lookupObject(identifier, options);
+		assertInstanceOf(actor, Person);
+		deepStrictEqual(actor.id, parseIri(actorId));
+	}
+	deepStrictEqual(documentLoader.fetched, [
+		hinted,
+		compatibleId,
+		compatibleId,
+		actorId,
+		actorId
+	]);
+	equal(await lookupObject(`ap://${did}/actor`, {
+		documentLoader,
+		contextLoader: mockDocumentLoader
+	}), null);
+	deepStrictEqual(documentLoader.fetched.length, 5);
+});
+test("getActorHandle() with FEP-ef61 portable actors", {
+	sanitizeResources: false,
+	sanitizeOps: false
+}, async (t) => {
+	const actor = new Person({
+		id: parseIri(actorId),
+		preferredUsername: "alice",
+		gateways: [new URL("https://example.com"), new URL("https://example.org")]
+	});
+	esm_default.spyGlobal();
+	try {
+		await t.step("verified through the first gateway", async () => {
+			esm_default.removeRoutes();
+			esm_default.get("https://example.com/.well-known/webfinger?resource=acct%3Aalice%40example.com", selfLinks(compatibleId));
+			deepStrictEqual(await getActorHandle(actor), "@alice@example.com");
+		});
+		await t.step("canonical self link", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, selfLinks(`ap://${did}/actor`));
+			deepStrictEqual(await getActorHandle(actor), "@alice@example.com");
+		});
+		await t.step("follows a verified subject", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, {
+				...selfLinks(compatibleId),
+				subject: "acct:alice@example.org"
+			});
+			esm_default.get("begin:https://example.org/.well-known/webfinger", {
+				...selfLinks(compatibleId),
+				subject: "acct:alice@example.org"
+			});
+			deepStrictEqual(await getActorHandle(actor), "@alice@example.org");
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, {
+				...selfLinks(compatibleId),
+				subject: "acct:alice@example.org"
+			});
+			esm_default.get("begin:https://example.org/.well-known/webfinger", selfLinks(`ap://${did}/other`));
+			deepStrictEqual(await getActorHandle(actor), "@alice@example.com");
+		});
+		await t.step("rejects a WebFinger response for another actor", async () => {
+			for (const jrd of [
+				selfLinks(`https://example.com/.well-known/apgateway/${did}/other`),
+				selfLinks("https://example.com/users/alice"),
+				{
+					subject: "acct:alice@example.com",
+					links: []
+				}
+			]) {
+				esm_default.removeRoutes();
+				esm_default.get(webFingerPrefix, jrd);
+				await rejects(() => getActorHandle(actor), TypeError);
+			}
+		});
+		await t.step("does not fall back when WebFinger fails", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, 404);
+			await rejects(() => getActorHandle(actor), TypeError);
+		});
+		await t.step("not enough information", async () => {
+			esm_default.removeRoutes();
+			esm_default.clearHistory();
+			for (const target of [
+				parseIri(actorId),
+				new Person({
+					id: parseIri(actorId),
+					preferredUsername: "alice"
+				}),
+				new Person({
+					id: parseIri(actorId),
+					gateways: [new URL("https://example.com")]
+				})
+			]) await rejects(() => getActorHandle(target), TypeError);
+			deepStrictEqual(esm_default.callHistory.calls().length, 0);
+		});
+	} finally {
+		esm_default.removeRoutes();
+		esm_default.hardReset();
+	}
+});
+//#endregion
+export {};

package/dist-tests/signed-representation.test.mjs

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { O as Note, R as Question, Y as vocab_exports, i as Announce, j as OrderedCollection, l as Create } from "./vocab-Dw_Vm0NE.mjs";
+import { O as Note, R as Question, Y as vocab_exports, i as Announce, j as OrderedCollection, l as Create } from "./vocab-BJGPw--L.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, ok } from "node:assert/strict";
 import { isMarkerSafeContext, retainSignedRepresentation } from "@fedify/vocab-runtime/internal/signed-representation";

package/dist-tests/translation.test.mjs

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { G as Translation, H as Service, I as PropertyValue, K as Update, N as Organization, O as Note, P as Person, T as Link, a as Application, k as Object$1, l as Create, o as Article, s as Collection, y as Group } from "./vocab-Dw_Vm0NE.mjs";
-import "./actor-BX07d5tK.mjs";
-import "./lookup-B9lgdxnM.mjs";
+import { G as Translation, H as Service, I as PropertyValue, K as Update, N as Organization, O as Note, P as Person, T as Link, a as Application, k as Object$1, l as Create, o as Article, s as Collection, y as Group } from "./vocab-BJGPw--L.mjs";
+import "./actor-DT_jVPKe.mjs";
+import "./lookup-4fEg7Ybl.mjs";
 import { test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
 import { LanguageString as LanguageString$1, getDocumentLoader, preloadedContexts } from "@fedify/vocab-runtime";

package/dist-tests/type.test.mjs

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { J as isEntityType, P as Person, T as Link, q as getEntityTypeById } from "./vocab-Dw_Vm0NE.mjs";
+import { J as isEntityType, P as Person, T as Link, q as getEntityTypeById } from "./vocab-BJGPw--L.mjs";
 import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
 import { test } from "@fedify/fixture";
 import { deepStrictEqual } from "node:assert/strict";