@fedify/fedify 2.4.0-dev.2071 → 2.4.0-dev.2077

package/dist/{middleware-CAObohey.js → middleware-SSfryVzY.js}

@@ -2,10 +2,10 @@ 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 recordCollectionPageItems, C as hasSignature, D as signJsonLd, E as isInvalidUrlTypeError, H as hasPortableActor, J as getRemoteHost, K as getDurationMs, L as importJwk, M as exportJwk, O as verifyCompactJsonLd, Q as recordCollectionDispatchDuration, R as validateCryptoKey, S as getNormalizationContextLoader, T as isClearlyMalformedContextReference, U as isCompatibleKeyId, V as getGatewayKeyBase, W as isPortableUri, X as isAbortError, Y as instrumentDocumentLoader, Z as recordCircuitBreakerStateChange, _ as assertSafeJsonLd, a as verifyRequestDetailed, at as recordOutboxActivity, c as hasProofLike, ct as registerQueueDepthGauge, d as verifyObject, et as recordCollectionRequest, f as verifyPortableObjectProof, g as InvalidContextReferenceError, ht as version, i as verifyRequest, it as recordInboxActivity, j as wrapContextLoaderForJsonLd, l as signObject, lt as normalizeOutgoingActivityJsonLd, mt as name, n as parseRfc9421SignatureInput, ot as recordOutboxEnqueue, p as verifyPortableObjectProofPolicy, q as getFederationMetrics, rt as recordFanoutRecipients, st as recordWebFingerHandle, t as doubleKnock, tt as recordCollectionTotalItems, u as verifyMapLocalProof, ut as formatAcceptSignature, w as hasSignatureLike, x as detachSignature, y as compactJsonLd } from "./http-BoWBwC0g.js";
+import { $ as recordCollectionPageItems, C as hasSignature, D as signJsonLd, E as isInvalidUrlTypeError, H as hasPortableActor, J as getRemoteHost, K as getDurationMs, L as importJwk, M as exportJwk, O as verifyCompactJsonLd, Q as recordCollectionDispatchDuration, R as validateCryptoKey, S as getNormalizationContextLoader, T as isClearlyMalformedContextReference, U as isCompatibleKeyId, V as getGatewayKeyBase, W as isPortableUri, X as isAbortError, Y as instrumentDocumentLoader, Z as recordCircuitBreakerStateChange, _ as assertSafeJsonLd, a as verifyRequestDetailed, at as recordOutboxActivity, c as hasProofLike, ct as registerQueueDepthGauge, d as verifyObject, et as recordCollectionRequest, f as verifyPortableObjectProof, g as InvalidContextReferenceError, ht as version, i as verifyRequest, it as recordInboxActivity, j as wrapContextLoaderForJsonLd, l as signObject, lt as normalizeOutgoingActivityJsonLd, mt as name, n as parseRfc9421SignatureInput, ot as recordOutboxEnqueue, p as verifyPortableObjectProofPolicy, q as getFederationMetrics, rt as recordFanoutRecipients, st as recordWebFingerHandle, t as doubleKnock, tt as recordCollectionTotalItems, u as verifyMapLocalProof, ut as formatAcceptSignature, w as hasSignatureLike, x as detachSignature, y as compactJsonLd } from "./http-aqh3yFdM.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 getKeyOwner, t as doesActorOwnKey } from "./owner-1TFakcTF.js";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-BdnmnAVc.js";
+import { n as getKeyOwner, t as doesActorOwnKey } from "./owner-jH1z_YfD.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./kv-cache-Y6SDRSX6.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";
@@ -3242,7 +3242,7 @@ async function handleInbox(request, options) {
 * @returns A promise that resolves to an HTTP response.
 */
 async function handleInboxInternal(request, parameters, span) {
-	const { recipient, context: ctx, inboxContextFactory, kv, kvPrefixes, publicKeyTtl, queue, actorDispatcher, inboxListeners, inboxErrorHandler, unverifiedActivityHandler, onNotFound, signatureTimeWindow, skipSignatureVerification, inboxChallengePolicy, meterProvider, tracerProvider } = parameters;
+	const { recipient, context: ctx, inboxContextFactory, kv, kvPrefixes, publicKeyTtl, queue, actorDispatcher, inboxListeners, inboxErrorHandler, unverifiedActivityHandler, onNotFound, signatureTimeWindow, skipSignatureVerification, inboxChallengePolicy, meterProvider, tracerProvider, portableInbox } = parameters;
 	const logger = getLogger([
 		"fedify",
 		"federation",
@@ -3255,7 +3255,7 @@ async function handleInboxInternal(request, parameters, span) {
 			message: "Actor dispatcher is not set."
 		});
 		return await onNotFound(request);
-	} else if (recipient != null) {
+	} else if (recipient != null && portableInbox == null) {
 		const actor = await actorDispatcher(ctx, recipient);
 		if (actor == null || actor instanceof Tombstone) {
 			logger.error("Actor {recipient} not found.", { recipient });
@@ -3666,8 +3666,9 @@ async function handleInboxInternal(request, parameters, span) {
 		});
 	}
 	if (!skipSignatureVerification) {
-		if (inspectCompoundPortableObjectApplicability(json, INBOX_COMPOUND_PROOF_LIMITS) !== "absent") {
-			const compoundProof = await verifyCompoundPortableObjectProofs(json, INBOX_COMPOUND_PROOF_LIMITS, {
+		const compoundJson = Array.isArray(json) ? json : jsonWithoutSig;
+		if (inspectCompoundPortableObjectApplicability(compoundJson, INBOX_COMPOUND_PROOF_LIMITS) !== "absent") {
+			const compoundProof = await verifyCompoundPortableObjectProofs(compoundJson, INBOX_COMPOUND_PROOF_LIMITS, {
 				documentLoader: ctx.documentLoader,
 				keyCache,
 				meterProvider,
@@ -3717,6 +3718,19 @@ async function handleInboxInternal(request, parameters, span) {
 		tracerProvider,
 		idempotencyStrategy: parameters.idempotencyStrategy
 	});
+	if (portableInbox != null && activity.id != null && PORTABLE_INBOX_FORWARDABLE_RESULTS.has(routeResult)) if (skipSignatureVerification || !(ldSigVerified || proofVerified)) logger.debug("Not forwarding activity {activityId} to the other gateways of the portable inbox {inbox}, as it is not authenticated by its own proof.", {
+		activityId: activity.id.href,
+		inbox: portableInbox.recipient.canonicalInboxId
+	});
+	else try {
+		await portableInbox.forward(json, activity.id, getTypeId(activity).href);
+	} catch (error) {
+		logger.error("Failed to forward activity {activityId} to the other gateways of the portable inbox {inbox}:\n{error}", {
+			activityId: activity.id.href,
+			inbox: portableInbox.recipient.canonicalInboxId,
+			error
+		});
+	}
 	if (routeResult === "alreadyProcessed") return new Response(`Activity <${activity.id}> has already been processed.`, {
 		status: 202,
 		headers: { "Content-Type": "text/plain; charset=utf-8" }
@@ -3742,6 +3756,12 @@ async function handleInboxInternal(request, parameters, span) {
 		headers: { "Content-Type": "text/plain; charset=utf-8" }
 	});
 }
+const PORTABLE_INBOX_FORWARDABLE_RESULTS = /* @__PURE__ */ new Set([
+	"success",
+	"enqueued",
+	"alreadyProcessed",
+	"unsupportedActivity"
+]);
 /**
 * Handles a custom collection request.
 * @template TItem The type of items in the collection.
@@ -4533,7 +4553,11 @@ async function sendActivityInternal({ activity, activityId, activityType, keys,
 		rsaKey = key;
 		break;
 	}
-	if (rsaKey == null) logger.warn("No supported key found to sign the request to {inbox}.  The request will be sent without a signature.  In order to sign the request, at least one RSASSA-PKCS1-v1_5 key must be provided.", {
+	if (rsaKey == null && keys.length < 1) logger.debug("Sending the activity {activityId} to {inbox} without a signature.", {
+		activityId,
+		inbox: inbox.href
+	});
+	else if (rsaKey == null) logger.warn("No supported key found to sign the request to {inbox}.  The request will be sent without a signature.  In order to sign the request, at least one RSASSA-PKCS1-v1_5 key must be provided.", {
 		inbox: inbox.href,
 		keys: keys.map((pair) => ({
 			keyId: pair.keyId.href,
@@ -4875,6 +4899,251 @@ function serializeDataPointType(dataPointType) {
 	}
 }
 //#endregion
+//#region src/federation/portable-inbox.ts
+const MAX_TIMEOUT_MS = 2 ** 31 - 1;
+/**
+* Fills in the defaults of {@link PortableInboxForwardingOptions} and
+* validates them.
+* @param options The options.
+* @returns The resolved options.
+* @throws {RangeError} If `maxTargets` is not a non-negative integer, if `ttl`
+*                      is not positive, if `deadline` is negative or longer
+*                      than 2,147,483,647 milliseconds (about 24.8 days), or
+*                      if either duration has calendar units, i.e., weeks,
+*                      months, or years, whose length depends on the date.
+*/
+function resolvePortableInboxForwardingOptions(options = {}) {
+	const maxTargets = options.maxTargets ?? 10;
+	if (!Number.isInteger(maxTargets) || maxTargets < 0) throw new RangeError("portableInboxForwarding.maxTargets must be a non-negative integer.");
+	const ttl = Temporal.Duration.from(options.ttl ?? { days: 30 });
+	if (ttl.total("millisecond") <= 0) throw new RangeError("portableInboxForwarding.ttl must be positive.");
+	const deadline = Temporal.Duration.from(options.deadline ?? { seconds: 10 });
+	const deadlineMs = deadline.total("millisecond");
+	if (deadlineMs < 0 || deadlineMs > MAX_TIMEOUT_MS) throw new RangeError(`portableInboxForwarding.deadline must be between 0 and ${MAX_TIMEOUT_MS} milliseconds.`);
+	return {
+		maxTargets,
+		ttl,
+		deadline
+	};
+}
+/**
+* Decides whether this server accepts a delivery to a portable inbox on behalf
+* of the given actor, which the actor dispatcher returned for the identifier
+* in the requested inbox path.
+*
+* The actor document comes from the application, so it is trusted as is and
+* its proof is not verified here.
+* @param actor The actor the actor dispatcher returned.
+* @param options The requested DID, the canonical form of the requested inbox
+*                ID, and the origin of this server.
+* @returns The resolution.
+*/
+function resolvePortableInboxRecipient(actor, { authority, canonicalInboxId, localOrigin }) {
+	if (actor == null) return {
+		status: "rejected",
+		reason: "notFound"
+	};
+	const id = actor.id;
+	if (id == null || id.protocol !== "ap:" && id.protocol !== "ap+ef61:") return {
+		status: "rejected",
+		reason: "notPortable"
+	};
+	if (!isSameAuthority(id, authority)) return {
+		status: "rejected",
+		reason: "authorityMismatch"
+	};
+	const inboxId = actor.inboxId;
+	if (inboxId == null || canonicalize(inboxId) !== canonicalInboxId) return {
+		status: "rejected",
+		reason: "inboxMismatch"
+	};
+	const gateways = actor.gateways;
+	if (!gateways.some((g) => isGatewayUrl(g) && g.origin === localOrigin)) return {
+		status: "rejected",
+		reason: "notGateway"
+	};
+	return {
+		status: "accepted",
+		recipient: {
+			inboxId,
+			canonicalInboxId,
+			gateways
+		}
+	};
+}
+function isSameAuthority(id, authority) {
+	try {
+		return getFe34Origin(id) === authority;
+	} catch (error) {
+		if (error instanceof TypeError) return false;
+		throw error;
+	}
+}
+function canonicalize(iri) {
+	try {
+		return canonicalizePortableUri(typeof iri === "string" ? iri : formatIri(iri));
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+}
+/**
+* Forwards an activity received in a portable inbox to the inboxes of the same
+* portable actor on its other gateways, as FEP-ef61 recommends.
+*
+* FEP-ef61 forbids forwarding an activity from an inbox more than once, so
+* each target gateway is claimed with an atomic compare-and-swap before the
+* activity is handed off, and a claim is never released, even if the hand-off
+* fails, since a failed hand-off does not prove that nothing was delivered.
+* Forwarding is therefore best effort.  Without {@link KvStore.cas}, nothing is
+* forwarded.
+*
+* Forwarded requests are not signed with HTTP Signatures; the receiving
+* gateways authenticate the activity by its own proof.
+* @param parameters The parameters.
+* @returns The target inbox URLs that the activity was handed off to.
+*/
+async function forwardPortableInboxActivity(parameters) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"inbox"
+	]);
+	const { recipient, activityId, excludedOrigins, kv, kvPrefix, outboxQueue } = parameters;
+	const { maxTargets, ttl } = parameters.options ?? resolvePortableInboxForwardingOptions();
+	if (kv.cas == null || maxTargets < 1) return [];
+	const canonicalActivityId = canonicalize(activityId) ?? activityId.href;
+	const targets = getForwardingTargets(recipient, excludedOrigins);
+	if (targets.length > maxTargets) {
+		logger.warn("The portable actor that owns the inbox {inbox} has more than {max} other gateways; the activity {activityId} is forwarded only to the first {max} of them.", {
+			inbox: recipient.canonicalInboxId,
+			activityId: activityId.href,
+			max: maxTargets
+		});
+		targets.length = maxTargets;
+	}
+	const claimed = [];
+	for (const { gateway, inbox } of targets) {
+		const key = [
+			...kvPrefix,
+			recipient.canonicalInboxId,
+			canonicalActivityId,
+			gateway
+		];
+		if (await kv.cas(key, void 0, true, { ttl })) claimed.push(inbox);
+	}
+	if (claimed.length < 1) return [];
+	logger.debug("Forwarding activity {activityId} from the portable inbox {inbox} to other gateways:\n{targets}", {
+		activityId: activityId.href,
+		inbox: recipient.canonicalInboxId,
+		targets: claimed.map((t) => t.href)
+	});
+	if (outboxQueue == null) await forwardImmediately(parameters, claimed);
+	else await enqueueForwarding(parameters, outboxQueue, claimed);
+	return claimed;
+}
+function getForwardingTargets(recipient, excludedOrigins) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"inbox"
+	]);
+	const seen = new Set(excludedOrigins);
+	const targets = [];
+	for (const gateway of recipient.gateways) {
+		if (!isGatewayUrl(gateway) || seen.has(gateway.origin)) continue;
+		seen.add(gateway.origin);
+		let inbox;
+		try {
+			inbox = toCompatibleEf61Id(recipient.inboxId, gateway.origin);
+		} catch (error) {
+			if (!(error instanceof TypeError)) throw error;
+			logger.warn("Cannot forward to the gateway {gateway}, as the portable inbox {inbox} cannot be represented as its compatible identifier.", {
+				gateway: gateway.origin,
+				inbox: recipient.canonicalInboxId
+			});
+			continue;
+		}
+		targets.push({
+			gateway: gateway.origin,
+			inbox
+		});
+	}
+	return targets;
+}
+async function forwardImmediately({ activity, activityId, activityType, allowPrivateAddress, options, meterProvider, tracerProvider }, inboxes) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"inbox"
+	]);
+	const deadline = (options ?? resolvePortableInboxForwardingOptions()).deadline.total("millisecond");
+	const sends = inboxes.map((inbox) => sendActivity({
+		activity,
+		activityId: activityId.href,
+		activityType,
+		keys: [],
+		inbox,
+		allowPrivateAddress,
+		meterProvider,
+		tracerProvider
+	}).catch((error) => {
+		logger.error("Failed to forward activity {activityId} to {inbox}; it will not be forwarded to the inbox again:\n{error}", {
+			activityId: activityId.href,
+			inbox: inbox.href,
+			error
+		});
+	}));
+	let timer;
+	const timedOut = await Promise.race([Promise.all(sends).then(() => false), new Promise((resolve) => {
+		timer = setTimeout(() => resolve(true), deadline);
+	})]);
+	clearTimeout(timer);
+	if (timedOut) logger.warn("Forwarding activity {activityId} to other gateways did not finish in {deadline} ms; responding to the delivery without waiting for it.", {
+		activityId: activityId.href,
+		deadline
+	});
+}
+async function enqueueForwarding({ activity, activityId, activityType, baseUrl, startQueue, meterProvider }, outboxQueue, inboxes) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"inbox"
+	]);
+	startQueue?.();
+	const started = (/* @__PURE__ */ new Date()).toISOString();
+	const traceContext = {};
+	propagation.inject(context.active(), traceContext);
+	await Promise.all(inboxes.map(async (inbox) => {
+		const message = {
+			type: "outbox",
+			id: crypto.randomUUID(),
+			baseUrl,
+			keys: [],
+			activity,
+			activityId: activityId.href,
+			activityType,
+			inbox: inbox.href,
+			sharedInbox: false,
+			started,
+			attempt: 0,
+			headers: {},
+			traceContext
+		};
+		try {
+			await outboxQueue.enqueue(message);
+		} catch (error) {
+			logger.error("Failed to enqueue activity {activityId} to forward to {inbox}; it will not be forwarded to the inbox again:\n{error}", {
+				activityId: activityId.href,
+				inbox: inbox.href,
+				error
+			});
+			return;
+		}
+		recordOutboxEnqueue(meterProvider, outboxQueue, message);
+	}));
+}
+//#endregion
 //#region src/federation/outgoing-proof.ts
 function isPortableUrl(url) {
 	return url.protocol === "ap:" || url.protocol === "ap+ef61:";
@@ -5774,6 +6043,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 	kvPrefixes;
 	publicKeyTtl;
 	httpMessageSignaturesSpecTtl;
+	portableInboxForwarding;
 	inboxQueue;
 	outboxQueue;
 	fanoutQueue;
@@ -5806,6 +6076,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 	benchmarkMetricReader;
 	benchmarkTriggerOptions;
 	#mediaUploaderNoAuthWarned = false;
+	#portableInboxForwardingWarned = false;
 	#queueDepthGaugeSourceId = `fedify-${(++nextQueueDepthGaugeSourceId).toString(36)}`;
 	#queueDepthGaugeEntries = [];
 	#queueDepthGaugeMeterProvider;
@@ -5837,10 +6108,12 @@ var FederationImpl = class extends FederationBuilderImpl {
 			acceptSignatureNonce: ["_fedify", "acceptSignatureNonce"],
 			circuitBreaker: ["_fedify", "circuit"],
 			taskDeduplication: ["_fedify", "taskDeduplication"],
+			portableInboxForwarding: ["_fedify", "portableInboxForwarding"],
 			...options.kvPrefixes ?? {}
 		};
 		this.publicKeyTtl = Temporal.Duration.from(options.publicKeyTtl ?? { days: 30 });
 		this.httpMessageSignaturesSpecTtl = Temporal.Duration.from(options.httpMessageSignaturesSpecTtl ?? { days: 90 });
+		this.portableInboxForwarding = resolvePortableInboxForwardingOptions(options.portableInboxForwarding);
 		if (options.queue == null) {
 			this.inboxQueue = void 0;
 			this.outboxQueue = void 0;
@@ -6510,8 +6783,8 @@ var FederationImpl = class extends FederationBuilderImpl {
 		]);
 		const baseUrl = new URL(message.baseUrl);
 		let context = this.#createContext(baseUrl, ctxData);
-		if (message.identifier != null) context = this.#createContext(baseUrl, ctxData, { documentLoader: await context.getDocumentLoader({ identifier: message.identifier }) });
-		else if (this.sharedInboxKeyDispatcher != null) {
+		if (message.identifier != null && this.actorCallbacks?.keyPairsDispatcher != null) context = this.#createContext(baseUrl, ctxData, { documentLoader: await context.getDocumentLoader({ identifier: message.identifier }) });
+		else if (message.identifier == null && this.sharedInboxKeyDispatcher != null) {
 			const identity = await this.sharedInboxKeyDispatcher(context);
 			if (identity != null) context = this.#createContext(baseUrl, ctxData, { documentLoader: "identifier" in identity || "username" in identity ? await context.getDocumentLoader(identity) : context.getDocumentLoader(identity) });
 		}
@@ -7104,6 +7377,15 @@ var FederationImpl = class extends FederationBuilderImpl {
 				span,
 				metricState
 			});
+			if (request.method === "POST") {
+				const portable = parsePortableGatewayRequest(url);
+				if (portable != null) return await this.#fetchPortableInbox(request, portable, {
+					onNotFound,
+					contextData,
+					span,
+					metricState
+				});
+			}
 			const portable = request.method === "GET" || request.method === "HEAD" ? parsePortableGatewayRequest(url) : null;
 			if (portable != null) return await discardBodyForHead(request, await this.#fetchPortableObject(request, portable, {
 				onNotFound,
@@ -7255,35 +7537,17 @@ var FederationImpl = class extends FederationBuilderImpl {
 					onNotFound
 				});
 				context = this.#createContext(request, contextData, { documentLoader: await context.getDocumentLoader({ identifier: route.values.identifier }) });
-			case "sharedInbox": {
+			case "sharedInbox":
 				if (routeName !== "inbox" && this.sharedInboxKeyDispatcher != null) {
 					const identity = await this.sharedInboxKeyDispatcher(context);
 					if (identity != null) context = this.#createContext(request, contextData, { documentLoader: "identifier" in identity || "username" in identity ? await context.getDocumentLoader(identity) : context.getDocumentLoader(identity) });
 				}
-				if (!this.manuallyStartQueue) this._startQueueInternal(contextData);
-				const inboxContextFactory = context.toInboxContext.bind(context);
-				inboxContextFactory[rawInboxContextFactorySymbol] = context.toInboxContext.bind(context);
-				return await handleInbox(request, {
+				return await this.#handleInbox(request, {
 					recipient: route.values.identifier ?? null,
 					context,
-					inboxContextFactory,
-					kv: this.kv,
-					kvPrefixes: this.kvPrefixes,
-					publicKeyTtl: this.publicKeyTtl,
-					queue: this.inboxQueue,
-					actorDispatcher: this.actorCallbacks?.dispatcher,
-					inboxListeners: this.inboxListeners,
-					inboxErrorHandler: this.inboxErrorHandler,
-					unverifiedActivityHandler: this.unverifiedActivityHandler,
-					onNotFound,
-					signatureTimeWindow: this.signatureTimeWindow,
-					skipSignatureVerification: this.skipSignatureVerification,
-					inboxChallengePolicy: this.inboxChallengePolicy,
-					meterProvider: this.meterProvider,
-					tracerProvider: this.tracerProvider,
-					idempotencyStrategy: this.idempotencyStrategy
+					contextData,
+					onNotFound
 				});
-			}
 			case "following": return await handleCollection(request, {
 				name: "following",
 				identifier: route.values.identifier,
@@ -7436,6 +7700,113 @@ var FederationImpl = class extends FederationBuilderImpl {
 			onNotFound
 		});
 	}
+	async #handleInbox(request, { recipient, context, contextData, onNotFound, portableInbox }) {
+		if (!this.manuallyStartQueue) this._startQueueInternal(contextData);
+		const inboxContextFactory = context.toInboxContext.bind(context);
+		inboxContextFactory[rawInboxContextFactorySymbol] = context.toInboxContext.bind(context);
+		return await handleInbox(request, {
+			recipient,
+			context,
+			inboxContextFactory,
+			kv: this.kv,
+			kvPrefixes: this.kvPrefixes,
+			publicKeyTtl: this.publicKeyTtl,
+			queue: this.inboxQueue,
+			actorDispatcher: this.actorCallbacks?.dispatcher,
+			inboxListeners: this.inboxListeners,
+			inboxErrorHandler: this.inboxErrorHandler,
+			unverifiedActivityHandler: this.unverifiedActivityHandler,
+			onNotFound,
+			signatureTimeWindow: this.signatureTimeWindow,
+			skipSignatureVerification: this.skipSignatureVerification,
+			inboxChallengePolicy: this.inboxChallengePolicy,
+			meterProvider: this.meterProvider,
+			tracerProvider: this.tracerProvider,
+			idempotencyStrategy: this.idempotencyStrategy,
+			portableInbox
+		});
+	}
+	async #fetchPortableInbox(request, portable, { onNotFound, contextData, span, metricState }) {
+		const logger = getLogger([
+			"fedify",
+			"federation",
+			"inbox"
+		]);
+		if (portable.type === "malformed") {
+			metricState.endpoint = "not_found";
+			logger.debug("Malformed FEP-ef61 gateway inbox request {url}: {error}", {
+				url: request.url,
+				error: portable.error
+			});
+			return new Response("Malformed portable inbox ID.", {
+				status: 400,
+				headers: { "Content-Type": "text/plain; charset=utf-8" }
+			});
+		}
+		const route = this.router.route(portable.path);
+		if (route == null || route.name !== "inbox") {
+			metricState.endpoint = "not_found";
+			return await onNotFound(request);
+		}
+		metricState.routeTemplate = PORTABLE_GATEWAY_ROUTE_PREFIX + route.template;
+		metricState.endpoint = "inbox";
+		span.updateName(`${request.method} ${metricState.routeTemplate}`);
+		const identifier = route.values.identifier;
+		let context = this.#createContext(request, contextData);
+		const actor = this.actorCallbacks?.dispatcher == null ? null : await this.actorCallbacks.dispatcher(context, identifier);
+		const localOrigin = context.canonicalOrigin;
+		const resolution = resolvePortableInboxRecipient(actor == null || actor instanceof Tombstone ? null : actor, {
+			authority: portable.portableRequest.authority,
+			canonicalInboxId: portable.canonicalId,
+			localOrigin
+		});
+		if (resolution.status === "rejected") {
+			logger.debug("Not accepting a delivery to the portable inbox {inbox} on behalf of the actor {identifier}: {reason}.", {
+				inbox: portable.canonicalId,
+				identifier,
+				reason: resolution.reason
+			});
+			return await onNotFound(request);
+		}
+		const { recipient } = resolution;
+		if (this.actorCallbacks?.keyPairsDispatcher != null) context = this.#createContext(request, contextData, { documentLoader: await context.getDocumentLoader({ identifier }) });
+		const excludedOrigins = [localOrigin, new URL(request.url).origin];
+		return await this.#handleInbox(request, {
+			recipient: identifier,
+			context,
+			contextData,
+			onNotFound,
+			portableInbox: {
+				recipient,
+				forward: async (activity, activityId, activityType) => {
+					if (this.portableInboxForwarding.maxTargets < 1) return;
+					if (this.kv.cas == null) {
+						if (!this.#portableInboxForwardingWarned) {
+							this.#portableInboxForwardingWarned = true;
+							logger.warn("Activities delivered to FEP-ef61 portable inboxes are not forwarded to the other gateways, as the key–value store does not support compare-and-swap (KvStore.cas()), which is needed to forward each activity at most once.");
+						}
+						return;
+					}
+					await forwardPortableInboxActivity({
+						recipient,
+						activity,
+						activityId,
+						activityType,
+						excludedOrigins,
+						baseUrl: context.origin,
+						kv: this.kv,
+						kvPrefix: this.kvPrefixes.portableInboxForwarding,
+						outboxQueue: this.outboxQueue,
+						startQueue: this.manuallyStartQueue ? void 0 : () => this._startQueueInternal(contextData),
+						allowPrivateAddress: this.allowPrivateAddress,
+						options: this.portableInboxForwarding,
+						meterProvider: this.meterProvider,
+						tracerProvider: this.tracerProvider
+					});
+				}
+			}
+		});
+	}
 	async #fetchHashlinkMedia(request, media, { onNotFound, contextData, span, metricState }) {
 		metricState.endpoint = "hashlink_media";
 		metricState.routeTemplate = HASHLINK_MEDIA_ROUTE_TEMPLATE;
@@ -7666,6 +8037,12 @@ var ContextImpl = class ContextImpl {
 		if (path == null) throw new RouterError("No inbox path registered.");
 		return new URL(path, this.canonicalOrigin);
 	}
+	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);
+	}
 	getFollowingUri(identifier) {
 		const path = this.federation.router.build("following", { identifier });
 		if (path == null) throw new RouterError("No following collection path registered.");
@@ -8268,6 +8645,9 @@ var RequestContextImpl = class RequestContextImpl extends ContextImpl {
 	getPortableObjectUri(cls, values, authority) {
 		return super.getPortableObjectUri(cls, values, authority ?? this.portableRequest?.authority);
 	}
+	getPortableInboxUri(identifier, authority) {
+		return super.getPortableInboxUri(identifier, 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([

package/dist/{mod-DMkflQdF.d.ts → mod-B2h2KY0q.d.ts}

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { Ut as WebFingerLinksDispatcher, _t as ActorDispatcher, gt as ActorAliasMapper, u as RequestContext, vt as ActorHandleMapper } from "./context-DsB9kF6q.js";
+import { Wt as WebFingerLinksDispatcher, _t as ActorAliasMapper, u as RequestContext, vt as ActorDispatcher, yt as ActorHandleMapper } from "./context-BSywYspi.js";
 import { RouterError, RouterOptions, RouterRouteResult } from "@fedify/uri-template";
 import { MeterProvider, Span, Tracer } from "@opentelemetry/api";
 

package/dist/{mod-DTAaBwiY.d.cts → mod-JzkaEXsi.d.cts}

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { Ut as WebFingerLinksDispatcher, _t as ActorDispatcher, gt as ActorAliasMapper, u as RequestContext, vt as ActorHandleMapper } from "./context-DijrgHDe.cjs";
+import { Wt as WebFingerLinksDispatcher, _t as ActorAliasMapper, u as RequestContext, vt as ActorDispatcher, yt as ActorHandleMapper } from "./context-CZjZYXFC.cjs";
 import { MeterProvider, Span, Tracer } from "@opentelemetry/api";
 import { RouterError, RouterOptions, RouterRouteResult } from "@fedify/uri-template";
 

package/dist/mod.cjs

@@ -3,14 +3,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./rolldown-runtime-Dmm3t92W.cjs");
 const require_transformers = require("./transformers-BalCrSsr.cjs");
 require("./compat/mod.cjs");
-const require_http = require("./http-CuLWIJdf.cjs");
-const require_federation = require("./federation-CUiHc7dP.cjs");
+const require_http = require("./http-Dvy_IwRa.cjs");
+const require_federation = require("./federation-CFd0Jhhv.cjs");
 const require_types = require("./types-Be2zbyeG.cjs");
-const require_owner = require("./owner-BXufwAzm.cjs");
-const require_kv_cache = require("./kv-cache-DE8kSNQU.cjs");
+const require_owner = require("./owner-BpOxL5PG.cjs");
+const require_kv_cache = require("./kv-cache-BP69NV0P.cjs");
 require("./nodeinfo/mod.cjs");
 require("./runtime/mod.cjs");
-const require_sig = require("./sig-TTn9wYrE.cjs");
+const require_sig = require("./sig-xoqy3ATq.cjs");
 require("./utils/mod.cjs");
 //#endregion
 exports.CircuitBreaker = require_federation.CircuitBreaker;