@fedify/fedify 2.4.0-dev.2141 → 2.4.0-dev.2155

package/dist/{middleware-1mv9QR16.js → middleware-BDUR99k3.js}

@@ -2,15 +2,15 @@ import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 import { t as __exportAll } from "./rolldown-runtime-BC-Eo5Mj.js";
 import { r as getDefaultActivityTransformers } from "./transformers-DAtXl_Kc.js";
-import { $ as recordCollectionRequest, A as isClearlyMalformedContextReference, Ct as name, D as getNormalizationContextLoader, E as detachSignature, G as getDurationMs, H as importJwk, I as wrapContextLoaderForJsonLd, J as instrumentDocumentLoader, K as getFederationMetrics, L as exportJwk, M as signJsonLd, N as verifyCompactJsonLd, O as hasSignature, Q as recordCollectionPageItems, S as assertSafeJsonLd, U as validateCryptoKey, X as recordCircuitBreakerStateChange, Y as isAbortError, Z as recordCollectionDispatchDuration, _ as verifyPortableObjectProofPolicy, _t as hasPortableActor, at as recordOutboxEnqueue, b as normalizeOutgoingActivityJsonLd, bt as isPortableKeyId, ct as preloadedOnlyDocumentLoader, et as recordCollectionTotalItems, f as hasProofLike, g as verifyPortableObjectProof, gt as getRawCanonicalPortableId, h as verifyObject, ht as getPortableDid, i as selectRequestSignature, it as recordOutboxActivity, j as isInvalidUrlTypeError, k as hasSignatureLike, lt as formatAcceptSignature, m as verifyMapLocalProof, mt as getGatewayKeyBase, n as listRequestSignatures, nt as recordFanoutRecipients, o as verifyRequest, ot as recordWebFingerHandle, p as signObject, pt as getCanonicalPortableId, q as getRemoteHost, r as parseRfc9421SignatureInput, rt as recordInboxActivity, s as verifyRequestDetailed, st as registerQueueDepthGauge, t as doubleKnock, u as InvalidPortableObjectIdError, v as verifyPortableObjectProofWithRoot, vt as isCompatibleKeyId, w as compactJsonLd, wt as version, x as InvalidContextReferenceError, xt as isPortableUri, yt as isPortableId } from "./http-D4KW2GTi.js";
+import { $ as recordCollectionPageItems, A as hasSignatureLike, C as assertSafeJsonLd, D as detachSignature, J as getRemoteHost, K as getDurationMs, L as wrapContextLoaderForJsonLd, M as isInvalidUrlTypeError, N as signJsonLd, O as getNormalizationContextLoader, P as verifyCompactJsonLd, Q as recordCollectionDispatchDuration, R as exportJwk, S as InvalidContextReferenceError, St as isPortableUri, T as compactJsonLd, Tt as version, U as importJwk, W as validateCryptoKey, X as isAbortError, Y as instrumentDocumentLoader, Z as recordCircuitBreakerStateChange, _ as verifyPortableObjectProof, _t as getRawCanonicalPortableId, at as recordOutboxActivity, bt as isPortableId, ct as registerQueueDepthGauge, d as classifyFep2277CoreType, et as recordCollectionRequest, g as verifyObject, gt as getPortableDid, h as verifyMapLocalProof, ht as getGatewayKeyBase, i as selectRequestSignature, it as recordInboxActivity, j as isClearlyMalformedContextReference, k as hasSignature, lt as preloadedOnlyDocumentLoader, m as signObject, mt as getCanonicalPortableId, n as listRequestSignatures, o as verifyRequest, ot as recordOutboxEnqueue, p as hasProofLike, q as getFederationMetrics, r as parseRfc9421SignatureInput, rt as recordFanoutRecipients, s as verifyRequestDetailed, st as recordWebFingerHandle, t as doubleKnock, tt as recordCollectionTotalItems, u as InvalidPortableObjectIdError, ut as formatAcceptSignature, v as verifyPortableObjectProofPolicy, vt as hasPortableActor, wt as name, x as normalizeOutgoingActivityJsonLd, xt as isPortableKeyId, y as verifyPortableObjectProofWithRoot, yt as isCompatibleKeyId } from "./http-Dk4O3WM0.js";
 import { a as MAX_BODY_SIZE, i as BodyTooLargeError, n as getNodeInfo, o as readBoundedText, t as nodeInfoToJson } from "./types-C_cNlNVK.js";
-import { n as doesActorOwnKey, r as getKeyOwner, t as verifyPortableObject } from "./portable-collection-CG9P_i0E.js";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-D_E-2K3i.js";
+import { n as doesActorOwnKey, r as getKeyOwner, t as verifyPortableObject } from "./portable-collection-BCy06GiS.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-3uKc0G76.js";
 import { getLogger, withContext } from "@logtape/logtape";
 import { Router, RouterError, assertPath } from "@fedify/uri-template";
-import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, Tombstone, getTypeId, lookupObject, traverseCollection } from "@fedify/vocab";
+import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, Tombstone, getTypeId, isActor, lookupObject, traverseCollection } from "@fedify/vocab";
 import { SpanKind, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
-import { FetchError, UrlError, canonicalizePortableUri, decodeMultibase, formatIri, fromCompatibleEf61Id, getDocumentLoader, getFe34Origin, isGatewayUrl, parseDigestMultibase, parseHashlink, parseIri, toCompatibleEf61Id, validatePublicUrl } from "@fedify/vocab-runtime";
+import { FetchError, UrlError, canonicalizePortableUri, decodeMultibase, formatIri, fromCompatibleEf61Id, getDocumentLoader, getFe34Origin, isGatewayUrl, parseDigestMultibase, parseHashlink, parseIri, preloadedContexts, toCompatibleEf61Id, validatePublicUrl } from "@fedify/vocab-runtime";
 import { isCompatibleEf61Iri } from "@fedify/vocab-runtime/internal/portable-dereference";
 import { encodeHex } from "byte-encodings/hex";
 import jsonld from "@fedify/vocab-runtime/jsonld";
@@ -211,6 +211,7 @@ var FederationBuilderImpl = class {
 			else if (!portable && actor.id.href != context.getActorUri(identifier).href) logger.warn("Actor dispatcher returned an actor with an id property that does not match the actor URI.  Set the property with Context.getActorUri(identifier).");
 			if (actor instanceof Tombstone) return actor;
 			if (actor.id != null && isCompatibleEf61Iri(actor.id)) warnCompatibleActorId(actor.id, actor.gateway);
+			if (portable) this.#warnPortableCollectionIds(context, identifier, actor);
 			if (this.followingCallbacks != null && this.followingCallbacks.dispatcher != null) {
 				if (actor.followingId == null) logger.warn("You configured a following collection dispatcher, but the actor does not have a following property.  Set the property with Context.getFollowingUri(identifier).");
 				else if (!portable && actor.followingId.href != context.getFollowingUri(identifier).href) logger.warn("You configured a following collection dispatcher, but the actor's following property does not match the following collection URI.  Set the property with Context.getFollowingUri(identifier).");
@@ -696,6 +697,10 @@ var FederationBuilderImpl = class {
 			authorize(predicate) {
 				callbacks.authorizePredicate = predicate;
 				return setters;
+			},
+			mapPortableOwner(mapper) {
+				callbacks.portableOwnerMapper = mapper;
+				return setters;
 			}
 		};
 		return setters;
@@ -717,6 +722,54 @@ var FederationBuilderImpl = class {
 		this.outboxPermanentFailureHandler = handler;
 	}
 	/**
+	* Warns if a portable actor's collection properties that are portable IDs
+	* or compatible identifiers do not refer to the collections that
+	* the registered collection dispatchers serve through the FEP-ef61 gateway
+	* endpoint for the actor's DID.  Properties with ordinary HTTP(S) URLs are
+	* not compared, since a portable actor may keep ordinary collections.
+	*/
+	#warnPortableCollectionIds(context, identifier, actor) {
+		const did = actor.id == null ? null : getPortableDid(actor.id);
+		if (did == null) return;
+		const logger = getLogger([
+			"fedify",
+			"federation",
+			"actor"
+		]);
+		const check = (registered, property, value, helper, build) => {
+			if (!registered || value == null || !isPortableId(value)) return;
+			const actual = getCanonicalPortableId(value);
+			if (actual == null) {
+				logger.warn("The actor's {property} property, {value}, is a malformed FEP-ef61 portable ID or compatible identifier.", {
+					property,
+					value: value.href
+				});
+				return;
+			}
+			let expected;
+			try {
+				expected = build();
+			} catch (error) {
+				if (error instanceof TypeError || error instanceof RouterError) return;
+				throw error;
+			}
+			if (actual === getCanonicalPortableId(expected)) return;
+			logger.warn("The portable actor's {property} property, {value}, does not match the portable ID of the collection that the gateway endpoint serves, {expected}.  Set the property with Context.{helper}(identifier, did).", {
+				property,
+				value: value.href,
+				expected: expected.href,
+				helper
+			});
+		};
+		check(this.outboxCallbacks?.dispatcher != null, "outbox", actor.outboxId, "getPortableOutboxUri", () => context.getPortableOutboxUri(identifier, did));
+		check(this.inboxCallbacks?.dispatcher != null || this.router.has("inbox"), "inbox", actor.inboxId, "getPortableInboxUri", () => context.getPortableInboxUri(identifier, did));
+		check(this.followingCallbacks?.dispatcher != null, "following", actor.followingId, "getPortableFollowingUri", () => context.getPortableFollowingUri(identifier, did));
+		check(this.followersCallbacks?.dispatcher != null, "followers", actor.followersId, "getPortableFollowersUri", () => context.getPortableFollowersUri(identifier, did));
+		check(this.likedCallbacks?.dispatcher != null, "liked", actor.likedId, "getPortableLikedUri", () => context.getPortableLikedUri(identifier, did));
+		check(this.featuredCallbacks?.dispatcher != null, "featured", actor.featuredId, "getPortableFeaturedUri", () => context.getPortableFeaturedUri(identifier, did));
+		check(this.featuredTagsCallbacks?.dispatcher != null, "featuredTags", actor.featuredTagsId, "getPortableFeaturedTagsUri", () => context.getPortableFeaturedTagsUri(identifier, did));
+	}
+	/**
 	* Converts a name (string or symbol) to a unique string identifier.
 	* For symbols, generates and caches a UUID if not already present.
 	* For strings, returns the string as-is.
@@ -2067,6 +2120,218 @@ function isSingleStringValue(values, datatype) {
 	const keys = Object.keys(value);
 	return keys.length === 1 || datatype != null && keys.length === 2 && value["@type"] === datatype;
 }
+/**
+* FEP-2277 core types that FEP-ef61 does not require to carry proofs.
+*/
+const UNSECURED_CORE_TYPES = /* @__PURE__ */ new Set([
+	"collection",
+	"link",
+	"verificationMethod",
+	"publicKey"
+]);
+/**
+* Applies the FEP-ef61 proof policy, under the map-local compound-proof
+* profile, to every portable object embedded in a document that a gateway is
+* about to serve, e.g., the items of a portable collection page.  The root
+* map itself is not checked, as the caller built it.
+*
+* Each map below the root whose direct `id` or `@id` is a portable ID or
+* a compatible identifier is checked independently of the others:
+*
+*  -  A map with a direct `proof` is a separately secured document: the proof
+*     has to be a single map, the map has to carry its own `@context`, and
+*     the proof has to verify over the map exactly as it is served, with only
+*     its own proof removed, and be made with a key of the DID in the map's
+*     ID, as the map-local compound-proof profile requires.
+*  -  A map without a proof has to be a collection, a link, or a key, which
+*     FEP-ef61 does not require to be secured.  It is classified under its
+*     effective context, i.e., the `@context` values of its ancestors and
+*     itself, which therefore may only use the simple, preloaded contexts
+*     that the compound-proof policy accepts.
+*
+* Maps that merely refer to a portable object, i.e., have no member other
+* than `id` or `@id`, and maps with non-portable IDs, are neither checked nor
+* verified.  Every `@context` in the document, however, has to be simple, and
+* every portable object that the expanded document describes has to be
+* a map found this way, so that no context can hide a portable object from
+* this check, e.g., by aliasing `@id` or redefining `proof`.  The input must be a finite, already-materialized JSON tree, such
+* as the compact JSON-LD document that is about to be served.
+*
+* @param json The document to check.
+* @param options The options for verifying the proofs.  Proofs whose
+*                verification methods are not `did:key` DID URLs may make
+*                the document loader fetch DID documents.
+* @returns The result, which names the first refused map, if any.
+* @internal
+*/
+async function verifyServedPortableObjects(json, options = {}) {
+	json = JSON.parse(JSON.stringify(json));
+	const collected = collectServedPortableMaps(json);
+	if (!("maps" in collected)) return collected;
+	const maps = collected.maps;
+	const discovered = /* @__PURE__ */ new Map();
+	const ids = maps.map((candidate) => candidate.id);
+	const rootId = isJsonMap(json) ? [json.id, json["@id"]].find(isPortableIdValue) : void 0;
+	if (rootId != null) ids.push(rootId);
+	for (const id of ids) discovered.set(id, (discovered.get(id) ?? 0) + 1);
+	let hidden;
+	try {
+		hidden = findHiddenPortableObject(await jsonld.expand(json, { documentLoader: preloadedOnlyDocumentLoader }), discovered);
+	} catch {
+		return {
+			verified: false,
+			path: "",
+			id: "",
+			reason: "unsupportedContext"
+		};
+	}
+	if (hidden != null) return {
+		verified: false,
+		path: "",
+		id: hidden,
+		reason: "hiddenPortableObject"
+	};
+	for (const candidate of maps) {
+		const reason = await checkServedPortableMap(candidate, options);
+		if (reason != null) return {
+			verified: false,
+			path: candidate.path,
+			id: candidate.id,
+			reason
+		};
+	}
+	return { verified: true };
+}
+/**
+* Finds a portable object that an expanded JSON-LD document describes, i.e.,
+* a node with a portable `@id` and other members, more times than the given
+* numbers of maps found for its ID.
+*/
+function findHiddenPortableObject(expanded, discovered) {
+	const remaining = new Map(discovered);
+	const pending = [expanded];
+	while (pending.length > 0) {
+		const value = pending.pop();
+		if (Array.isArray(value)) {
+			pending.push(...value);
+			continue;
+		}
+		if (!isJsonMap(value)) continue;
+		const id = value["@id"];
+		if (isPortableIdValue(id) && Object.keys(value).some((key) => key !== "@id")) {
+			const count = remaining.get(id) ?? 0;
+			if (count < 1) return id;
+			remaining.set(id, count - 1);
+		}
+		pending.push(...Object.values(value));
+	}
+}
+/**
+* Checks whether a context uses only preloaded remote contexts and simple
+* term definitions, so that the context in effect for a map can be told from
+* the contexts of its ancestors.
+*/
+function isCheckableContext(context) {
+	return (Array.isArray(context) ? context : [context]).every((value) => typeof value === "string" ? Object.hasOwn(preloadedContexts, value) : !Array.isArray(value) && isSimpleContext(value));
+}
+/**
+* Checks whether every remote context that a context refers to is preloaded,
+* so that all of its definitions are known.
+*/
+function hasOnlyPreloadedRemoteContexts(context) {
+	return (Array.isArray(context) ? context : [context]).every((value) => typeof value === "string" ? Object.hasOwn(preloadedContexts, value) : !Array.isArray(value));
+}
+/**
+* Checks whether a map or any map below it, outside proof and context values,
+* has a portable `id` or `@id` and other members.
+*/
+function hasLiteralPortableObject(json) {
+	return findInJsonMaps(json, (map) => [map.id, map["@id"]].some(isPortableIdValue) && Object.keys(map).some((key) => key !== "id" && key !== "@id") ? true : void 0) ?? false;
+}
+function collectServedPortableMaps(json) {
+	const maps = [];
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [{
+		value: json,
+		path: "",
+		depth: 0,
+		contexts: []
+	}];
+	while (pending.length > 0) {
+		const { value, path, depth, contexts } = pending.pop();
+		if (typeof value !== "object" || value == null || seen.has(value)) continue;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (let index = value.length - 1; index >= 0; index--) pending.push({
+				value: value[index],
+				path: childPath(path, String(index)),
+				depth: depth + 1,
+				contexts
+			});
+			continue;
+		}
+		const map = value;
+		const hasContext = Object.hasOwn(map, "@context");
+		if (hasContext && !isCheckableContext(map["@context"])) {
+			if (hasOnlyPreloadedRemoteContexts(map["@context"]) && !hasLiteralPortableObject(map)) continue;
+			const id = [map.id, map["@id"]].find((v) => typeof v === "string");
+			return {
+				verified: false,
+				path,
+				id: typeof id === "string" ? id : "",
+				reason: "unsupportedContext"
+			};
+		}
+		const mapContexts = hasContext ? [...contexts, map["@context"]] : contexts;
+		const id = [map.id, map["@id"]].find(isPortableIdValue);
+		if (depth > 0 && id != null && Object.keys(map).some((key) => key !== "id" && key !== "@id")) maps.push({
+			path,
+			id,
+			map,
+			contexts: mapContexts
+		});
+		const keys = Object.keys(map);
+		for (let index = keys.length - 1; index >= 0; index--) {
+			const key = keys[index];
+			if (key === "proof" || key === "@context") continue;
+			pending.push({
+				value: map[key],
+				path: childPath(path, key),
+				depth: depth + 1,
+				contexts: mapContexts
+			});
+		}
+	}
+	maps.sort((left, right) => comparePaths(left.path, right.path));
+	return { maps };
+}
+async function checkServedPortableMap({ map, contexts }, options) {
+	if (Object.hasOwn(map, "proof")) {
+		if (!isJsonMap(map.proof)) return "unsupportedProofShape";
+		if (!Object.hasOwn(map, "@context")) return "missingContext";
+		try {
+			const policy = await verifyPortableObjectProofPolicy(map, await verifyMapLocalProof(map, options), options);
+			return policy.verified ? null : policy.reason.type;
+		} catch (error) {
+			if (error instanceof TypeError) return "invalidPortableObject";
+			throw error;
+		}
+	}
+	const flattened = contexts.flatMap((context) => Array.isArray(context) ? context : [context]);
+	if (flattened.length < 1 || !isSimpleContext(flattened)) return "unsupportedContext";
+	let expanded;
+	try {
+		expanded = await jsonld.expand({
+			...map,
+			"@context": flattened
+		}, { documentLoader: preloadedOnlyDocumentLoader });
+	} catch {
+		return "unsupportedContext";
+	}
+	if (expanded.length !== 1 || !isJsonMap(expanded[0])) return "invalidPortableObject";
+	const type = classifyFep2277CoreType(expanded[0]);
+	return UNSECURED_CORE_TYPES.has(type) ? null : "missingProof";
+}
 //#endregion
 //#region src/federation/inbox.ts
 async function routeActivity({ context: ctx, json, originalJson, normalizedActivity, ldSignatureVerified, activity, recipient, inboxListeners, inboxContextFactory, listenerInboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, meterProvider, tracerProvider, idempotencyStrategy }) {
@@ -3626,6 +3891,46 @@ function portableObjectInternalServerError(request) {
 		headers: { "Content-Type": "text/plain; charset=utf-8" }
 	});
 }
+/**
+* Checks the portable objects embedded in a portable collection or its page
+* that is about to be served against the FEP-ef61 proof policy.  See
+* `verifyServedPortableObjects()`.
+* @returns `true` if the collection can be served.
+*/
+async function verifyPortableCollection(jsonLd, context, portable) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"collection"
+	]);
+	try {
+		const result = await verifyServedPortableObjects(jsonLd, {
+			contextLoader: context.contextLoader,
+			documentLoader: context.documentLoader,
+			tracerProvider: context.tracerProvider,
+			meterProvider: context.meterProvider
+		});
+		if (result.verified) return true;
+		logger.error("Refusing to serve the portable collection {collectionId}, as the portable object {objectId} it embeds at {path} does not satisfy the FEP-ef61 proof policy: {reason}.  Embedded portable actors, activities, and objects need an Object Integrity Proof made with a key of the DID in their ID, and their own @context.", {
+			collectionId: portable.id.href,
+			objectId: result.id,
+			path: result.path,
+			reason: result.reason
+		});
+	} catch (error) {
+		logger.error("Failed to verify the portable objects embedded in the portable collection {collectionId}:\n{error}", {
+			collectionId: portable.id.href,
+			error
+		});
+	}
+	return false;
+}
+function respondWithPortableCollection(request, jsonLd) {
+	return new Response(request.method === "HEAD" ? null : JSON.stringify(jsonLd), { headers: {
+		"Content-Type": PORTABLE_OBJECT_CONTENT_TYPE,
+		Vary: "Accept"
+	} });
+}
 const BUILT_IN_COLLECTION_METRIC_KINDS = /* @__PURE__ */ new Set([
 	"inbox",
 	"outbox",
@@ -3663,13 +3968,13 @@ function recordCollectionMetrics(meterProvider, base, result, options = {}) {
 * @param parameters The parameters for handling the collection.
 * @returns A promise that resolves to an HTTP response.
 */
-async function handleCollection(request, { name: name$2, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, tracerProvider, meterProvider, onUnauthorized, onNotFound }) {
-	const spanName = name$2.trim().replace(/\s+/g, "_");
+async function handleCollection(request, { name: name$1, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, portable, tracerProvider, meterProvider, onUnauthorized, onNotFound }) {
+	const spanName = name$1.trim().replace(/\s+/g, "_");
 	tracerProvider = tracerProvider ?? trace.getTracerProvider();
 	const tracer = tracerProvider.getTracer(name, version);
 	const cursor = new URL(request.url).searchParams.get("cursor");
 	const metricBase = {
-		kind: getCollectionMetricKind(name$2),
+		kind: getCollectionMetricKind(name$1),
 		page: cursor != null,
 		dispatcher: "built_in"
 	};
@@ -3687,8 +3992,13 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 	};
 	try {
 		if (collectionCallbacks == null) return finish(await onNotFound(request), "not_found");
+		if (portable != null && collectionCallbacks.authorizePredicate != null) {
+			if (!await collectionCallbacks.authorizePredicate(context, identifier)) return finish(await onUnauthorized(request), "unauthorized");
+		}
 		let collection;
-		const baseUri = uriGetter(identifier);
+		const baseUri = portable?.id ?? uriGetter(identifier);
+		const pageBase = portable?.view ?? context.url;
+		const attribution = portable?.attribution ?? null;
 		if (cursor == null) {
 			const firstCursor = await collectionCallbacks.firstCursor?.(context, identifier);
 			const totalItems = filter == null ? await collectionCallbacks.counter?.(context, identifier) : void 0;
@@ -3710,7 +4020,7 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 							span.setStatus({ code: SpanStatusCode.ERROR });
 							return await onNotFound(request);
 						}
-						const items = filterCollectionItems(page.items, name$2, filterPredicate);
+						const items = filterCollectionItems(page.items, name$1, filterPredicate);
 						itemCount = items.length;
 						span.setAttribute("fedify.collection.items", itemCount);
 						return items;
@@ -3728,29 +4038,31 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 				if (itemsOrResponse instanceof Response) return finish(itemsOrResponse, "not_found");
 				collection = new OrderedCollection({
 					id: baseUri,
+					attribution,
 					totalItems: totalItemCount ?? null,
 					items: itemsOrResponse
 				});
 			} else {
 				const lastCursor = await collectionCallbacks.lastCursor?.(context, identifier);
-				const first = new URL(context.url);
+				const first = new URL(pageBase);
 				first.searchParams.set("cursor", firstCursor);
 				let last = null;
 				if (lastCursor != null) {
-					last = new URL(context.url);
+					last = new URL(pageBase);
 					last.searchParams.set("cursor", lastCursor);
 				}
 				collection = new OrderedCollection({
 					id: baseUri,
+					attribution,
 					totalItems: totalItemCount ?? null,
 					first,
 					last
 				});
 			}
 		} else {
-			const uri = new URL(baseUri);
+			const uri = new URL(portable == null ? baseUri : pageBase);
 			uri.searchParams.set("cursor", cursor);
-			const pageOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection_page ${name$2}`, {
+			const pageOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection_page ${name$1}`, {
 				kind: SpanKind.SERVER,
 				attributes: {
 					"activitypub.collection.id": uri.href,
@@ -3766,7 +4078,7 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 						span.setStatus({ code: SpanStatusCode.ERROR });
 						return await onNotFound(request);
 					}
-					const items = filterCollectionItems(page.items, name$2, filterPredicate);
+					const items = filterCollectionItems(page.items, name$1, filterPredicate);
 					itemCount = items.length;
 					span.setAttribute("fedify.collection.items", itemCount);
 					return {
@@ -3788,28 +4100,30 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 			const { items, prevCursor, nextCursor } = pageOrResponse;
 			let prev = null;
 			if (prevCursor != null) {
-				prev = new URL(context.url);
+				prev = new URL(pageBase);
 				prev.searchParams.set("cursor", prevCursor);
 			}
 			let next = null;
 			if (nextCursor != null) {
-				next = new URL(context.url);
+				next = new URL(pageBase);
 				next.searchParams.set("cursor", nextCursor);
 			}
-			const partOf = new URL(context.url);
+			const partOf = new URL(pageBase);
 			partOf.searchParams.delete("cursor");
 			collection = new OrderedCollectionPage({
 				id: uri,
+				attribution,
 				prev,
 				next,
 				items,
 				partOf
 			});
 		}
-		if (collectionCallbacks.authorizePredicate != null) {
+		if (portable == null && collectionCallbacks.authorizePredicate != null) {
 			if (!await collectionCallbacks.authorizePredicate(context, identifier)) return finish(await onUnauthorized(request), "unauthorized");
 		}
 		const jsonLd = await collection.toJsonLd(context);
+		if (portable != null) return await verifyPortableCollection(jsonLd, context, portable) ? finish(respondWithPortableCollection(request, jsonLd), "served") : finish(portableObjectInternalServerError(request), "error");
 		return finish(new Response(JSON.stringify(jsonLd), { headers: {
 			"Content-Type": "application/activity+json",
 			Vary: "Accept"
@@ -4857,19 +5171,11 @@ function recordDeferredPendingCollectionMetrics(error, result, response) {
 	pendingCollectionMetricRecorders.delete(error);
 	recorder?.(result, response);
 }
-async function _handleCustomCollection(request, { name, values, context, tracerProvider, meterProvider, collectionCallbacks: callbacks, filterPredicate }) {
+async function _handleCustomCollection(request, { name, values, context, tracerProvider, meterProvider, collectionCallbacks: callbacks, filterPredicate, portable }) {
 	verifyDefined(callbacks);
 	await authIfNeeded(context, values, callbacks);
 	const cursor = new URL(request.url).searchParams.get("cursor");
-	const handler = new CustomCollectionHandler(name, values, context, callbacks, tracerProvider, meterProvider, Collection, CollectionPage, filterPredicate).fetchCollection(cursor);
-	try {
-		const response = await handler.toJsonLd().then(respondAsActivity);
-		handler.recordPendingCollectionMetrics("served", response);
-		return response;
-	} catch (e) {
-		if (!deferPendingCollectionMetrics(e, (result, response) => handler.recordPendingCollectionMetrics(result, response))) handler.recordPendingCollectionMetrics("error");
-		throw e;
-	}
+	return await respondWithCustomCollection(request, new CustomCollectionHandler(name, values, context, callbacks, tracerProvider, meterProvider, Collection, CollectionPage, filterPredicate, portable).fetchCollection(cursor), context, portable);
 }
 /**
 * Handles an ordered collection request.
@@ -4883,13 +5189,19 @@ async function _handleCustomCollection(request, { name, values, context, tracerP
 * @since 1.8.0
 */
 const handleOrderedCollection = exceptWrapper(_handleOrderedCollection);
-async function _handleOrderedCollection(request, { name, values, context, tracerProvider, meterProvider, collectionCallbacks: callbacks, filterPredicate }) {
+async function _handleOrderedCollection(request, { name, values, context, tracerProvider, meterProvider, collectionCallbacks: callbacks, filterPredicate, portable }) {
 	verifyDefined(callbacks);
 	await authIfNeeded(context, values, callbacks);
 	const cursor = new URL(request.url).searchParams.get("cursor");
-	const handler = new CustomCollectionHandler(name, values, context, callbacks, tracerProvider, meterProvider, OrderedCollection, OrderedCollectionPage, filterPredicate).fetchCollection(cursor);
+	return await respondWithCustomCollection(request, new CustomCollectionHandler(name, values, context, callbacks, tracerProvider, meterProvider, OrderedCollection, OrderedCollectionPage, filterPredicate, portable).fetchCollection(cursor), context, portable);
+}
+async function respondWithCustomCollection(request, handler, context, portable) {
 	try {
-		const response = await handler.toJsonLd().then(respondAsActivity);
+		const jsonLd = await handler.toJsonLd();
+		let response;
+		if (portable == null) response = respondAsActivity(jsonLd);
+		else if (await verifyPortableCollection(jsonLd, context, portable)) response = respondWithPortableCollection(request, jsonLd);
+		else throw new PortableCollectionRefusedError();
 		handler.recordPendingCollectionMetrics("served", response);
 		return response;
 	} catch (e) {
@@ -4919,6 +5231,7 @@ var CustomCollectionHandler = class {
 	Collection;
 	CollectionPage;
 	filterPredicate;
+	portable;
 	/**
 	* The tracer for telemetry.
 	* @type {Tracer}
@@ -4955,8 +5268,8 @@ var CustomCollectionHandler = class {
 	* @param CollectionPage The CollectionPage constructor.
 	* @param filterPredicate Optional filter predicate for items.
 	*/
-	constructor(name$1, values, context, callbacks, tracerProvider = trace.getTracerProvider(), meterProvider, Collection, CollectionPage, filterPredicate) {
-		this.name = name$1;
+	constructor(name$2, values, context, callbacks, tracerProvider = trace.getTracerProvider(), meterProvider, Collection, CollectionPage, filterPredicate, portable) {
+		this.name = name$2;
 		this.values = values;
 		this.context = context;
 		this.callbacks = callbacks;
@@ -4965,9 +5278,14 @@ var CustomCollectionHandler = class {
 		this.Collection = Collection;
 		this.CollectionPage = CollectionPage;
 		this.filterPredicate = filterPredicate;
+		this.portable = portable;
 		this.name = this.name.trim().replace(/\s+/g, "_");
 		this.#tracer = this.tracerProvider.getTracer(name, version);
-		this.#id = new URL(this.context.url);
+		if (portable == null) this.#id = new URL(this.context.url);
+		else {
+			const cursor = this.context.url.searchParams.get("cursor");
+			this.#id = cursor == null ? new URL(portable.view) : appendCursorIfExists(portable.view, cursor);
+		}
 		this.#dispatcher = callbacks.dispatcher.bind(callbacks);
 	}
 	/**
@@ -5018,6 +5336,7 @@ var CustomCollectionHandler = class {
 		this.recordPendingCollectionItemCount(true, items.length);
 		return {
 			id,
+			attribution: this.portable?.attribution ?? null,
 			partOf,
 			items,
 			prev: this.appendToUrl(prevCursor),
@@ -5039,6 +5358,7 @@ var CustomCollectionHandler = class {
 		});
 		return {
 			id: this.#id,
+			attribution: this.portable?.attribution ?? null,
 			first: this.appendToUrl(firstCursor),
 			last: this.appendToUrl(lastCursor),
 			totalItems
@@ -5055,6 +5375,7 @@ var CustomCollectionHandler = class {
 		this.recordPendingCollectionItemCount(false, items.length);
 		return {
 			id: this.#id,
+			attribution: this.portable?.attribution ?? null,
 			totalItems,
 			items
 		};
@@ -5172,7 +5493,7 @@ var CustomCollectionHandler = class {
 	* @returns The URL with cursor appended, or null if cursor is null/undefined.
 	*/
 	appendToUrl(cursor) {
-		return appendCursorIfExists(this.context.url, cursor);
+		return appendCursorIfExists(this.portable?.view ?? this.context.url, cursor);
 	}
 	/**
 	* Gets the stored collection or collection page.
@@ -5249,6 +5570,12 @@ function exceptWrapper(handler) {
 					recordCollectionRequest(meterProvider, collectionAttributes(metricBase, "not_found", response));
 					return response;
 				}
+				case PortableCollectionRefusedError: {
+					const response = portableObjectInternalServerError(request);
+					recordDeferredPendingCollectionMetrics(error, "error", response);
+					recordCollectionRequest(meterProvider, collectionAttributes(metricBase, "error", response));
+					return response;
+				}
 				case UnauthorizedError: {
 					const response = await onUnauthorized(request);
 					recordDeferredPendingCollectionMetrics(error, "unauthorized", response);
@@ -5345,6 +5672,16 @@ var UnauthorizedError = class extends HandlerError {
 	}
 };
 /**
+* Error thrown when a portable collection is not served because it embeds
+* portable objects that do not satisfy the FEP-ef61 proof policy.
+* @since 2.4.0
+*/
+var PortableCollectionRefusedError = class extends HandlerError {
+	constructor() {
+		super("The portable collection embeds unverifiable portable objects.");
+	}
+};
+/**
 * Responds with the given object in JSON-LD format.
 *
 * @param object The object to respond with.
@@ -5714,6 +6051,100 @@ function serializeDataPointType(dataPointType) {
 	}
 }
 //#endregion
+//#region src/federation/portable-collection.ts
+/**
+* The query parameters of a gateway request for a portable collection that
+* do not select a view of the collection: the page cursor, and FEP-ef61
+* location hints (`@gateway`, and the legacy `gateways`).
+*/
+const NON_VIEW_PARAMETERS = /* @__PURE__ */ new Set([
+	"cursor",
+	"@gateway",
+	"gateways"
+]);
+/**
+* Checks that a collection requested through the FEP-ef61 gateway endpoint
+* belongs to a portable actor under the requested DID, and determines
+* the collection's ID from the actor.
+*
+* Collection dispatchers return items, not documents with IDs, so unlike
+* object dispatchers, there is nothing else to tell whether the requested
+* DID controls the collection.
+*
+* @param actor The actor that owns the collection according to
+*              the application, dispatched without the portable request,
+*              or `null` if there is none.
+* @param options The requested DID, and either the requested collection's
+*                canonical ID and the actor's property that has to refer to
+*                it (for the built-in collections of an actor), or
+*                the requested collection's portable ID (for a custom
+*                collection, whose ID has the same form as the actor's).
+* @returns The resolution.
+*/
+function resolvePortableCollectionOwner(actor, options) {
+	if (!isActor(actor)) return {
+		status: "rejected",
+		reason: "notFound"
+	};
+	const ownerId = actor.id;
+	const did = ownerId == null || !isPortableId(ownerId) ? null : getPortableDid(ownerId);
+	if (ownerId == null || did == null) return {
+		status: "rejected",
+		reason: "notPortable"
+	};
+	if (did !== options.authority) return {
+		status: "rejected",
+		reason: "authorityMismatch"
+	};
+	if ("portableId" in options) return {
+		status: "accepted",
+		ownerId,
+		collectionId: getCustomCollectionId(ownerId, actor, options.portableId)
+	};
+	const property = options.property(actor);
+	if (property == null || getCanonicalPortableId(property) !== options.canonicalId) return {
+		status: "rejected",
+		reason: "collectionMismatch"
+	};
+	const collectionId = new URL(property);
+	collectionId.search = "";
+	collectionId.hash = "";
+	return {
+		status: "accepted",
+		ownerId,
+		collectionId
+	};
+}
+/**
+* Gets the ID of a custom portable collection in the same form as its owner's
+* ID: a portable ID if the owner has one, or otherwise a compatible identifier
+* on the owner's first gateway, as FEP-ef61 requires of publishers.
+*/
+function getCustomCollectionId(ownerId, owner, portableId) {
+	if (isPortableUri(ownerId)) return portableId;
+	const gateway = owner.gateways[0];
+	if (gateway == null || !isGatewayUrl(gateway)) return portableId;
+	try {
+		return toCompatibleEf61Id(portableId, gateway);
+	} catch (error) {
+		if (error instanceof TypeError) return portableId;
+		throw error;
+	}
+}
+/**
+* Builds the URI that the pages of a portable collection are relative to:
+* the collection's ID with the query parameters of the requested view, e.g.,
+* a filter, but without the page cursor and location hints.
+* @param collectionId The ID of the collection.
+* @param requestUrl The URL of the gateway request.
+* @returns The view URI.
+*/
+function buildPortableCollectionView(collectionId, requestUrl) {
+	const view = new URL(collectionId);
+	for (const [name, value] of requestUrl.searchParams) if (!NON_VIEW_PARAMETERS.has(name)) view.searchParams.append(name, value);
+	return view;
+}
+//#endregion
 //#region src/federation/outgoing-proof.ts
 function formatKeyIds(candidates) {
 	return candidates.map((c) => c.verificationMethod.href).join(", ");
@@ -8175,12 +8606,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				onNotFound
 			});
 			case "followers": {
-				let baseUrl = url.searchParams.get("base-url");
-				if (baseUrl != null) try {
-					baseUrl = `${new URL(baseUrl).origin}/`;
-				} catch {
-					baseUrl = null;
-				}
+				const baseUrl = getFollowersBaseUrl(url);
 				return await handleCollection(request, {
 					name: "followers",
 					identifier: route.values.identifier,
@@ -8191,7 +8617,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 					},
 					context,
 					filter: baseUrl != null ? new URL(baseUrl) : void 0,
-					filterPredicate: baseUrl != null ? ((i) => (i instanceof URL ? i.href : i.id?.href ?? "").startsWith(baseUrl)) : void 0,
+					filterPredicate: baseUrl != null ? getFollowersFilterPredicate(baseUrl) : void 0,
 					collectionCallbacks: this.followersCallbacks,
 					tracerProvider: this.tracerProvider,
 					meterProvider: this._meterProvider,
@@ -8285,17 +8711,30 @@ var FederationImpl = class extends FederationBuilderImpl {
 		}
 		const route = this.router.route(portable.path);
 		const isActor = route != null && (route.name === "actor" || route.name.startsWith("actorAlias:"));
-		if (route == null || !isActor && !route.name.startsWith("object:")) {
+		const collectionRoute = route == null ? void 0 : getCollectionMetricRoute(route.name.replace(/:.*$/, ""));
+		if (route == null || !isActor && !route.name.startsWith("object:") && collectionRoute == null) {
 			metricState.endpoint = "not_found";
 			return await onNotFound(request);
 		}
 		metricState.routeTemplate = PORTABLE_GATEWAY_ROUTE_PREFIX + route.template;
-		metricState.endpoint = isActor ? "actor" : "object";
+		metricState.endpoint = getEndpointCategory(route.name);
 		span.updateName(`${request.method} ${metricState.routeTemplate}`);
 		if (!acceptsJsonLd(request)) {
 			metricState.endpoint = "not_acceptable";
-			return await onNotAcceptable(request);
+			const response = await onNotAcceptable(request);
+			if (collectionRoute != null) recordCollectionRequest(this._meterProvider, {
+				...collectionRoute,
+				page: new URL(request.url).searchParams.get("cursor") != null,
+				result: "not_acceptable",
+				statusCode: response.status
+			});
+			return response;
 		}
+		if (collectionRoute != null) return await this.#fetchPortableCollection(request, portable, route, {
+			onNotFound,
+			onUnauthorized,
+			contextData
+		});
 		if (isActor) {
 			const identifier = route.name.startsWith("actorAlias:") ? route.name.substring(11) : route.values.identifier;
 			const context = this.#createContext(request, contextData, {
@@ -8334,6 +8773,108 @@ var FederationImpl = class extends FederationBuilderImpl {
 			onNotFound
 		});
 	}
+	async #fetchPortableCollection(request, portable, route, { onNotFound, onUnauthorized, contextData }) {
+		const logger = getLogger([
+			"fedify",
+			"federation",
+			"collection"
+		]);
+		const url = new URL(request.url);
+		const { authority } = portable.portableRequest;
+		const ownerContext = this.#createContext(request, contextData);
+		const context = this.#createContext(request, contextData, { portableRequest: portable.portableRequest });
+		const reject = async (reason, identifier) => {
+			logger.debug("Not serving the portable collection {collection} of the actor {identifier}: {reason}.", {
+				collection: portable.canonicalId,
+				identifier,
+				reason
+			});
+			return await onNotFound(request);
+		};
+		const routeName = route.name.replace(/:.*$/, "");
+		if (routeName === "collection" || routeName === "orderedCollection") {
+			const name = route.name.replace(/^(?:ordered)?[cC]ollection:/, "");
+			const callbacks = this.collectionCallbacks[name];
+			if (callbacks == null) return await onNotFound(request);
+			const mapper = callbacks.portableOwnerMapper;
+			if (mapper == null) return await reject("noPortableOwnerMapper");
+			const identifier = await mapper(ownerContext, route.values);
+			if (identifier == null) return await reject("notPortable");
+			const resolution = resolvePortableCollectionOwner(await this.actorCallbacks?.dispatcher?.(ownerContext, identifier), {
+				authority,
+				portableId: portable.portableRequest.id
+			});
+			if (resolution.status === "rejected") return await reject(resolution.reason, identifier);
+			const view = buildPortableCollectionView(resolution.collectionId, url);
+			return await (routeName === "collection" ? handleCustomCollection : handleOrderedCollection)(request, {
+				name,
+				context,
+				values: route.values,
+				collectionCallbacks: callbacks,
+				portable: {
+					id: view,
+					view,
+					attribution: resolution.ownerId
+				},
+				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
+				onUnauthorized,
+				onNotFound
+			});
+		}
+		const identifier = route.values.identifier;
+		const serve = async (name, callbacks, property, filter) => {
+			if (callbacks == null) return await onNotFound(request);
+			const resolution = resolvePortableCollectionOwner(await this.actorCallbacks?.dispatcher?.(ownerContext, identifier), {
+				authority,
+				canonicalId: portable.canonicalId,
+				property
+			});
+			if (resolution.status === "rejected") return await reject(resolution.reason, identifier);
+			const id = new URL(resolution.collectionId);
+			if (filter != null) id.searchParams.set(...filter.parameter);
+			const view = buildPortableCollectionView(resolution.collectionId, url);
+			if (routeName === "followers") {
+				view.searchParams.delete("base-url");
+				if (filter != null) view.searchParams.set(...filter.parameter);
+			}
+			return await handleCollection(request, {
+				name,
+				identifier,
+				uriGetter: () => id,
+				context,
+				filter: filter?.value,
+				filterPredicate: filter?.predicate,
+				collectionCallbacks: callbacks,
+				portable: {
+					id,
+					view,
+					attribution: resolution.ownerId
+				},
+				tracerProvider: this.tracerProvider,
+				meterProvider: this._meterProvider,
+				onUnauthorized,
+				onNotFound
+			});
+		};
+		switch (routeName) {
+			case "outbox": return await serve("outbox", this.outboxCallbacks, (a) => a.outboxId);
+			case "inbox": return await serve("inbox", this.inboxCallbacks, (a) => a.inboxId);
+			case "following": return await serve("following", this.followingCallbacks, (a) => a.followingId);
+			case "followers": {
+				const baseUrl = getFollowersBaseUrl(url);
+				return await serve("followers", this.followersCallbacks, (a) => a.followersId, baseUrl == null ? void 0 : {
+					value: new URL(baseUrl),
+					predicate: getFollowersFilterPredicate(baseUrl),
+					parameter: ["base-url", baseUrl]
+				});
+			}
+			case "liked": return await serve("liked", this.likedCallbacks, (a) => a.likedId);
+			case "featured": return await serve("featured", this.featuredCallbacks, (a) => a.featuredId);
+			case "featuredTags": return await serve("featured tags", this.featuredTagsCallbacks, (a) => a.featuredTagsId);
+		}
+		return await onNotFound(request);
+	}
 	async #handleInbox(request, { recipient, context, contextData, onNotFound, portableInbox }) {
 		if (!this.manuallyStartQueue) this._startQueueInternal(contextData);
 		const inboxContextFactory = context.toInboxContext.bind(context);
@@ -8520,6 +9061,41 @@ var FederationImpl = class extends FederationBuilderImpl {
 };
 const PORTABLE_GATEWAY_ROUTE_PREFIX = "/.well-known/apgateway/{did}";
 /**
+* Gets the origin that a followers collection request filters followers by,
+* i.e., its normalized `base-url` query parameter (FEP-8fcf).
+* @returns The origin with a trailing slash, or `null` if the parameter is
+*          missing or invalid.
+*/
+function getFollowersBaseUrl(url) {
+	const baseUrl = url.searchParams.get("base-url");
+	if (baseUrl == null) return null;
+	try {
+		return `${new URL(baseUrl).origin}/`;
+	} catch {
+		return null;
+	}
+}
+function getFollowersFilterPredicate(baseUrl) {
+	return (i) => (i instanceof URL ? i.href : i.id?.href ?? "").startsWith(baseUrl);
+}
+const ACTOR_COLLECTION_ROUTE_ERRORS = {
+	outbox: "No outbox dispatcher registered.",
+	following: "No following collection path registered.",
+	followers: "No followers collection path registered.",
+	liked: "No liked collection path registered.",
+	featured: "No featured collection path registered.",
+	featuredTags: "No featured tags collection path registered."
+};
+/**
+* Checks that the authority of a portable ID to build is given, either
+* explicitly or by the FEP-ef61 gateway request being handled.
+* @throws {TypeError} If the authority is missing.
+*/
+function requirePortableAuthority(authority) {
+	if (authority == null) throw new TypeError("The authority of a portable ID is required outside an FEP-ef61 gateway request.");
+	return authority;
+}
+/**
 * Removes the body of a response to a `HEAD` request.
 * @param request The request.
 * @param response The response to the request.
@@ -8698,8 +9274,7 @@ var ContextImpl = class ContextImpl {
 	}
 	getPortableActorUri(identifier, authority) {
 		const path = this.#getActorPath(identifier);
-		if (authority == null) throw new TypeError("The authority of a portable ID is required outside an FEP-ef61 gateway request.");
-		return buildPortableUri(authority, path);
+		return buildPortableUri(requirePortableAuthority(authority), path);
 	}
 	#getActorPath(identifier) {
 		const path = this.federation.router.build(`actorAlias:${identifier}`, {}) ?? this.federation.router.build("actor", { identifier });
@@ -8711,8 +9286,7 @@ var ContextImpl = class ContextImpl {
 	}
 	getPortableObjectUri(cls, values, authority) {
 		const path = this.#getObjectPath(cls, values);
-		if (authority == null) throw new TypeError("The authority of a portable ID is required outside an FEP-ef61 gateway request.");
-		return buildPortableUri(authority, path);
+		return buildPortableUri(requirePortableAuthority(authority), path);
 	}
 	#getObjectPath(cls, values) {
 		const callbacks = this.federation.objectCallbacks[cls.typeId.href];
@@ -8722,10 +9296,17 @@ var ContextImpl = class ContextImpl {
 		if (path == null) throw new RouterError("No object dispatcher registered.");
 		return path;
 	}
+	#getActorCollectionPath(route, identifier) {
+		const path = this.federation.router.build(route, { identifier });
+		if (path == null) throw new RouterError(ACTOR_COLLECTION_ROUTE_ERRORS[route]);
+		return path;
+	}
 	getOutboxUri(identifier) {
-		const path = this.federation.router.build("outbox", { identifier });
-		if (path == null) throw new RouterError("No outbox dispatcher registered.");
-		return new URL(path, this.canonicalOrigin);
+		return new URL(this.#getActorCollectionPath("outbox", identifier), this.canonicalOrigin);
+	}
+	getPortableOutboxUri(identifier, authority) {
+		const path = this.#getActorCollectionPath("outbox", identifier);
+		return buildPortableUri(requirePortableAuthority(authority), path);
 	}
 	getMediaUploaderUri(identifier) {
 		const path = this.federation.router.build("mediaUploader", { identifier });
@@ -8745,39 +9326,53 @@ var ContextImpl = class ContextImpl {
 	getPortableInboxUri(identifier, authority) {
 		const path = this.federation.router.build("inbox", { identifier });
 		if (path == null) throw new RouterError("No inbox path registered.");
-		if (authority == null) throw new TypeError("The authority of a portable ID is required outside an FEP-ef61 gateway request.");
-		return buildPortableUri(authority, path);
+		return buildPortableUri(requirePortableAuthority(authority), path);
 	}
 	getFollowingUri(identifier) {
-		const path = this.federation.router.build("following", { identifier });
-		if (path == null) throw new RouterError("No following collection path registered.");
-		return new URL(path, this.canonicalOrigin);
+		return new URL(this.#getActorCollectionPath("following", identifier), this.canonicalOrigin);
+	}
+	getPortableFollowingUri(identifier, authority) {
+		const path = this.#getActorCollectionPath("following", identifier);
+		return buildPortableUri(requirePortableAuthority(authority), path);
 	}
 	getFollowersUri(identifier) {
-		const path = this.federation.router.build("followers", { identifier });
-		if (path == null) throw new RouterError("No followers collection path registered.");
-		return new URL(path, this.canonicalOrigin);
+		return new URL(this.#getActorCollectionPath("followers", identifier), this.canonicalOrigin);
+	}
+	getPortableFollowersUri(identifier, authority) {
+		const path = this.#getActorCollectionPath("followers", identifier);
+		return buildPortableUri(requirePortableAuthority(authority), path);
 	}
 	getLikedUri(identifier) {
-		const path = this.federation.router.build("liked", { identifier });
-		if (path == null) throw new RouterError("No liked collection path registered.");
-		return new URL(path, this.canonicalOrigin);
+		return new URL(this.#getActorCollectionPath("liked", identifier), this.canonicalOrigin);
+	}
+	getPortableLikedUri(identifier, authority) {
+		const path = this.#getActorCollectionPath("liked", identifier);
+		return buildPortableUri(requirePortableAuthority(authority), path);
 	}
 	getFeaturedUri(identifier) {
-		const path = this.federation.router.build("featured", { identifier });
-		if (path == null) throw new RouterError("No featured collection path registered.");
-		return new URL(path, this.canonicalOrigin);
+		return new URL(this.#getActorCollectionPath("featured", identifier), this.canonicalOrigin);
+	}
+	getPortableFeaturedUri(identifier, authority) {
+		const path = this.#getActorCollectionPath("featured", identifier);
+		return buildPortableUri(requirePortableAuthority(authority), path);
 	}
 	getFeaturedTagsUri(identifier) {
-		const path = this.federation.router.build("featuredTags", { identifier });
-		if (path == null) throw new RouterError("No featured tags collection path registered.");
-		return new URL(path, this.canonicalOrigin);
+		return new URL(this.#getActorCollectionPath("featuredTags", identifier), this.canonicalOrigin);
+	}
+	getPortableFeaturedTagsUri(identifier, authority) {
+		const path = this.#getActorCollectionPath("featuredTags", identifier);
+		return buildPortableUri(requirePortableAuthority(authority), path);
 	}
 	getCollectionUri(name, values) {
 		const path = this.federation.getCollectionPath(name, values);
 		if (path === null) throw new RouterError(`No collection dispatcher registered for "${String(name)}".`);
 		return new URL(path, this.canonicalOrigin);
 	}
+	getPortableCollectionUri(name, values, authority) {
+		const path = this.federation.getCollectionPath(name, values);
+		if (path === null) throw new RouterError(`No collection dispatcher registered for "${String(name)}".`);
+		return buildPortableUri(requirePortableAuthority(authority), path);
+	}
 	parseUri(uri) {
 		if (uri == null) return null;
 		if (uri.origin !== this.origin && uri.origin !== this.canonicalOrigin) return null;
@@ -9357,6 +9952,27 @@ var RequestContextImpl = class RequestContextImpl extends ContextImpl {
 	getPortableInboxUri(identifier, authority) {
 		return super.getPortableInboxUri(identifier, authority ?? this.portableRequest?.authority);
 	}
+	getPortableOutboxUri(identifier, authority) {
+		return super.getPortableOutboxUri(identifier, authority ?? this.portableRequest?.authority);
+	}
+	getPortableFollowingUri(identifier, authority) {
+		return super.getPortableFollowingUri(identifier, authority ?? this.portableRequest?.authority);
+	}
+	getPortableFollowersUri(identifier, authority) {
+		return super.getPortableFollowersUri(identifier, authority ?? this.portableRequest?.authority);
+	}
+	getPortableLikedUri(identifier, authority) {
+		return super.getPortableLikedUri(identifier, authority ?? this.portableRequest?.authority);
+	}
+	getPortableFeaturedUri(identifier, authority) {
+		return super.getPortableFeaturedUri(identifier, authority ?? this.portableRequest?.authority);
+	}
+	getPortableFeaturedTagsUri(identifier, authority) {
+		return super.getPortableFeaturedTagsUri(identifier, authority ?? this.portableRequest?.authority);
+	}
+	getPortableCollectionUri(name, values, authority) {
+		return super.getPortableCollectionUri(name, values, authority ?? this.portableRequest?.authority);
+	}
 	async getActor(identifier, options) {
 		if (this.federation.actorCallbacks == null || this.federation.actorCallbacks.dispatcher == null) throw new Error("No actor dispatcher registered.");
 		if (this.#invokedFromActorDispatcher != null) getLogger([