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

package/dist/{federation-Coi_bg12.cjs → federation-CUiHc7dP.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-BGShIsd6.cjs");
+const require_http = require("./http-CuLWIJdf.cjs");
 const require_types = require("./types-Be2zbyeG.cjs");
-const require_owner = require("./owner-D8ZpRusc.cjs");
-const require_kv_cache = require("./kv-cache-CY6pDNoS.cjs");
+const require_owner = require("./owner-BXufwAzm.cjs");
+const require_kv_cache = require("./kv-cache-DE8kSNQU.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_uri_template = require("@fedify/uri-template");
 let _fedify_vocab = require("@fedify/vocab");
@@ -281,6 +281,10 @@ var FederationBuilderImpl = class {
 				callbacks.aliasMapper = mapper;
 				return setters;
 			},
+			mapPortableActorId(mapper) {
+				callbacks.portableActorIdMapper = mapper;
+				return setters;
+			},
 			mapActorAlias: (path, identifier) => {
 				if (identifier === "") throw new _fedify_uri_template.RouterError("Identifier cannot be empty.");
 				if (this.router.has(`actorAlias:${identifier}`)) throw new _fedify_uri_template.RouterError(`Actor alias for "${identifier}" already set.`);
@@ -1777,7 +1781,7 @@ async function verifyDiscoveredProofDocuments(discovered, options) {
 			verified: false,
 			reason: { type: "missingContext" }
 		});
-		const key = await require_owner.verifyMapLocalProof(document.securedDocument, options);
+		const key = await require_http.verifyMapLocalProof(document.securedDocument, options);
 		return key == null ? Object.freeze({
 			...metadata,
 			verified: false,
@@ -1815,7 +1819,7 @@ async function verifyCompoundPortableObjectProofs(json, limits, options = {}) {
 		const proof = proofByPath.get(object.path);
 		const key = proof?.verified === true ? proof.key : null;
 		try {
-			const policy = await require_owner.verifyPortableObjectProofPolicy(object.document, key, options);
+			const policy = await require_http.verifyPortableObjectProofPolicy(object.document, key, options);
 			return policy.verified ? Object.freeze({
 				...metadata,
 				id: policy.objectId,
@@ -2397,7 +2401,7 @@ function hasMalformedKnownTemporalLiteralInternal(value, visited) {
 async function hasMalformedKnownTemporalLiteral(value, contextLoader) {
 	try {
 		return hasMalformedKnownTemporalLiteralInternal(await _fedify_vocab_runtime_jsonld.default.expand(value, {
-			documentLoader: require_owner.getNormalizationContextLoader(contextLoader),
+			documentLoader: require_http.getNormalizationContextLoader(contextLoader),
 			keepFreeFloatingNodes: true
 		}), /* @__PURE__ */ new Set());
 	} catch {
@@ -2421,15 +2425,15 @@ function isPermanentRemoteContextError$1(error) {
 	if (!(error instanceof Error) || error.name !== "jsonld.InvalidUrl") return false;
 	const details = error.details;
 	if (details?.code === "invalid remote context") return true;
-	return isRemoteContextLoadingFailure$1(error) && typeof details?.url === "string" && !URL.canParse(details.url) && require_owner.isClearlyMalformedContextReference(details.url);
+	return isRemoteContextLoadingFailure$1(error) && typeof details?.url === "string" && !URL.canParse(details.url) && require_http.isClearlyMalformedContextReference(details.url);
 }
 function isInvalidJsonLdError(error) {
 	if (!(error instanceof Error)) return false;
 	const name = error.name;
-	return name === "UnsafeJsonLdError" || error instanceof require_owner.InvalidContextReferenceError || isPermanentRemoteContextError$1(error) || name === "jsonld.SyntaxError" && !isRemoteContextLoadingFailure$1(error);
+	return name === "UnsafeJsonLdError" || error instanceof require_http.InvalidContextReferenceError || isPermanentRemoteContextError$1(error) || name === "jsonld.SyntaxError" && !isRemoteContextLoadingFailure$1(error);
 }
 function isValidationTypeError(error) {
-	return error instanceof TypeError && (/^(Invalid JSON-LD:|Invalid type:|Unexpected type:|Invalid @id:)/.test(error.message) || require_owner.isInvalidUrlTypeError(error));
+	return error instanceof TypeError && (/^(Invalid JSON-LD:|Invalid type:|Unexpected type:|Invalid @id:)/.test(error.message) || require_http.isInvalidUrlTypeError(error));
 }
 function isPermanentActivityParseError(error) {
 	return isInvalidJsonLdError(error) || isValidationTypeError(error);
@@ -2535,7 +2539,7 @@ async function handlePortableObject(request, { values, context, objectDispatcher
 	try {
 		jsonLd = await object.toJsonLd(context);
 		servedId = await getJsonLdRootId(jsonLd, context.contextLoader);
-		result = await require_owner.verifyPortableObjectProof(jsonLd, {
+		result = await require_http.verifyPortableObjectProof(jsonLd, {
 			contextLoader: context.contextLoader,
 			documentLoader: context.documentLoader,
 			tracerProvider: context.tracerProvider,
@@ -2576,7 +2580,7 @@ function isRequestedPortableObject(object, canonicalId) {
 }
 async function getJsonLdRootId(jsonLd, contextLoader) {
 	const expanded = await _fedify_vocab_runtime_jsonld.default.expand(jsonLd, {
-		documentLoader: require_owner.getNormalizationContextLoader(contextLoader),
+		documentLoader: require_http.getNormalizationContextLoader(contextLoader),
 		keepFreeFloatingNodes: true
 	});
 	if (expanded.length !== 1) return null;
@@ -2634,13 +2638,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, tracerProvider, meterProvider, onUnauthorized, onNotFound }) {
+	const spanName = name$1.trim().replace(/\s+/g, "_");
 	tracerProvider = tracerProvider ?? _opentelemetry_api.trace.getTracerProvider();
 	const tracer = tracerProvider.getTracer(require_http.name, require_http.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"
 	};
@@ -2681,7 +2685,7 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 							span.setStatus({ code: _opentelemetry_api.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;
@@ -2721,7 +2725,7 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 		} else {
 			const uri = new URL(baseUri);
 			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: _opentelemetry_api.SpanKind.SERVER,
 				attributes: {
 					"activitypub.collection.id": uri.href,
@@ -2737,7 +2741,7 @@ async function handleCollection(request, { name: name$2, identifier, uriGetter,
 						span.setStatus({ code: _opentelemetry_api.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 {
@@ -3328,8 +3332,8 @@ async function handleInboxInternal(request, parameters, span) {
 		tracerProvider,
 		keyTtl: publicKeyTtl
 	});
-	const jsonWithoutSig = require_owner.detachSignature(json);
-	const hasLdSignature = require_owner.hasSignature(json);
+	const jsonWithoutSig = require_http.detachSignature(json);
+	const hasLdSignature = require_http.hasSignature(json);
 	const canAttemptAlternateAuthAfterLdSignatureFailure = skipSignatureVerification || hasHttpSignatureHeaders(request) || hasObjectIntegrityProof(jsonWithoutSig);
 	let deferredLdSignatureError = void 0;
 	const respondInvalidActivity = async (error) => {
@@ -3361,7 +3365,7 @@ async function handleInboxInternal(request, parameters, span) {
 	let ldSigVerified = false;
 	if (hasLdSignature) {
 		try {
-			compactedJson = await require_owner.compactJsonLd(json, ctx.contextLoader);
+			compactedJson = await require_http.compactJsonLd(json, ctx.contextLoader);
 		} catch (error) {
 			if (isInvalidJsonLdError(error)) {
 				logger.error("Failed to parse JSON-LD:\n{error}", {
@@ -3381,9 +3385,9 @@ async function handleInboxInternal(request, parameters, span) {
 			});
 		}
 		if (compactedJson !== json) {
-			compactedJsonWithoutSig = require_owner.detachSignature(compactedJson);
+			compactedJsonWithoutSig = require_http.detachSignature(compactedJson);
 			try {
-				ldSigVerified = await require_owner.verifyCompactJsonLd(compactedJson, {
+				ldSigVerified = await require_http.verifyCompactJsonLd(compactedJson, {
 					contextLoader: ctx.contextLoader,
 					documentLoader: ctx.documentLoader,
 					keyCache,
@@ -3405,7 +3409,7 @@ async function handleInboxInternal(request, parameters, span) {
 				if (!canAttemptAlternateAuthAfterLdSignatureFailure) throw error;
 				if (!skipSignatureVerification) try {
 					await _fedify_vocab.Object.fromJsonLd(compactedJson, {
-						contextLoader: require_owner.getNormalizationContextLoader(ctx.contextLoader),
+						contextLoader: require_http.getNormalizationContextLoader(ctx.contextLoader),
 						documentLoader: ctx.documentLoader,
 						tracerProvider
 					});
@@ -3429,6 +3433,7 @@ async function handleInboxInternal(request, parameters, span) {
 	}
 	let activity = null;
 	let activityVerified = false;
+	let proofVerified = false;
 	if (ldSigVerified) {
 		logger.debug("Linked Data Signatures are verified.", {
 			recipient,
@@ -3437,7 +3442,7 @@ async function handleInboxInternal(request, parameters, span) {
 		try {
 			activity = await _fedify_vocab.Activity.fromJsonLd(compactedJsonWithoutSig, {
 				...ctx,
-				contextLoader: require_owner.getNormalizationContextLoader(ctx.contextLoader)
+				contextLoader: require_http.getNormalizationContextLoader(ctx.contextLoader)
 			});
 		} catch (error) {
 			if (error instanceof RangeError && await hasMalformedKnownTemporalLiteral(compactedJsonWithoutSig, ctx.contextLoader)) return await respondInvalidActivity(error);
@@ -3445,14 +3450,29 @@ async function handleInboxInternal(request, parameters, span) {
 			return await respondInvalidActivity(error);
 		}
 		activityVerified = true;
+		if (!skipSignatureVerification && require_http.hasPortableActor(activity)) try {
+			proofVerified = await require_http.verifyObject(_fedify_vocab.Activity, jsonWithoutSig, {
+				contextLoader: require_http.wrapContextLoaderForJsonLd(ctx.contextLoader),
+				documentLoader: ctx.documentLoader,
+				keyCache,
+				meterProvider,
+				tracerProvider
+			}) != null;
+		} catch (error) {
+			if (!isPermanentActivityParseError(error)) throw error;
+			logger.debug("Failed to verify the Object Integrity Proofs of the portable actor's activity:\n{error}", {
+				recipient,
+				error
+			});
+		}
 	} else {
 		logger.debug("Linked Data Signatures are not verified.", {
 			recipient,
 			json
 		});
 		try {
-			activity = await require_owner.verifyObject(_fedify_vocab.Activity, jsonWithoutSig, {
-				contextLoader: require_owner.wrapContextLoaderForJsonLd(ctx.contextLoader),
+			activity = await require_http.verifyObject(_fedify_vocab.Activity, jsonWithoutSig, {
+				contextLoader: require_http.wrapContextLoaderForJsonLd(ctx.contextLoader),
 				documentLoader: ctx.documentLoader,
 				keyCache,
 				meterProvider,
@@ -3501,6 +3521,7 @@ async function handleInboxInternal(request, parameters, span) {
 				activity: json
 			});
 			activityVerified = true;
+			proofVerified = true;
 		}
 	}
 	let httpSigKey = null;
@@ -3597,7 +3618,7 @@ async function handleInboxInternal(request, parameters, span) {
 		try {
 			activity = await _fedify_vocab.Activity.fromJsonLd(jsonWithoutSig, {
 				...ctx,
-				contextLoader: require_owner.wrapContextLoaderForJsonLd(ctx.contextLoader)
+				contextLoader: require_http.wrapContextLoaderForJsonLd(ctx.contextLoader)
 			});
 		} catch (error) {
 			if (!isPermanentActivityParseError(error)) throw error;
@@ -3613,6 +3634,24 @@ async function handleInboxInternal(request, parameters, span) {
 		"http_signatures.verified": httpSigKey != null,
 		"http_signatures.key_id": httpSigKey?.id?.href ?? ""
 	});
+	if (!skipSignatureVerification && !proofVerified && (require_http.hasPortableActor(activity) || isPortableGatewayKey(httpSigKey))) {
+		if (deferredLdSignatureError != null) throw deferredLdSignatureError;
+		logger.error("The activity {activityId} of the portable actor {actorId} is not authenticated by a valid Object Integrity Proof.", {
+			activity: json,
+			recipient,
+			activityId: activity.id?.href,
+			actorId: activity.actorId?.href,
+			keyId: httpSigKey?.id?.href
+		});
+		span.setStatus({
+			code: _opentelemetry_api.SpanStatusCode.ERROR,
+			message: `The activity of the portable actor (${activity.actorId?.href}) is not authenticated by a valid Object Integrity Proof.`
+		});
+		return new Response("Activities of portable actors must have valid Object Integrity Proofs.", {
+			status: 401,
+			headers: { "Content-Type": "text/plain; charset=utf-8" }
+		});
+	}
 	if (httpSigKey != null && !await require_owner.doesActorOwnKey(activity, httpSigKey, ctx)) {
 		if (deferredLdSignatureError != null) throw deferredLdSignatureError;
 		require_http.getFederationMetrics(parameters.meterProvider).recordSignatureVerificationFailure("actorKeyMismatch", httpSigKey.id == null ? void 0 : require_http.getRemoteHost(httpSigKey.id));
@@ -3830,8 +3869,8 @@ var CustomCollectionHandler = class {
 	* @param CollectionPage The CollectionPage constructor.
 	* @param filterPredicate Optional filter predicate for items.
 	*/
-	constructor(name$1, values, context, callbacks, tracerProvider = _opentelemetry_api.trace.getTracerProvider(), meterProvider, Collection, CollectionPage, filterPredicate) {
-		this.name = name$1;
+	constructor(name$2, values, context, callbacks, tracerProvider = _opentelemetry_api.trace.getTracerProvider(), meterProvider, Collection, CollectionPage, filterPredicate) {
+		this.name = name$2;
 		this.values = values;
 		this.context = context;
 		this.callbacks = callbacks;
@@ -4315,6 +4354,15 @@ const MIN_COMPONENTS = [
 	"@target-uri",
 	"@authority"
 ];
+/**
+* Checks whether an HTTP Signature key is a gateway key of an FEP-ef61
+* portable actor, i.e., its ID is a compatible identifier and it is owned by
+* a portable actor, which only the portable actor's signed document can
+* establish.
+*/
+function isPortableGatewayKey(key) {
+	return key?.id != null && require_http.isCompatibleKeyId(key.id) && key.ownerId != null && require_http.isPortableUri(key.ownerId);
+}
 //#endregion
 //#region src/federation/kv.ts
 const Temporal$5 = require_http.Temporal;
@@ -4928,39 +4976,50 @@ function formatKeyIds(candidates) {
 	return candidates.map((c) => c.verificationMethod.href).join(", ");
 }
 /**
+* Rejects an activity of a portable actor whose ID cannot be authenticated by
+* the actor's DID: FEP-ef61 requires the activity to be a portable object
+* signed by that DID, so its ID has to be a portable ID with the same DID.
+* @throws {TypeError} If the activity is performed by a portable actor, but
+*                     its ID is not a portable ID of the actor's DID, or its
+*                     portable actors do not share a DID.
+* @internal
+*/
+function assertPortableActorActivity(activity) {
+	const portableActors = activity.actorIds.filter(isPortableUrl);
+	if (portableActors.length < 1) return;
+	const did = (0, _fedify_vocab_runtime.getFe34Origin)(portableActors[0]);
+	if (portableActors.some((actorId) => (0, _fedify_vocab_runtime.getFe34Origin)(actorId) !== did)) throw new TypeError(`The activity ${activity.id?.href} has portable actors with different DIDs (${portableActors.map((a) => a.href).join(", ")}); a portable activity is signed by a single DID.`);
+	if (activity.id == null || !isPortableUrl(activity.id) || (0, _fedify_vocab_runtime.getFe34Origin)(activity.id) !== did) throw new TypeError(`The activity ${activity.id?.href} is performed by the portable actor ${portableActors[0].href}, so its ID has to be an ap: or ap+ef61: URI with the same DID (${did}), as FEP-ef61 requires it to carry an Object Integrity Proof made by that DID.`);
+}
+/**
 * Creates the Object Integrity Proofs Fedify attaches to an outgoing activity.
 *
+* Keys whose IDs are FEP-ef61 compatible identifiers are gateway keys, which
+* never sign proofs.  A portable activity, i.e., one with an `ap:` or
+* `ap+ef61:` ID, that carries no proof is signed only by the one Ed25519 key
+* whose verification method is a DID URL for its DID, even if it is the only
+* key; if no key or more than one key qualifies, this function throws.
+*
 * Outside the map-local compound-proof profile, i.e., when the activity
 * embeds no portable object, every Ed25519 key signs the activity, as it
 * always has.  Inside the profile, which accepts exactly one direct proof per
 * map, Fedify creates at most one proof:
 *
 *  -  An activity that already carries a proof is kept as is.
-*  -  A single Ed25519 key signs the activity.
-*  -  With several Ed25519 keys, a portable activity is signed by the one key
-*     whose verification method is a DID URL for the activity's DID, the only
-*     proof the FEP-ef61 policy can accept.  If no key or more than one key
-*     qualifies, or the activity is not portable itself, the choice is
-*     ambiguous and this function throws.
+*  -  A single Ed25519 key signs a non-portable activity.
+*  -  With several Ed25519 keys, a non-portable activity is ambiguous, and
+*     this function throws.
 *
-* @throws {TypeError} If a single proof key cannot be chosen.
+* @throws {TypeError} If a single proof key cannot be chosen, or the activity
+*                     is performed by a portable actor but is not a portable
+*                     activity of the same DID.
 * @internal
 */
 async function signOutgoingActivity(activity, candidates, options) {
 	const { contextLoader, tracerProvider } = options;
-	let hasProof = false;
-	for await (const _ of activity.getProofs({ contextLoader })) {
-		hasProof = true;
-		break;
-	}
-	const keys = candidates.filter((c) => c.privateKey.algorithm.name === "Ed25519");
-	if (keys.length < 1 || hasProof && !options.appendToExistingProofs) return {
-		activity,
-		hasProof,
-		proofCreated: false
-	};
+	assertPortableActorActivity(activity);
 	const sign = async (selected) => {
-		for (const { verificationMethod, privateKey } of selected) activity = await require_owner.signObject(activity, privateKey, verificationMethod, {
+		for (const { verificationMethod, privateKey } of selected) activity = await require_http.signObject(activity, privateKey, verificationMethod, {
 			contextLoader,
 			tracerProvider
 		});
@@ -4970,6 +5029,18 @@ async function signOutgoingActivity(activity, candidates, options) {
 			proofCreated: true
 		};
 	};
+	let hasProof = false;
+	for await (const _ of activity.getProofs({ contextLoader })) {
+		hasProof = true;
+		break;
+	}
+	const keys = candidates.filter((c) => c.privateKey.algorithm.name === "Ed25519" && !require_http.isCompatibleKeyId(c.verificationMethod));
+	if (!hasProof && activity.id != null && isPortableUrl(activity.id)) return await sign(selectPortableActivityKey(activity, activity.id, keys));
+	if (keys.length < 1 || hasProof && !options.appendToExistingProofs) return {
+		activity,
+		hasProof,
+		proofCreated: false
+	};
 	if (keys.length < 2 && !hasProof) return await sign(keys);
 	if (!containsCompoundPortableObject(await activity.toJsonLd({
 		format: "compact",
@@ -4989,15 +5060,26 @@ async function signOutgoingActivity(activity, candidates, options) {
 			proofCreated: false
 		};
 	}
-	if (activity.id == null || !isPortableUrl(activity.id)) throw new TypeError(`Cannot choose an Object Integrity Proof key for the activity ${activityId}: it embeds portable objects, so it falls under the map-local compound-proof profile, which accepts exactly one direct proof per map, but ${keys.length} Ed25519 keys were supplied (${formatKeyIds(keys)}).  Send it with explicit sender keys that contain exactly one Ed25519 key (RSA keys for HTTP Signatures may stay), or sign it with signObject() before sending it.`);
-	const activityDid = (0, _fedify_vocab_runtime.getFe34Origin)(activity.id);
-	const eligible = keys.filter((c) => c.verificationMethod.protocol === "did:" && (0, _fedify_vocab_runtime.haveSameFe34Origin)(activity.id, c.verificationMethod));
-	if (eligible.length !== 1) throw new TypeError(`Cannot choose an Object Integrity Proof key for the portable activity ${activityId}: ` + (eligible.length < 1 ? `none of its ${keys.length} Ed25519 keys (${formatKeyIds(keys)}) ` : `${eligible.length} of its Ed25519 keys (${formatKeyIds(eligible)}) `) + `${eligible.length < 1 ? "is" : "are"} a DID URL verification method for ${activityDid}.  The map-local compound-proof profile accepts exactly one direct proof per map, and FEP-ef61 requires that proof's verification method to be a DID URL for the activity's DID.  Supply exactly one Ed25519 key whose key ID is a DID URL for ${activityDid}, or sign the activity with signObject() before sending it.`);
-	logger.debug("The portable activity {activityId} is signed only by {keyId}, the one Ed25519 key whose verification method matches its DID; the map-local compound-proof profile accepts exactly one direct proof per map.", {
-		activityId,
+	throw new TypeError(`Cannot choose an Object Integrity Proof key for the activity ${activityId}: it embeds portable objects, so it falls under the map-local compound-proof profile, which accepts exactly one direct proof per map, but ${keys.length} Ed25519 keys were supplied (${formatKeyIds(keys)}).  Send it with explicit sender keys that contain exactly one Ed25519 key (RSA keys for HTTP Signatures may stay), or sign it with signObject() before sending it.`);
+}
+/**
+* Chooses the one Ed25519 key that can sign a portable activity: the key
+* whose verification method is a DID URL for the activity's DID.
+* @throws {TypeError} If no key or more than one key qualifies.
+*/
+function selectPortableActivityKey(activity, activityId, keys) {
+	const activityDid = (0, _fedify_vocab_runtime.getFe34Origin)(activityId);
+	const eligible = keys.filter((c) => c.verificationMethod.protocol === "did:" && (0, _fedify_vocab_runtime.haveSameFe34Origin)(activityId, c.verificationMethod));
+	if (eligible.length !== 1) throw new TypeError(`Cannot choose an Object Integrity Proof key for the portable activity ${activityId.href}: ` + (eligible.length < 1 ? `none of its ${keys.length} Ed25519 keys (${formatKeyIds(keys)}) ` : `${eligible.length} of its Ed25519 keys (${formatKeyIds(eligible)}) `) + `${eligible.length < 1 ? "is" : "are"} a DID URL verification method for ${activityDid}.  FEP-ef61 requires a portable activity's proof to be made by its DID, and the map-local compound-proof profile accepts exactly one direct proof per map.  Gateway keys, whose IDs are compatible identifiers, never sign proofs.  Supply exactly one Ed25519 key whose key ID is a DID URL for ${activityDid}, or sign the activity with signObject() before sending it.`);
+	(0, _logtape_logtape.getLogger)([
+		"fedify",
+		"federation",
+		"outbox"
+	]).debug("The portable activity {activityId} is signed only by {keyId}, the one Ed25519 key whose verification method matches its DID.", {
+		activityId: activity.id?.href,
 		keyId: eligible[0].verificationMethod.href
 	});
-	return await sign(eligible);
+	return eligible;
 }
 /**
 * Rejects an outgoing activity whose proofs Fedify's own inbox would reject
@@ -5758,10 +5840,10 @@ function isPermanentRemoteContextError(error) {
 	if (!(error instanceof Error) || error.name !== "jsonld.InvalidUrl") return false;
 	const details = error.details;
 	if (details?.code === "invalid remote context") return true;
-	return isRemoteContextLoadingFailure(error) && typeof details?.url === "string" && !URL.canParse(details.url) && require_owner.isClearlyMalformedContextReference(details.url);
+	return isRemoteContextLoadingFailure(error) && typeof details?.url === "string" && !URL.canParse(details.url) && require_http.isClearlyMalformedContextReference(details.url);
 }
 function isPermanentInboxParseError(error) {
-	return error instanceof Error && (error.name === "UnsafeJsonLdError" || error instanceof require_owner.InvalidContextReferenceError || isPermanentRemoteContextError(error) || error.name === "jsonld.SyntaxError" && !isRemoteContextLoadingFailure(error)) || error instanceof TypeError && (/^(Invalid JSON-LD:|Invalid type:|Unexpected type:|Invalid @id:)/.test(error.message) || require_owner.isInvalidUrlTypeError(error));
+	return error instanceof Error && (error.name === "UnsafeJsonLdError" || error instanceof require_http.InvalidContextReferenceError || isPermanentRemoteContextError(error) || error.name === "jsonld.SyntaxError" && !isRemoteContextLoadingFailure(error)) || error instanceof TypeError && (/^(Invalid JSON-LD:|Invalid type:|Unexpected type:|Invalid @id:)/.test(error.message) || require_http.isInvalidUrlTypeError(error));
 }
 function hasLinkedDataSignatureJsonLdProcessingError(error) {
 	if (error.message.startsWith("Maximum deep iterations exceeded")) return true;
@@ -6614,22 +6696,22 @@ var FederationImpl = class extends FederationBuilderImpl {
 			let parseInput = void 0;
 			let parseContextLoader = context.contextLoader;
 			try {
-				const hasSignatureField = require_owner.hasSignature(message.activity);
+				const hasSignatureField = require_http.hasSignature(message.activity);
 				const shouldParseFromNormalizedSignedPayload = message.ldSignatureVerified === true || message.normalizedActivity != null || message.ldSignatureVerified == null && hasSignatureField;
 				const parseContext = hasSignatureField ? {
 					...context,
-					contextLoader: require_owner.getNormalizationContextLoader(context.contextLoader)
+					contextLoader: require_http.getNormalizationContextLoader(context.contextLoader)
 				} : {
 					...context,
-					contextLoader: require_owner.wrapContextLoaderForJsonLd(context.contextLoader)
+					contextLoader: require_http.wrapContextLoaderForJsonLd(context.contextLoader)
 				};
 				parseContextLoader = parseContext.contextLoader;
 				let normalizedActivity;
 				if (shouldParseFromNormalizedSignedPayload) {
-					normalizedActivity = message.normalizedActivity ?? await require_owner.compactJsonLd(message.activity, context.contextLoader);
-					require_owner.assertSafeJsonLd(normalizedActivity);
+					normalizedActivity = message.normalizedActivity ?? await require_http.compactJsonLd(message.activity, context.contextLoader);
+					require_http.assertSafeJsonLd(normalizedActivity);
 				}
-				parseInput = shouldParseFromNormalizedSignedPayload ? require_owner.detachSignature(normalizedActivity) : hasSignatureField ? require_owner.detachSignature(message.activity) : message.activity;
+				parseInput = shouldParseFromNormalizedSignedPayload ? require_http.detachSignature(normalizedActivity) : hasSignatureField ? require_http.detachSignature(message.activity) : message.activity;
 				activity = await _fedify_vocab.Activity.fromJsonLd(parseInput, parseContext);
 				activityType = (0, _fedify_vocab.getTypeId)(activity).href;
 				span.setAttribute("activitypub.activity.type", activityType);
@@ -6884,9 +6966,10 @@ var FederationImpl = class extends FederationBuilderImpl {
 		const contextLoader = this.contextLoaderFactory(this.#getLoaderOptions(ctx.origin));
 		const activityId = activity.id.href;
 		let rsaKey = null;
+		const ldSignable = !require_http.hasPortableActor(activity);
 		for (const { keyId, privateKey } of keys) {
 			require_http.validateCryptoKey(privateKey, "private");
-			if (rsaKey == null && privateKey.algorithm.name === "RSASSA-PKCS1-v1_5") rsaKey = {
+			if (ldSignable && rsaKey == null && privateKey.algorithm.name === "RSASSA-PKCS1-v1_5" && !require_http.isCompatibleKeyId(keyId)) rsaKey = {
 				keyId,
 				privateKey
 			};
@@ -6905,9 +6988,10 @@ var FederationImpl = class extends FederationBuilderImpl {
 			format: "compact",
 			contextLoader
 		});
-		if (proofCreated || !hasProof || options.normalizeExistingProofs) jsonLd = await require_owner.normalizeOutgoingActivityJsonLd(jsonLd, contextLoader, { preserveNestedSecuredDocuments: true });
+		if (proofCreated || !hasProof || options.normalizeExistingProofs) jsonLd = await require_http.normalizeOutgoingActivityJsonLd(jsonLd, contextLoader, { preserveNestedSecuredDocuments: true });
 		assertSupportedCompoundProofShape(jsonLd, activityId);
-		if (rsaKey == null) logger.warn("No supported key found to create a Linked Data signature for the activity {activityId}.  The activity will be sent without a Linked Data signature.  In order to create a Linked Data signature, at least one RSASSA-PKCS1-v1_5 key must be provided.", {
+		if (rsaKey == null && !ldSignable) logger.debug("The activity {activityId} is performed by a portable actor, so it is sent without a Linked Data signature.", { activityId });
+		else if (rsaKey == null) logger.warn("No supported key found to create a Linked Data signature for the activity {activityId}.  The activity will be sent without a Linked Data signature.  In order to create a Linked Data signature, at least one RSASSA-PKCS1-v1_5 key must be provided.", {
 			activityId,
 			keys: keys.map((pair) => ({
 				keyId: pair.keyId.href,
@@ -6915,7 +6999,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 			}))
 		});
 		else try {
-			jsonLd = await require_owner.signJsonLd(jsonLd, rsaKey.privateKey, rsaKey.keyId, {
+			jsonLd = await require_http.signJsonLd(jsonLd, rsaKey.privateKey, rsaKey.keyId, {
 				contextLoader,
 				tracerProvider: this.tracerProvider
 			});
@@ -7783,14 +7867,15 @@ var ContextImpl = class ContextImpl {
 			getActorKeyPairsIdentifier: identifier,
 			actorKeyPairsDispatcherIdentifier: this.invokedFromActorKeyPairsDispatcher.identifier
 		});
+		const portableActor = await this.getPortableActorKeyOwner(identifier);
 		let keyPairs;
 		try {
-			keyPairs = await this.getKeyPairsFromIdentifier(identifier);
+			keyPairs = await this.getKeyPairsFromIdentifier(identifier, portableActor);
 		} catch (_) {
 			logger.warn("No actor key pairs dispatcher registered.");
 			return [];
 		}
-		const owner = this.getActorUri(identifier);
+		const owner = portableActor?.id ?? this.getActorUri(identifier);
 		const result = [];
 		let i = 1;
 		for (const keyPair of keyPairs) {
@@ -7802,7 +7887,7 @@ var ContextImpl = class ContextImpl {
 					publicKey: keyPair.publicKey
 				}),
 				multikey: new _fedify_vocab.Multikey({
-					id: new URL(`#multikey-${i}`, owner),
+					id: portableActor == null ? new URL(`#multikey-${i}`, owner) : keyPair.keyId,
 					controller: owner,
 					publicKey: keyPair.publicKey
 				})
@@ -7812,7 +7897,26 @@ var ContextImpl = class ContextImpl {
 		}
 		return result;
 	}
-	async getKeyPairsFromIdentifier(identifier) {
+	/**
+	* Resolves the portable actor that the actor with the given identifier is,
+	* through the portable actor ID mapper, along with the base of its gateway
+	* key IDs on this server.
+	* @param identifier The actor's identifier.
+	* @returns The portable actor's ID and key ID base, or `null` if the actor
+	*          is not portable.
+	* @throws {TypeError} If the mapper returns an invalid portable actor ID.
+	*/
+	async getPortableActorKeyOwner(identifier) {
+		const mapper = this.federation.actorCallbacks?.portableActorIdMapper;
+		if (mapper == null) return null;
+		const id = await mapper(this, identifier);
+		if (id == null) return null;
+		return {
+			id,
+			keyBase: require_http.getGatewayKeyBase(id, this.canonicalOrigin)
+		};
+	}
+	async getKeyPairsFromIdentifier(identifier, portableActor) {
 		const logger = (0, _logtape_logtape.getLogger)([
 			"fedify",
 			"federation",
@@ -7829,6 +7933,8 @@ var ContextImpl = class ContextImpl {
 			}
 			throw error;
 		}
+		if (portableActor === void 0) portableActor = await this.getPortableActorKeyOwner(identifier);
+		const keyBase = portableActor?.keyBase ?? actorUri;
 		const keyPairs = await this.federation.actorCallbacks?.keyPairsDispatcher(new ContextImpl({
 			...this,
 			invokedFromActorKeyPairsDispatcher: { identifier }
@@ -7839,7 +7945,7 @@ var ContextImpl = class ContextImpl {
 		for (const keyPair of keyPairs) {
 			result.push({
 				...keyPair,
-				keyId: new URL(i == 0 ? `#main-key` : `#key-${i + 1}`, actorUri)
+				keyId: new URL(i == 0 ? `#main-key` : `#key-${i + 1}`, keyBase)
 			});
 			i++;
 		}
@@ -7885,7 +7991,7 @@ var ContextImpl = class ContextImpl {
 			userAgent: options.userAgent ?? this.federation.userAgent,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider,
 			meterProvider: options.meterProvider ?? this.meterProvider,
-			verifyPortableObject: options.verifyPortableObject ?? require_owner.verifyPortableObjectProof,
+			verifyPortableObject: options.verifyPortableObject ?? require_http.verifyPortableObjectProof,
 			allowPrivateAddress: this.federation.allowPrivateAddress
 		});
 	}
@@ -8148,7 +8254,7 @@ var ContextImpl = class ContextImpl {
 			tracerProvider: this.tracerProvider,
 			keyTtl: this.federation.publicKeyTtl
 		});
-		if (await require_owner.verifyObject(_fedify_vocab.Activity, json, {
+		if (await require_http.verifyObject(_fedify_vocab.Activity, json, {
 			contextLoader,
 			documentLoader: options.documentLoader ?? this.documentLoader,
 			meterProvider: this.meterProvider,
@@ -8381,8 +8487,8 @@ async function forwardActivityInternal(ctx, loggerCategory, forwarder, recipient
 		if (forwarder.length < 1) throw new Error("The forwarder's key pairs are empty.");
 		keys = forwarder;
 	} else keys = [forwarder];
-	if (!require_owner.hasSignatureLike(ctx.activity)) {
-		if (!require_owner.hasProofLike(ctx.activity)) {
+	if (!require_http.hasSignatureLike(ctx.activity)) {
+		if (!require_http.hasProofLike(ctx.activity)) {
 			if (options?.skipIfUnsigned) return false;
 			logger.warn("The activity {activityId} is not signed; even if it is forwarded to other servers as is, it may not be accepted by them due to the lack of a signature/proof.", {
 				activityId: ctx.activityId,