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

package/dist/federation/portable-gateway-keys.test.mjs

@@ -7,10 +7,10 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
-import { p as signJsonLd } from "../ld-DQNTIrAe.mjs";
-import { l as signRequest } from "../http-BFeK9sBg.mjs";
+import { p as signJsonLd } from "../ld-CWDReGMZ.mjs";
+import { l as signRequest } from "../http-CEx2SZjf.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { f as handleInbox, n as FederationImpl, o as createFederation } from "../middleware-BdhvduR9.mjs";
+import { f as handleInbox, n as FederationImpl, o as createFederation } from "../middleware-CAWRGSwH.mjs";
 import { t as ActivityListenerSet } from "../activity-listener-C-BSbKI7.mjs";
 import { t as KvKeyCache } from "../keycache-BInaECGj.mjs";
 import { Create, CryptographicKey, Person } from "@fedify/vocab";
@@ -214,6 +214,24 @@ test("Context.sendActivity() never signs documents with gateway keys", async ()
 	assertEquals(bodies[0].proof, void 0);
 	assertEquals(bodies[0].signature, void 0);
 });
+test("Context.sendActivity() never signs documents with keys at ap: URIs", async () => {
+	const ctx = createTestFederation().createContext(new URL(gateway));
+	const keys = [{
+		keyId: parseIri(`${actorId.href}#main-key`),
+		privateKey: rsaPrivateKey2
+	}, {
+		keyId: parseIri(`${actorId.href}#key-2`),
+		privateKey: ed25519GatewayKeyPair.privateKey
+	}];
+	const activity = new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/users/bob"),
+		object: new URL("https://example.com/notes/1")
+	});
+	const { bodies } = await capture(() => ctx.sendActivity(keys, recipient, activity));
+	assertEquals(bodies[0].proof, void 0);
+	assertEquals(bodies[0].signature, void 0);
+});
 test("Context.getDocumentLoader() signs requests with gateway keys for portable actors", async () => {
 	const documentLoader = await createTestFederation(() => actorId).createContext(new URL(gateway)).getDocumentLoader({ identifier: "alice" });
 	let keyId;
@@ -255,14 +273,14 @@ function createLoader(responses) {
 		});
 	};
 }
-async function deliver(body, gateways, { kv = new MemoryKvStore(), httpSignature = true, actor, documentLoader } = {}) {
+async function deliver(body, gateways, { kv = new MemoryKvStore(), httpSignature = true, actor, documentLoader, keyId = gatewayKeyId } = {}) {
 	documentLoader ??= createLoader({ [compatibleActorId(gateway)]: actor ?? await actorDocument(gateways) });
 	const unsigned = new Request("https://local.example/inbox", {
 		method: "POST",
 		body: JSON.stringify(body),
 		headers: { "Content-Type": "application/activity+json" }
 	});
-	const request = httpSignature ? await signRequest(unsigned, rsaPrivateKey2, gatewayKeyId) : unsigned;
+	const request = httpSignature ? await signRequest(unsigned, rsaPrivateKey2, keyId) : unsigned;
 	const context = createRequestContext({
 		federation: createFederation({ kv: new MemoryKvStore() }),
 		request,
@@ -332,6 +350,59 @@ test("handleInbox() requires proofs of portable actors despite gateway signature
 		dispatched: 1
 	});
 });
+const apKeyId = parseIri(`${actorId.href}?@gateway=${encodeURIComponent(gateway)}#main-key`);
+async function apActorDocument() {
+	const json = await new Person({
+		id: actorId,
+		inbox: parseIri(`${actorId.href}/inbox`),
+		gateways: [new URL(gateway)],
+		publicKey: new CryptographicKey({
+			id: parseIri(`${actorId.href}#main-key`),
+			owner: actorId,
+			publicKey: rsaPublicKey2.publicKey
+		})
+	}).toJsonLd({
+		format: "compact",
+		contextLoader: mockDocumentLoader
+	});
+	json["@context"] = [...json["@context"], "https://w3id.org/security/data-integrity/v1"];
+	return await sign(json);
+}
+test("handleInbox() requires proofs of portable actors despite signatures with keys at ap: key IDs", async () => {
+	const fetched = [];
+	const inner = createLoader({ [compatibleActorId(gateway)]: await apActorDocument() });
+	const documentLoader = (url, options) => {
+		fetched.push(url);
+		return inner(url, options);
+	};
+	assertEquals(await deliver(await createJson("unsigned"), [gateway], {
+		documentLoader,
+		keyId: apKeyId
+	}), {
+		status: 401,
+		dispatched: 0
+	});
+	assertEquals(fetched.some((url) => url.startsWith(compatibleActorId(gateway))), true);
+	assertEquals(await deliver(await sign(await createJson("signed")), [gateway], {
+		documentLoader,
+		keyId: apKeyId
+	}), {
+		status: 202,
+		dispatched: 1
+	});
+});
+test("RequestContext.getSignedKeyOwner() resolves keys at ap: key IDs", async () => {
+	const documentLoader = createLoader({ [compatibleActorId(gateway)]: await apActorDocument() });
+	const federation = new FederationImpl({
+		kv: new MemoryKvStore(),
+		contextLoaderFactory: () => mockDocumentLoader,
+		documentLoaderFactory: () => documentLoader
+	});
+	const request = await signRequest(new Request("https://local.example/notes/1", { headers: { Accept: "application/activity+json" } }), rsaPrivateKey2, apKeyId);
+	const ctx = federation.createContext(request, void 0);
+	assertEquals((await ctx.getSignedKey())?.id?.href, apKeyId.href);
+	assertEquals((await ctx.getSignedKeyOwner())?.id?.href, actorId.href);
+});
 test("handleInbox() fetches an unreachable gateway key once", async () => {
 	const fetched = [];
 	const documentLoader = (url) => {

package/dist/federation/portable-inbox.test.mjs

@@ -8,11 +8,11 @@ import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
 import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { p as signJsonLd } from "../ld-DQNTIrAe.mjs";
-import { i as signObject } from "../proof-CW8k0R1G.mjs";
-import { f as verifyRequestDetailed, l as signRequest } from "../http-BFeK9sBg.mjs";
+import { p as signJsonLd } from "../ld-CWDReGMZ.mjs";
+import { i as signObject } from "../proof-B5s-W6Sm.mjs";
+import { f as verifyRequestDetailed, l as signRequest } from "../http-CEx2SZjf.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { _ as coversDelivery, o as createFederation, v as forwardPortableInboxActivity, y as resolvePortableInboxForwardingOptions } from "../middleware-BdhvduR9.mjs";
+import { _ as coversDelivery, o as createFederation, v as forwardPortableInboxActivity, y as resolvePortableInboxForwardingOptions } from "../middleware-CAWRGSwH.mjs";
 import { Create, CryptographicKey, Follow, Note, Person, Tombstone } from "@fedify/vocab";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { exportDidKey, formatIri, parseIri } from "@fedify/vocab-runtime";
@@ -1089,6 +1089,11 @@ test("Federation.fetch() forwards portable inbox deliveries whose sending gatewa
 			sign: { keyId: bobKeyId },
 			fetches: false
 		},
+		{
+			name: "key at an ap: key ID",
+			sign: { keyId: parseIri(`ap+ef61://${did}/users/alice?@gateway=${encodeURIComponent(GATEWAY2)}#main-key`) },
+			fetches: false
+		},
 		{
 			name: "content-digest not covered",
 			sign: {

package/dist/federation/portable.test.mjs

@@ -8,10 +8,10 @@ import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertStrictEquals } from "../assert_strict_equals-CYvBmkpC.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { i as signObject, s as verifyPortableObjectProof } from "../proof-CW8k0R1G.mjs";
-import { l as signRequest } from "../http-BFeK9sBg.mjs";
+import { i as signObject, s as verifyPortableObjectProof } from "../proof-B5s-W6Sm.mjs";
+import { l as signRequest } from "../http-CEx2SZjf.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-BdhvduR9.mjs";
+import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-CAWRGSwH.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { Collection, Create, Note, Object as Object$1, Person, Tombstone, lookupObject } from "@fedify/vocab";
 import { mockDocumentLoader, test } from "@fedify/fixture";

package/dist/federation/send.test.mjs

@@ -10,10 +10,10 @@ import { t as assertNotEquals } from "../assert_not_equals-CpPK2t89.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { d as verifyRequest } from "../http-BFeK9sBg.mjs";
+import { d as verifyRequest } from "../http-CEx2SZjf.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { t as doesActorOwnKey } from "../owner-CCfdL83M.mjs";
-import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send--FORaIc4.mjs";
+import { t as doesActorOwnKey } from "../owner-CgoCOTUQ.mjs";
+import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-BAJvkdNL.mjs";
 import { Activity, Application, Endpoints, Group, Person, Service } from "@fedify/vocab";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, UrlError } from "@fedify/vocab-runtime";

package/dist/federation/tasks/enqueue.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../../kv-DCHkaJ9-.mjs";
 import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../tasks-dbCShlCb.mjs";
 import "../../testing-otQhu4aD.mjs";
-import { o as createFederation } from "../../middleware-BdhvduR9.mjs";
+import { o as createFederation } from "../../middleware-CAWRGSwH.mjs";
 import { n as ParallelMessageQueue } from "../../mq-Dm1Wmtm-.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { delay } from "es-toolkit";

package/dist/federation/tasks/tasks.test.mjs

@@ -4,8 +4,8 @@ globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../../kv-DCHkaJ9-.mjs";
 import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../tasks-dbCShlCb.mjs";
 import "../../testing-otQhu4aD.mjs";
-import { o as createFederation } from "../../middleware-BdhvduR9.mjs";
-import { r as createFederationBuilder } from "../../builder-B2bgGYbP.mjs";
+import { o as createFederation } from "../../middleware-CAWRGSwH.mjs";
+import { r as createFederationBuilder } from "../../builder-BI7H61zO.mjs";
 import { t as TaskCodec } from "../../codec-C6rTrpIp.mjs";
 import { t as InProcessMessageQueue } from "../../mq-Dm1Wmtm-.mjs";
 import { W3CTraceContextPropagator } from "@opentelemetry/core";

package/dist/federation/temporal.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { t as hasMalformedKnownTemporalLiteral } from "../temporal-CffY_XOJ.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "../temporal-BkCPJ_uC.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/temporal.test.ts
 test("hasMalformedKnownTemporalLiteral() detects expanded proof timestamps", async () => {

package/dist/federation/webfinger.test.mjs

@@ -6,7 +6,7 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import { t as assertNotEquals } from "../assert_not_equals-CpPK2t89.mjs";
 import "../std__assert-DvMDRPes.mjs";
-import { o as createFederation, s as handleWebFinger } from "../middleware-BdhvduR9.mjs";
+import { o as createFederation, s as handleWebFinger } from "../middleware-CAWRGSwH.mjs";
 import { Image, Link, Person, Tombstone } from "@fedify/vocab";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { parseIri } from "@fedify/vocab-runtime";

package/dist/{federation-B6IHuS6n.cjs → federation-DqDOPjWo.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-o8l4QeUY.cjs");
+const require_http = require("./http-DSYQQn23.cjs");
 const require_types = require("./types-Be2zbyeG.cjs");
-const require_portable_collection = require("./portable-collection-DXogVs__.cjs");
-const require_kv_cache = require("./kv-cache-BUkgZAcX.cjs");
+const require_portable_collection = require("./portable-collection-BD8fE3j3.cjs");
+const require_kv_cache = require("./kv-cache-BcsvaCCL.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_uri_template = require("@fedify/uri-template");
 let _fedify_vocab = require("@fedify/vocab");
@@ -1964,9 +1964,9 @@ const KEY_PROPERTIES = /* @__PURE__ */ new Set([
 *
 * The projection must expand to the parent's verified ID with the key as the
 * single value of `publicKey` or `assertionMethod`, and the key must be
-* nothing but a `CryptographicKey` or `Multikey` whose ID is a compatible
-* identifier of the parent plus a fragment, and whose owner or controller,
-* if any, is the parent.
+* nothing but a `CryptographicKey` or `Multikey` whose ID is the parent's
+* `ap:` or `ap+ef61:` URI, or its compatible identifier, plus a fragment,
+* and whose owner or controller, if any, is the parent.
 */
 async function isEmbeddedPortableKey(parent, member, key, parentId) {
 	const parentPortableId = getCanonicalPortableIdOf(parentId);
@@ -2024,21 +2024,16 @@ function getCanonicalPortableIdOf(id) {
 	}
 }
 /**
-* Checks whether an ID is a compatible identifier of the given portable
-* object plus a fragment.
+* Checks whether an ID is the given portable object's `ap:` or `ap+ef61:`
+* URI, or its compatible identifier, plus a non-empty fragment.  The ID is
+* compared as it is written, so an ID that URL parsing would turn into
+* the portable object's, e.g., through dot segments, is not one of its keys.
 */
 function isKeyIdOf(id, portableId) {
-	let url;
-	try {
-		if ((0, _fedify_vocab_runtime.fromCompatibleEf61Id)(id) == null) return false;
-		url = new URL(id);
-	} catch (error) {
-		if (error instanceof TypeError) return false;
-		throw error;
-	}
-	if (url.hash.length < 2) return false;
-	url.hash = "";
-	return require_http.getCanonicalPortableId(url) === portableId;
+	const canonical = require_http.getRawCanonicalPortableId(id);
+	if (canonical == null) return false;
+	const hash = canonical.indexOf("#");
+	return hash >= 0 && hash < canonical.length - 1 && canonical.slice(0, hash) === portableId;
 }
 /**
 * Checks whether a `@context` value defines no keyword aliases and no scoped
@@ -4671,7 +4666,7 @@ async function handleInboxInternal(request, parameters, span) {
 		"http_signatures.verified": httpSigKey != null,
 		"http_signatures.key_id": httpSigKey?.id?.href ?? ""
 	});
-	if (!skipSignatureVerification && !proofVerified && (isPortableActivity(activity) || isPortableGatewayKey(httpSigKey))) {
+	if (!skipSignatureVerification && !proofVerified && (isPortableActivity(activity) || isPortableActorKey(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,
@@ -5452,13 +5447,13 @@ const MIN_COMPONENTS = [
 	"@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.
+* Checks whether an HTTP Signature key is a key of an FEP-ef61 portable
+* actor, i.e., its ID is a compatible identifier or an `ap:` or `ap+ef61:`
+* URI, 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.isPortableId(key.ownerId);
+function isPortableActorKey(key) {
+	return key?.id != null && require_http.isPortableKeyId(key.id) && key.ownerId != null && require_http.isPortableId(key.ownerId);
 }
 /**
 * Checks whether an activity needs an Object Integrity Proof by its DID:
@@ -5895,7 +5890,7 @@ async function signOutgoingActivity(activity, candidates, options) {
 		hasProof = true;
 		break;
 	}
-	const keys = candidates.filter((c) => c.privateKey.algorithm.name === "Ed25519" && !require_http.isCompatibleKeyId(c.verificationMethod));
+	const keys = candidates.filter((c) => c.privateKey.algorithm.name === "Ed25519" && !require_http.isPortableKeyId(c.verificationMethod));
 	if (!hasProof && activity.id != null && require_http.isPortableId(activity.id)) return await sign(selectPortableActivityKey(activity, activity.id, keys));
 	if (keys.length < 1 || hasProof && !options.appendToExistingProofs) return {
 		activity,
@@ -7863,7 +7858,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 		const ldSignable = !require_http.hasPortableActor(activity);
 		for (const { keyId, privateKey } of keys) {
 			require_http.validateCryptoKey(privateKey, "private");
-			if (ldSignable && rsaKey == null && privateKey.algorithm.name === "RSASSA-PKCS1-v1_5" && !require_http.isCompatibleKeyId(keyId)) rsaKey = {
+			if (ldSignable && rsaKey == null && privateKey.algorithm.name === "RSASSA-PKCS1-v1_5" && !require_http.isPortableKeyId(keyId)) rsaKey = {
 				keyId,
 				privateKey
 			};

package/dist/{http-D76Py0M4.d.cts → http-C-x_OLSp.d.ts}

@@ -1,7 +1,7 @@
 /// <reference lib="esnext.temporal" />
 import { Actor, CryptographicKey, Multikey } from "@fedify/vocab";
-import { DocumentLoader } from "@fedify/vocab-runtime";
 import { MeterProvider, TracerProvider } from "@opentelemetry/api";
+import { DocumentLoader } from "@fedify/vocab-runtime";
 
 //#region src/sig/portable-key.d.ts
 /**
@@ -29,6 +29,28 @@ type PortableGatewayKeyResolution = {
   */
   readonly expires?: Temporal.Instant;
 };
+/**
+* The result of resolving a key of a portable actor at an `ap:` or
+* `ap+ef61:` key ID.
+* @internal
+*/
+type PortableActorKeyResolution = Exclude<PortableGatewayKeyResolution, {
+  readonly type: "legacy";
+}> | {
+  /**
+  * Whether the actor's document vouches for the key could not be
+  * determined, e.g., because no gateway could be reached.
+  */
+  readonly type: "unavailable";
+  readonly error: unknown;
+  /**
+  * Whether the failure can be cached as a failure to fetch the key, i.e.,
+  * every gateway failed to serve the actor's document at all.  A failure
+  * that is not cacheable comes with an error that has no HTTP status,
+  * since none of the statuses describes the lookup as a whole.
+  */
+  readonly cacheable: boolean;
+};
 //#endregion
 //#region src/sig/key.d.ts
 /**
@@ -119,17 +141,34 @@ interface FetchKeyOptions {
   */
   keyIdBoundByCaller?: boolean;
   /**
-  * Resolves a gateway key of an [FEP-ef61] portable actor, i.e., a key whose
-  * ID is a compatible identifier and dereferences to a portable actor's
-  * document.  Such a key is resolved only through this function, and is
-  * rejected if it is omitted, so that only HTTP Signature verification,
-  * which passes it, accepts gateway keys.  Object Integrity Proofs and
-  * Linked Data Signatures never do.
+  * Resolves keys of [FEP-ef61] portable actors, which only HTTP Signature
+  * verification passes, so that only it accepts them.  Object Integrity
+  * Proofs and Linked Data Signatures never do: such a key is rejected if
+  * this is omitted.
   *
   * [FEP-ef61]: https://w3id.org/fep/ef61
   * @internal
   */
-  portableGatewayKeyResolver?: (document: unknown, actor: Actor, keyId: URL) => Promise<PortableGatewayKeyResolution>;
+  portableKeyResolvers?: PortableKeyResolvers;
+}
+/**
+* Resolves keys of [FEP-ef61] portable actors for HTTP Signature
+* verification.  See {@link FetchKeyOptions.portableKeyResolvers}.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+* @internal
+*/
+interface PortableKeyResolvers {
+  /**
+  * Resolves a gateway key, i.e., a key whose ID is a compatible identifier
+  * and dereferences to a portable actor's document.
+  */
+  gatewayKey(document: unknown, actor: Actor, keyId: URL): Promise<PortableGatewayKeyResolution>;
+  /**
+  * Resolves a key of a portable actor itself, i.e., a key whose ID is an
+  * `ap:` or `ap+ef61:` URI.
+  */
+  actorKey(keyId: URL): Promise<PortableActorKeyResolution>;
 }
 /**
 * The result of {@link fetchKey}.
@@ -182,9 +221,11 @@ type FetchableKeyClass<T extends CryptographicKey | Multikey> = (new (...args: a
 * Gateway keys of [FEP-ef61] portable actors, i.e., keys whose IDs are
 * compatible identifiers that dereference to portable actor documents, are
 * not resolved by this function, as they only authenticate HTTP requests;
-* use `verifyRequest()` or `getKeyOwner()` for them instead.  Keys whose IDs
-* are compatible identifiers are never read from or written to the key
-* cache under their IDs, except for failures to fetch them.
+* use `verifyRequest()` or `getKeyOwner()` for them instead.  Nor are keys
+* of portable actors whose IDs are `ap:` or `ap+ef61:` URIs, for the same
+* reason.  Keys whose IDs are compatible identifiers or `ap:` or `ap+ef61:`
+* URIs are never read from or written to the key cache under their IDs,
+* except for failures to fetch them.
 *
 * [FEP-ef61]: https://w3id.org/fep/ef61
 * @template T The type of the key to fetch.  Either {@link CryptographicKey}
@@ -204,9 +245,11 @@ declare function fetchKey<T extends CryptographicKey | Multikey>(keyId: URL | st
 * Gateway keys of [FEP-ef61] portable actors, i.e., keys whose IDs are
 * compatible identifiers that dereference to portable actor documents, are
 * not resolved by this function, as they only authenticate HTTP requests;
-* use `verifyRequest()` or `getKeyOwner()` for them instead.  Keys whose IDs
-* are compatible identifiers are never read from or written to the key
-* cache under their IDs, except for failures to fetch them.
+* use `verifyRequest()` or `getKeyOwner()` for them instead.  Nor are keys
+* of portable actors whose IDs are `ap:` or `ap+ef61:` URIs, for the same
+* reason.  Keys whose IDs are compatible identifiers or `ap:` or `ap+ef61:`
+* URIs are never read from or written to the key cache under their IDs,
+* except for failures to fetch them.
 *
 * [FEP-ef61]: https://w3id.org/fep/ef61
 *

package/dist/{http-BFeK9sBg.mjs → http-CEx2SZjf.mjs}

@@ -1,11 +1,12 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-Be9xoxps.mjs";
-import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-DDE9S63Q.mjs";
+import { n as version, t as name } from "./deno-BXI_BLNy.mjs";
+import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-DxlVXwn5.mjs";
 import { i as validateAcceptSignature, n as fulfillAcceptSignature, r as parseAcceptSignature } from "./accept-CPVqki78.mjs";
-import { a as fetchKeyDetailed, c as validateCryptoKey, t as bypassKeyCacheReads } from "./key-Cc1b6pW9.mjs";
-import { n as verifyPortableGatewayKeyDocument } from "./portable-key-C-fPq_Yf.mjs";
+import { f as parseKeyIdString } from "./portable-key-id-Bg259c4Z.mjs";
+import { a as fetchKeyDetailed, c as validateCryptoKey, t as bypassKeyCacheReads } from "./key-C0giKuki.mjs";
+import { n as resolvePortableActorKey, r as verifyPortableGatewayKeyDocument } from "./portable-key-BXkgMpw1.mjs";
 import { getLogger } from "@logtape/logtape";
 import { CryptographicKey } from "@fedify/vocab";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
@@ -383,13 +384,18 @@ function keyFetchErrorResult(keyId, result) {
 		}
 	};
 }
+/**
+* Creates the resolvers of keys of FEP-ef61 portable actors, which HTTP
+* Signature verification alone passes to key lookups.
+*/
+function createPortableKeyResolvers(options) {
+	return {
+		gatewayKey: (document, actor, keyId) => verifyPortableGatewayKeyDocument(document, actor, keyId, options),
+		actorKey: (keyId) => resolvePortableActorKey(keyId, options)
+	};
+}
 function parseKeyId(value) {
-	if (value == null) return null;
-	try {
-		return new URL(value);
-	} catch {
-		return null;
-	}
+	return value == null ? null : parseKeyIdString(value);
 }
 function getKeyFetchErrorName(error) {
 	return error.name || error.constructor.name || "Error";
@@ -647,7 +653,7 @@ async function verifyRequestDraft(request, span, metricsContext, { documentLoade
 		keyCache,
 		tracerProvider,
 		meterProvider,
-		portableGatewayKeyResolver: (document, actor, keyId) => verifyPortableGatewayKeyDocument(document, actor, keyId, {
+		portableKeyResolvers: createPortableKeyResolvers({
 			documentLoader,
 			contextLoader,
 			keyCache,
@@ -867,7 +873,7 @@ async function verifyRequestRfc9421(request, span, metricsContext, { documentLoa
 			keyCache,
 			tracerProvider,
 			meterProvider,
-			portableGatewayKeyResolver: (document, actor, gatewayKeyId) => verifyPortableGatewayKeyDocument(document, actor, gatewayKeyId, {
+			portableKeyResolvers: createPortableKeyResolvers({
 				documentLoader,
 				contextLoader,
 				keyCache,

package/dist/{http-BrQgkJay.d.ts → http-CjezPjFX.d.cts}

@@ -1,7 +1,7 @@
 /// <reference lib="esnext.temporal" />
 import { Actor, CryptographicKey, Multikey } from "@fedify/vocab";
-import { MeterProvider, TracerProvider } from "@opentelemetry/api";
 import { DocumentLoader } from "@fedify/vocab-runtime";
+import { MeterProvider, TracerProvider } from "@opentelemetry/api";
 
 //#region src/sig/portable-key.d.ts
 /**
@@ -29,6 +29,28 @@ type PortableGatewayKeyResolution = {
   */
   readonly expires?: Temporal.Instant;
 };
+/**
+* The result of resolving a key of a portable actor at an `ap:` or
+* `ap+ef61:` key ID.
+* @internal
+*/
+type PortableActorKeyResolution = Exclude<PortableGatewayKeyResolution, {
+  readonly type: "legacy";
+}> | {
+  /**
+  * Whether the actor's document vouches for the key could not be
+  * determined, e.g., because no gateway could be reached.
+  */
+  readonly type: "unavailable";
+  readonly error: unknown;
+  /**
+  * Whether the failure can be cached as a failure to fetch the key, i.e.,
+  * every gateway failed to serve the actor's document at all.  A failure
+  * that is not cacheable comes with an error that has no HTTP status,
+  * since none of the statuses describes the lookup as a whole.
+  */
+  readonly cacheable: boolean;
+};
 //#endregion
 //#region src/sig/key.d.ts
 /**
@@ -119,17 +141,34 @@ interface FetchKeyOptions {
   */
   keyIdBoundByCaller?: boolean;
   /**
-  * Resolves a gateway key of an [FEP-ef61] portable actor, i.e., a key whose
-  * ID is a compatible identifier and dereferences to a portable actor's
-  * document.  Such a key is resolved only through this function, and is
-  * rejected if it is omitted, so that only HTTP Signature verification,
-  * which passes it, accepts gateway keys.  Object Integrity Proofs and
-  * Linked Data Signatures never do.
+  * Resolves keys of [FEP-ef61] portable actors, which only HTTP Signature
+  * verification passes, so that only it accepts them.  Object Integrity
+  * Proofs and Linked Data Signatures never do: such a key is rejected if
+  * this is omitted.
   *
   * [FEP-ef61]: https://w3id.org/fep/ef61
   * @internal
   */
-  portableGatewayKeyResolver?: (document: unknown, actor: Actor, keyId: URL) => Promise<PortableGatewayKeyResolution>;
+  portableKeyResolvers?: PortableKeyResolvers;
+}
+/**
+* Resolves keys of [FEP-ef61] portable actors for HTTP Signature
+* verification.  See {@link FetchKeyOptions.portableKeyResolvers}.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+* @internal
+*/
+interface PortableKeyResolvers {
+  /**
+  * Resolves a gateway key, i.e., a key whose ID is a compatible identifier
+  * and dereferences to a portable actor's document.
+  */
+  gatewayKey(document: unknown, actor: Actor, keyId: URL): Promise<PortableGatewayKeyResolution>;
+  /**
+  * Resolves a key of a portable actor itself, i.e., a key whose ID is an
+  * `ap:` or `ap+ef61:` URI.
+  */
+  actorKey(keyId: URL): Promise<PortableActorKeyResolution>;
 }
 /**
 * The result of {@link fetchKey}.
@@ -182,9 +221,11 @@ type FetchableKeyClass<T extends CryptographicKey | Multikey> = (new (...args: a
 * Gateway keys of [FEP-ef61] portable actors, i.e., keys whose IDs are
 * compatible identifiers that dereference to portable actor documents, are
 * not resolved by this function, as they only authenticate HTTP requests;
-* use `verifyRequest()` or `getKeyOwner()` for them instead.  Keys whose IDs
-* are compatible identifiers are never read from or written to the key
-* cache under their IDs, except for failures to fetch them.
+* use `verifyRequest()` or `getKeyOwner()` for them instead.  Nor are keys
+* of portable actors whose IDs are `ap:` or `ap+ef61:` URIs, for the same
+* reason.  Keys whose IDs are compatible identifiers or `ap:` or `ap+ef61:`
+* URIs are never read from or written to the key cache under their IDs,
+* except for failures to fetch them.
 *
 * [FEP-ef61]: https://w3id.org/fep/ef61
 * @template T The type of the key to fetch.  Either {@link CryptographicKey}
@@ -204,9 +245,11 @@ declare function fetchKey<T extends CryptographicKey | Multikey>(keyId: URL | st
 * Gateway keys of [FEP-ef61] portable actors, i.e., keys whose IDs are
 * compatible identifiers that dereference to portable actor documents, are
 * not resolved by this function, as they only authenticate HTTP requests;
-* use `verifyRequest()` or `getKeyOwner()` for them instead.  Keys whose IDs
-* are compatible identifiers are never read from or written to the key
-* cache under their IDs, except for failures to fetch them.
+* use `verifyRequest()` or `getKeyOwner()` for them instead.  Nor are keys
+* of portable actors whose IDs are `ap:` or `ap+ef61:` URIs, for the same
+* reason.  Keys whose IDs are compatible identifiers or `ap:` or `ap+ef61:`
+* URIs are never read from or written to the key cache under their IDs,
+* except for failures to fetch them.
 *
 * [FEP-ef61]: https://w3id.org/fep/ef61
 *