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

package/dist/{federation-CUiHc7dP.cjs → federation-CFd0Jhhv.cjs}

@@ -1,10 +1,10 @@
 const { URLPattern } = require("urlpattern-polyfill");
 const require_rolldown_runtime = require("./rolldown-runtime-Dmm3t92W.cjs");
 const require_transformers = require("./transformers-BalCrSsr.cjs");
-const require_http = require("./http-CuLWIJdf.cjs");
+const require_http = require("./http-Dvy_IwRa.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");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_uri_template = require("@fedify/uri-template");
 let _fedify_vocab = require("@fedify/vocab");
@@ -735,13 +735,13 @@ function createFederationBuilder() {
 }
 //#endregion
 //#region src/federation/circuit-breaker.ts
-const Temporal$10 = require_http.Temporal;
+const Temporal$11 = require_http.Temporal;
 const LEGACY_SWEEP_MARKER = ["__fedify_meta", "circuit_breaker_state_ttl_sweep_v2"];
 const LEGACY_SWEEP_DELETING_MARKER = { __fedifyDeletingCircuitBreakerLegacyState: true };
 const CIRCUIT_BREAKER_STATE_VERSION = 1;
-const LEGACY_SWEEP_LOCK_TTL = Temporal$10.Duration.from({ minutes: 5 });
-const LEGACY_SWEEP_RENEW_INTERVAL = Temporal$10.Duration.from({ minutes: 1 });
-const LEGACY_SWEEP_RETRY_WINDOW = Temporal$10.Duration.from({ hours: 168 });
+const LEGACY_SWEEP_LOCK_TTL = Temporal$11.Duration.from({ minutes: 5 });
+const LEGACY_SWEEP_RENEW_INTERVAL = Temporal$11.Duration.from({ minutes: 1 });
+const LEGACY_SWEEP_RETRY_WINDOW = Temporal$11.Duration.from({ hours: 168 });
 const LEGACY_SWEEP_WAIT_INTERVAL = 10;
 const LEGACY_SWEEP_CAS_ATTEMPTS = 3;
 /**
@@ -760,7 +760,7 @@ var CircuitBreaker = class {
 		this.#kv = options.kv;
 		this.#prefix = options.prefix;
 		this.#options = normalizeCircuitBreakerOptions(options.options ?? {});
-		this.#now = options.now ?? (() => Temporal$10.Now.instant());
+		this.#now = options.now ?? (() => Temporal$11.Now.instant());
 		this.#stateChangeObserver = options.stateChangeObserver;
 	}
 	get options() {
@@ -774,7 +774,7 @@ var CircuitBreaker = class {
 		this.#sweepLegacyStates();
 		const heldSince = parseHeldSince(message.circuitHeldSince);
 		const now = this.#now();
-		if (heldSince != null && Temporal$10.Instant.compare(heldSince.add(this.#options.heldActivityTtl), now) <= 0) return {
+		if (heldSince != null && Temporal$11.Instant.compare(heldSince.add(this.#options.heldActivityTtl), now) <= 0) return {
 			type: "drop",
 			heldSince
 		};
@@ -786,12 +786,12 @@ var CircuitBreaker = class {
 				probe: false
 			};
 			if (oldState.state === "half-open") {
-				const halfOpened = oldState.halfOpened == null ? void 0 : Temporal$10.Instant.from(oldState.halfOpened);
+				const halfOpened = oldState.halfOpened == null ? void 0 : Temporal$11.Instant.from(oldState.halfOpened);
 				if (halfOpened != null) {
 					const staleAt = halfOpened.add(this.#options.recoveryDelay);
-					if (Temporal$10.Instant.compare(now, staleAt) < 0) {
+					if (Temporal$11.Instant.compare(now, staleAt) < 0) {
 						const releaseAt = now.add(this.#options.releaseInterval);
-						const retryAt = Temporal$10.Instant.compare(releaseAt, staleAt) < 0 ? releaseAt : staleAt;
+						const retryAt = Temporal$11.Instant.compare(releaseAt, staleAt) < 0 ? releaseAt : staleAt;
 						const cappedRetryAt = this.#capHeldRetryAt(now, heldSince, retryAt);
 						return {
 							type: "hold",
@@ -813,8 +813,8 @@ var CircuitBreaker = class {
 				lastConflictingState = "half-open";
 				continue;
 			}
-			const probeAt = (oldState.opened == null ? now : Temporal$10.Instant.from(oldState.opened)).add(this.#options.recoveryDelay);
-			if (Temporal$10.Instant.compare(now, probeAt) < 0) {
+			const probeAt = (oldState.opened == null ? now : Temporal$11.Instant.from(oldState.opened)).add(this.#options.recoveryDelay);
+			if (Temporal$11.Instant.compare(now, probeAt) < 0) {
 				const retryAt = this.#capHeldRetryAt(now, heldSince, probeAt);
 				return {
 					type: "hold",
@@ -879,7 +879,7 @@ var CircuitBreaker = class {
 		for (let attempt = 0; attempt < 10; attempt++) {
 			const oldState = await this.#get(remoteHost);
 			if (oldState?.state === "open") return void 0;
-			const oldFailures = oldState?.failures.map(Temporal$10.Instant.from) ?? [];
+			const oldFailures = oldState?.failures.map(Temporal$11.Instant.from) ?? [];
 			const failures = this.#options.pruneFailures([...oldFailures, now], now);
 			let newState;
 			let transition;
@@ -963,7 +963,7 @@ var CircuitBreaker = class {
 			for await (const { key, value } of this.#kv.list(this.#prefix)) {
 				if (key.length !== this.#prefix.length + 1) continue;
 				await this.#migrateLegacyState(key, value);
-				if (Temporal$10.Instant.compare(this.#now(), leaseRenewedAt.add(LEGACY_SWEEP_RENEW_INTERVAL)) >= 0) {
+				if (Temporal$11.Instant.compare(this.#now(), leaseRenewedAt.add(LEGACY_SWEEP_RENEW_INTERVAL)) >= 0) {
 					const renewed = await this.#renewLegacySweep(markerKey, marker);
 					if (renewed == null) return;
 					marker = renewed;
@@ -987,7 +987,7 @@ var CircuitBreaker = class {
 	}
 	#finishLegacySweepMarker(marker) {
 		const retryUntil = getLegacySweepRetryUntil(marker);
-		if (retryUntil != null && Temporal$10.Instant.compare(this.#now(), Temporal$10.Instant.from(retryUntil)) < 0) return {
+		if (retryUntil != null && Temporal$11.Instant.compare(this.#now(), Temporal$11.Instant.from(retryUntil)) < 0) return {
 			state: "done",
 			retryUntil
 		};
@@ -1030,7 +1030,7 @@ var CircuitBreaker = class {
 	#isLegacySweepDone() {
 		if (this.#legacySweepDone === "final") return true;
 		if (this.#legacySweepDone == null) return false;
-		if (Temporal$10.Instant.compare(this.#now(), this.#legacySweepDone) < 0) return true;
+		if (Temporal$11.Instant.compare(this.#now(), this.#legacySweepDone) < 0) return true;
 		this.#legacySweepDone = void 0;
 		return false;
 	}
@@ -1040,7 +1040,7 @@ var CircuitBreaker = class {
 	}
 	#capHeldRetryAt(now, heldSince, retryAt) {
 		const expiresAt = (heldSince ?? now).add(this.#options.heldActivityTtl);
-		return Temporal$10.Instant.compare(expiresAt, retryAt) < 0 ? expiresAt : retryAt;
+		return Temporal$11.Instant.compare(expiresAt, retryAt) < 0 ? expiresAt : retryAt;
 	}
 	async #get(remoteHost) {
 		return parseStoredCircuitBreakerKvState(await this.#kv.get(this.#key(remoteHost)));
@@ -1110,7 +1110,7 @@ function normalizeCircuitBreakerOptions(options) {
 	assertPositiveDuration(releaseInterval, "releaseInterval");
 	if (configuredStateTtl != null) {
 		assertPositiveDuration(configuredStateTtl, "stateTtl");
-		if (Temporal$10.Duration.compare(configuredStateTtl, recoveryDelay) < 0) throw new RangeError("stateTtl must be at least recoveryDelay.");
+		if (Temporal$11.Duration.compare(configuredStateTtl, recoveryDelay) < 0) throw new RangeError("stateTtl must be at least recoveryDelay.");
 	}
 	let failure;
 	let pruneFailures;
@@ -1122,13 +1122,13 @@ function normalizeCircuitBreakerOptions(options) {
 		assertPositiveDuration(failureWindow, "failureWindow");
 		pruneFailures = (timestamps, now) => {
 			const earliest = now.subtract(failureWindow);
-			return timestamps.filter((timestamp) => Temporal$10.Instant.compare(timestamp, earliest) >= 0).slice(-failureThreshold);
+			return timestamps.filter((timestamp) => Temporal$11.Instant.compare(timestamp, earliest) >= 0).slice(-failureThreshold);
 		};
 		failure = (timestamps) => {
 			if (timestamps.length < failureThreshold) return false;
 			const first = timestamps[timestamps.length - failureThreshold];
 			const last = timestamps[timestamps.length - 1];
-			return Temporal$10.Duration.compare(first.until(last), failureWindow) <= 0;
+			return Temporal$11.Duration.compare(first.until(last), failureWindow) <= 0;
 		};
 		stateTtl = configuredStateTtl ?? maxDuration(recoveryDelay.add(failureWindow), recoveryDelay.add(heldActivityTtl));
 	} else {
@@ -1148,7 +1148,7 @@ function normalizeCircuitBreakerOptions(options) {
 	};
 }
 function maxDuration(duration, ...durations) {
-	return durations.reduce((max, candidate) => Temporal$10.Duration.compare(candidate, max) > 0 ? candidate : max, duration);
+	return durations.reduce((max, candidate) => Temporal$11.Duration.compare(candidate, max) > 0 ? candidate : max, duration);
 }
 function isLegacySweepDone(value, now) {
 	return getLegacySweepDoneUntil(value, now) != null;
@@ -1157,8 +1157,8 @@ function getLegacySweepDoneUntil(value, now) {
 	if (typeof value !== "object" || value == null || !("state" in value)) return;
 	if (value.state === "final") return "final";
 	if (value.state === "done" && "retryUntil" in value && typeof value.retryUntil === "string") try {
-		const retryUntil = Temporal$10.Instant.from(value.retryUntil);
-		return Temporal$10.Instant.compare(now, retryUntil) < 0 ? retryUntil : void 0;
+		const retryUntil = Temporal$11.Instant.from(value.retryUntil);
+		return Temporal$11.Instant.compare(now, retryUntil) < 0 ? retryUntil : void 0;
 	} catch {
 		return;
 	}
@@ -1166,7 +1166,7 @@ function getLegacySweepDoneUntil(value, now) {
 function isLegacySweepRetryDue(value, now) {
 	if (typeof value !== "object" || value == null || !("state" in value) || value.state !== "done" || !("retryUntil" in value) || typeof value.retryUntil !== "string") return false;
 	try {
-		return Temporal$10.Instant.compare(now, Temporal$10.Instant.from(value.retryUntil)) >= 0;
+		return Temporal$11.Instant.compare(now, Temporal$11.Instant.from(value.retryUntil)) >= 0;
 	} catch {
 		return false;
 	}
@@ -1177,7 +1177,7 @@ function isLegacySweepActive(value, now) {
 function isLegacySweepInProgress(value, now) {
 	if (typeof value !== "object" || value == null || !("state" in value) || value.state !== "sweeping" || !("started" in value) || typeof value.started !== "string") return false;
 	try {
-		return Temporal$10.Instant.compare(now, Temporal$10.Instant.from(value.started).add(LEGACY_SWEEP_LOCK_TTL)) < 0;
+		return Temporal$11.Instant.compare(now, Temporal$11.Instant.from(value.started).add(LEGACY_SWEEP_LOCK_TTL)) < 0;
 	} catch {
 		return false;
 	}
@@ -1185,7 +1185,7 @@ function isLegacySweepInProgress(value, now) {
 function getLegacySweepRetryUntil(value) {
 	if (typeof value !== "object" || value == null || !("retryUntil" in value) || typeof value.retryUntil !== "string") return;
 	try {
-		Temporal$10.Instant.from(value.retryUntil);
+		Temporal$11.Instant.from(value.retryUntil);
 		return value.retryUntil;
 	} catch {
 		return;
@@ -1209,19 +1209,19 @@ function delay(milliseconds) {
 	return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 function toInstantDuration(duration) {
-	const parsed = Temporal$10.Duration.from(duration);
-	return Temporal$10.Duration.from({ milliseconds: Math.trunc(parsed.total({
+	const parsed = Temporal$11.Duration.from(duration);
+	return Temporal$11.Duration.from({ milliseconds: Math.trunc(parsed.total({
 		unit: "millisecond",
-		relativeTo: Temporal$10.PlainDateTime.from("2026-01-01T00:00:00")
+		relativeTo: Temporal$11.PlainDateTime.from("2026-01-01T00:00:00")
 	})) });
 }
 function assertPositiveDuration(duration, name) {
-	if (Temporal$10.Duration.compare(duration, { seconds: 0 }) <= 0) throw new RangeError(`${name} must be a positive duration.`);
+	if (Temporal$11.Duration.compare(duration, { seconds: 0 }) <= 0) throw new RangeError(`${name} must be a positive duration.`);
 }
 function parseHeldSince(value) {
 	if (value == null) return void 0;
 	try {
-		return Temporal$10.Instant.from(value);
+		return Temporal$11.Instant.from(value);
 	} catch (error) {
 		(0, _logtape_logtape.getLogger)([
 			"fedify",
@@ -1248,7 +1248,7 @@ function parseStoredCircuitBreakerKvState(value) {
 	const isInstantString = (v) => {
 		if (typeof v !== "string") return false;
 		try {
-			Temporal$10.Instant.from(v);
+			Temporal$11.Instant.from(v);
 			return true;
 		} catch {
 			return false;
@@ -1849,7 +1849,7 @@ async function verifyCompoundPortableObjectProofs(json, limits, options = {}) {
 }
 //#endregion
 //#region src/federation/inbox.ts
-const Temporal$9 = require_http.Temporal;
+const Temporal$10 = require_http.Temporal;
 async function routeActivity({ context: ctx, json, originalJson, normalizedActivity, ldSignatureVerified, activity, recipient, inboxListeners, inboxContextFactory, listenerInboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, meterProvider, tracerProvider, idempotencyStrategy }) {
 	const logger = (0, _logtape_logtape.getLogger)([
 		"fedify",
@@ -1996,7 +1996,7 @@ async function routeActivity({ context: ctx, json, originalJson, normalizedActiv
 			return "error";
 		}
 		require_http.recordInboxActivity(meterProvider, "processed", (0, _fedify_vocab.getTypeId)(activity).href);
-		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal$9.Duration.from({ days: 1 }) });
+		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal$10.Duration.from({ days: 1 }) });
 		logger.info("Activity {activityId} has been processed.", {
 			activityId: activity.id?.href,
 			activity: json,
@@ -2008,7 +2008,7 @@ async function routeActivity({ context: ctx, json, originalJson, normalizedActiv
 }
 //#endregion
 //#region src/federation/keycache.ts
-const Temporal$8 = require_http.Temporal;
+const Temporal$9 = require_http.Temporal;
 const KEY_CACHE_GENERATION = "2";
 var KvKeyCache = class {
 	kv;
@@ -2021,8 +2021,8 @@ var KvKeyCache = class {
 		this.kv = kv;
 		this.prefix = prefix;
 		this.options = options;
-		this.unavailableKeyTtl = options.unavailableKeyTtl ?? Temporal$8.Duration.from({ minutes: 10 });
-		this.keyTtl = options.keyTtl ?? Temporal$8.Duration.from({ days: 30 });
+		this.unavailableKeyTtl = options.unavailableKeyTtl ?? Temporal$9.Duration.from({ minutes: 10 });
+		this.keyTtl = options.keyTtl ?? Temporal$9.Duration.from({ days: 30 });
 		this.nullKeys = /* @__PURE__ */ new Map();
 	}
 	#getFetchErrorKey(keyId) {
@@ -2042,13 +2042,13 @@ var KvKeyCache = class {
 	async get(keyId) {
 		const negativeExpiration = this.nullKeys.get(keyId.href);
 		if (negativeExpiration != null) {
-			if (Temporal$8.Now.instant().until(negativeExpiration).sign >= 0) return null;
+			if (Temporal$9.Now.instant().until(negativeExpiration).sign >= 0) return null;
 			this.nullKeys.delete(keyId.href);
 		}
 		const serialized = await this.kv.get(this.#entryKey(keyId));
 		if (serialized === void 0) return void 0;
 		if (serialized === null) {
-			this.nullKeys.set(keyId.href, Temporal$8.Now.instant().add(this.unavailableKeyTtl));
+			this.nullKeys.set(keyId.href, Temporal$9.Now.instant().add(this.unavailableKeyTtl));
 			return null;
 		}
 		try {
@@ -2064,7 +2064,7 @@ var KvKeyCache = class {
 	}
 	async set(keyId, key) {
 		if (key == null) {
-			this.nullKeys.set(keyId.href, Temporal$8.Now.instant().add(this.unavailableKeyTtl));
+			this.nullKeys.set(keyId.href, Temporal$9.Now.instant().add(this.unavailableKeyTtl));
 			await this.kv.set(this.#entryKey(keyId), null, { ttl: this.unavailableKeyTtl });
 			return;
 		}
@@ -2320,7 +2320,7 @@ function parseHashlinkGatewayRequest(url) {
 }
 //#endregion
 //#region src/federation/temporal.ts
-const Temporal$7 = require_http.Temporal;
+const Temporal$8 = require_http.Temporal;
 function isPlainObject$1(value) {
 	return typeof value === "object" && value != null && !Array.isArray(value);
 }
@@ -2330,7 +2330,7 @@ function normalizeDateTimeLiteral(value) {
 function isMalformedDateTimeLiteral(value) {
 	if (typeof value !== "string") return false;
 	try {
-		Temporal$7.Instant.from(normalizeDateTimeLiteral(value));
+		Temporal$8.Instant.from(normalizeDateTimeLiteral(value));
 		return false;
 	} catch {
 		return true;
@@ -2339,7 +2339,7 @@ function isMalformedDateTimeLiteral(value) {
 function isMalformedDurationLiteral(value) {
 	if (typeof value !== "string") return false;
 	try {
-		Temporal$7.Duration.from(value);
+		Temporal$8.Duration.from(value);
 		return false;
 	} catch {
 		return true;
@@ -2410,7 +2410,7 @@ async function hasMalformedKnownTemporalLiteral(value, contextLoader) {
 }
 //#endregion
 //#region src/federation/handler.ts
-const Temporal$6 = require_http.Temporal;
+const Temporal$7 = require_http.Temporal;
 const rawInboxContextFactorySymbol = Symbol("fedify.rawInboxContextFactory");
 const INBOX_COMPOUND_PROOF_LIMITS = {
 	maxDepth: 64,
@@ -3247,7 +3247,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 = (0, _logtape_logtape.getLogger)([
 		"fedify",
 		"federation",
@@ -3260,7 +3260,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 _fedify_vocab.Tombstone) {
 			logger.error("Actor {recipient} not found.", { recipient });
@@ -3671,8 +3671,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,
@@ -3722,6 +3723,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, (0, _fedify_vocab.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" }
@@ -3747,6 +3761,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.
@@ -4340,7 +4360,7 @@ async function buildAcceptSignatureHeader(policy, kv, noncePrefix) {
 }
 async function setKey(kv, key, policy) {
 	const seconds = policy.nonceTtlSeconds ?? 300;
-	const ttl = Temporal$6.Duration.from({ seconds });
+	const ttl = Temporal$7.Duration.from({ seconds });
 	await kv.set(key, true, { ttl });
 }
 const DEF_COMPONENTS = [
@@ -4365,7 +4385,7 @@ function isPortableGatewayKey(key) {
 }
 //#endregion
 //#region src/federation/kv.ts
-const Temporal$5 = require_http.Temporal;
+const Temporal$6 = require_http.Temporal;
 /**
 * A key–value store that stores values in memory.
 * Do not use this in production as it does not persist values.
@@ -4385,7 +4405,7 @@ var MemoryKvStore = class {
 		const entry = this.#values[encodedKey];
 		if (entry == null) return Promise.resolve(void 0);
 		const [value, expiration] = entry;
-		if (expiration != null && Temporal$5.Now.instant().until(expiration).sign < 0) {
+		if (expiration != null && Temporal$6.Now.instant().until(expiration).sign < 0) {
 			delete this.#values[encodedKey];
 			return Promise.resolve(void 0);
 		}
@@ -4396,7 +4416,7 @@ var MemoryKvStore = class {
 	*/
 	set(key, value, options) {
 		const encodedKey = this.#encodeKey(key);
-		const expiration = options?.ttl == null ? null : Temporal$5.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
+		const expiration = options?.ttl == null ? null : Temporal$6.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
 		this.#values[encodedKey] = [value, expiration];
 		return Promise.resolve();
 	}
@@ -4418,13 +4438,13 @@ var MemoryKvStore = class {
 		if (entry == null) currentValue = void 0;
 		else {
 			const [value, expiration] = entry;
-			if (expiration != null && Temporal$5.Now.instant().until(expiration).sign < 0) {
+			if (expiration != null && Temporal$6.Now.instant().until(expiration).sign < 0) {
 				delete this.#values[encodedKey];
 				currentValue = void 0;
 			} else currentValue = value;
 		}
 		if (!(0, es_toolkit.isEqual)(currentValue, expectedValue)) return Promise.resolve(false);
-		const expiration = options?.ttl == null ? null : Temporal$5.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
+		const expiration = options?.ttl == null ? null : Temporal$6.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
 		this.#values[encodedKey] = [newValue, expiration];
 		return Promise.resolve(true);
 	}
@@ -4432,7 +4452,7 @@ var MemoryKvStore = class {
 	* {@inheritDoc KvStore.list}
 	*/
 	async *list(prefix) {
-		const now = Temporal$5.Now.instant();
+		const now = Temporal$6.Now.instant();
 		for (const [encodedKey, entry] of Object.entries(this.#values)) {
 			const key = JSON.parse(encodedKey);
 			if (prefix != null) {
@@ -4626,7 +4646,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,
@@ -4968,6 +4992,252 @@ function serializeDataPointType(dataPointType) {
 	}
 }
 //#endregion
+//#region src/federation/portable-inbox.ts
+const Temporal$5 = require_http.Temporal;
+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$5.Duration.from(options.ttl ?? { days: 30 });
+	if (ttl.total("millisecond") <= 0) throw new RangeError("portableInboxForwarding.ttl must be positive.");
+	const deadline = Temporal$5.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) => (0, _fedify_vocab_runtime.isGatewayUrl)(g) && g.origin === localOrigin)) return {
+		status: "rejected",
+		reason: "notGateway"
+	};
+	return {
+		status: "accepted",
+		recipient: {
+			inboxId,
+			canonicalInboxId,
+			gateways
+		}
+	};
+}
+function isSameAuthority(id, authority) {
+	try {
+		return (0, _fedify_vocab_runtime.getFe34Origin)(id) === authority;
+	} catch (error) {
+		if (error instanceof TypeError) return false;
+		throw error;
+	}
+}
+function canonicalize(iri) {
+	try {
+		return (0, _fedify_vocab_runtime.canonicalizePortableUri)(typeof iri === "string" ? iri : (0, _fedify_vocab_runtime.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 = (0, _logtape_logtape.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 = (0, _logtape_logtape.getLogger)([
+		"fedify",
+		"federation",
+		"inbox"
+	]);
+	const seen = new Set(excludedOrigins);
+	const targets = [];
+	for (const gateway of recipient.gateways) {
+		if (!(0, _fedify_vocab_runtime.isGatewayUrl)(gateway) || seen.has(gateway.origin)) continue;
+		seen.add(gateway.origin);
+		let inbox;
+		try {
+			inbox = (0, _fedify_vocab_runtime.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 = (0, _logtape_logtape.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 = (0, _logtape_logtape.getLogger)([
+		"fedify",
+		"federation",
+		"inbox"
+	]);
+	startQueue?.();
+	const started = (/* @__PURE__ */ new Date()).toISOString();
+	const traceContext = {};
+	_opentelemetry_api.propagation.inject(_opentelemetry_api.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;
+		}
+		require_http.recordOutboxEnqueue(meterProvider, outboxQueue, message);
+	}));
+}
+//#endregion
 //#region src/federation/outgoing-proof.ts
 function isPortableUrl(url) {
 	return url.protocol === "ap:" || url.protocol === "ap+ef61:";
@@ -5870,6 +6140,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 	kvPrefixes;
 	publicKeyTtl;
 	httpMessageSignaturesSpecTtl;
+	portableInboxForwarding;
 	inboxQueue;
 	outboxQueue;
 	fanoutQueue;
@@ -5902,6 +6173,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 	benchmarkMetricReader;
 	benchmarkTriggerOptions;
 	#mediaUploaderNoAuthWarned = false;
+	#portableInboxForwardingWarned = false;
 	#queueDepthGaugeSourceId = `fedify-${(++nextQueueDepthGaugeSourceId).toString(36)}`;
 	#queueDepthGaugeEntries = [];
 	#queueDepthGaugeMeterProvider;
@@ -5933,10 +6205,12 @@ var FederationImpl = class extends FederationBuilderImpl {
 			acceptSignatureNonce: ["_fedify", "acceptSignatureNonce"],
 			circuitBreaker: ["_fedify", "circuit"],
 			taskDeduplication: ["_fedify", "taskDeduplication"],
+			portableInboxForwarding: ["_fedify", "portableInboxForwarding"],
 			...options.kvPrefixes ?? {}
 		};
 		this.publicKeyTtl = Temporal$2.Duration.from(options.publicKeyTtl ?? { days: 30 });
 		this.httpMessageSignaturesSpecTtl = Temporal$2.Duration.from(options.httpMessageSignaturesSpecTtl ?? { days: 90 });
+		this.portableInboxForwarding = resolvePortableInboxForwardingOptions(options.portableInboxForwarding);
 		if (options.queue == null) {
 			this.inboxQueue = void 0;
 			this.outboxQueue = void 0;
@@ -6606,8 +6880,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) });
 		}
@@ -7200,6 +7474,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,
@@ -7351,35 +7634,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,
@@ -7532,6 +7797,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 = (0, _logtape_logtape.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 _fedify_vocab.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;
@@ -7762,6 +8134,12 @@ var ContextImpl = class ContextImpl {
 		if (path == null) throw new _fedify_uri_template.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 _fedify_uri_template.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 _fedify_uri_template.RouterError("No following collection path registered.");
@@ -8364,6 +8742,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) (0, _logtape_logtape.getLogger)([