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

package/dist/sig/portable-key.test.mjs

@@ -1,13 +1,13 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { r as fetchKey } from "../key-IxTTC8Yf.mjs";
-import { l as verifyRequest, s as signRequest } from "../http-CCJ97Jql.mjs";
+import { r as fetchKey } from "../key-Dwm4VswT.mjs";
+import { l as verifyRequest, s as signRequest } from "../http-B2ftY0Ha.mjs";
 import { c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-DGbYmXqU.mjs";
+import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-Cgx2Dc7I.mjs";
 import { Create, CryptographicKey, Multikey, Person } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
-import { FetchError, encodeMultibase, exportDidKey, parseIri, preloadedContexts } from "@fedify/vocab-runtime";
+import { FetchError, encodeMultibase, exportDidKey, exportSpki, parseIri, preloadedContexts } from "@fedify/vocab-runtime";
 import serialize from "json-canon";
 import { deepStrictEqual, ok, strictEqual } from "node:assert/strict";
 //#region src/sig/portable-key.test.ts
@@ -129,7 +129,16 @@ test("verifyRequest() rejects gateway keys that portable actors do not vouch for
 		"an unsigned actor document": unsigned,
 		"an actor document signed by another DID": await sign(unsigned, otherKeyPair.privateKey, `${otherDid}#${otherDid.slice(8)}`),
 		"an unlisted gateway": await sign(await actorJson({ gateways: [gw2] })),
-		"a key missing from assertionMethod": await sign(await actorJson({ assertionMethod: false })),
+		"a key missing from both assertionMethod and publicKey": await sign(await actorJson({
+			assertionMethod: false,
+			publicKey: null
+		})),
+		"a key referred to by URL in assertionMethod, embedded in publicKey": await sign({
+			...await actorJson({ assertionMethod: false }),
+			assertionMethod: [keyId.href]
+		}),
+		"a key only in publicKey without an owner": await sign(withoutPublicKeyOwner(await actorJson({ assertionMethod: false }))),
+		"two keys with the same ID in publicKey": await sign(await duplicatePublicKey(await actorJson({ assertionMethod: false }))),
 		"a key referred to by URL": await sign({
 			...await actorJson({
 				publicKey: null,
@@ -154,18 +163,175 @@ test("verifyRequest() rejects gateway keys that portable actors do not vouch for
 		contextLoader
 	}), null);
 });
-test("verifyRequest() keeps web-origin trust for compatible-ID actors", async () => {
-	const id = compatibleId(gw1);
-	const documentLoader = createLoader({ [id]: await actorJson({
-		id,
-		gateways: [gw1]
+function withoutPublicKeyOwner(json) {
+	const { owner: _, ...publicKey } = json.publicKey;
+	return {
+		...json,
+		publicKey
+	};
+}
+async function duplicatePublicKey(json) {
+	const publicKey = json.publicKey;
+	return {
+		...json,
+		publicKey: [publicKey, {
+			...publicKey,
+			publicKeyPem: await exportSpki(rsaPublicKey3.publicKey)
+		}]
+	};
+}
+test("verifyRequest() accepts gateway keys referred to by URL in publicKey", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign({
+		...await actorJson({ publicKey: null }),
+		publicKey: keyId.href
 	}) });
+	strictEqual((await verifyRequest(await signedRequest(), {
+		documentLoader,
+		contextLoader
+	}))?.id?.href, keyId.href);
+});
+test("verifyRequest() accepts gateway keys only in publicKey", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await actorJson({ assertionMethod: false })) });
 	const key = await verifyRequest(await signedRequest(), {
 		documentLoader,
 		contextLoader
 	});
 	strictEqual(key?.id?.href, keyId.href);
+	strictEqual(key?.ownerId?.href, parseIri(actorId).href);
+});
+test("verifyRequest() resolves gateway keys of compatible-ID actors", async () => {
+	const id = compatibleId(gw1);
+	const signed = await sign(await actorJson({
+		id,
+		gateways: [gw1]
+	}));
+	let key = await verifyRequest(await signedRequest(), {
+		documentLoader: createLoader({ [id]: signed }),
+		contextLoader
+	});
+	strictEqual(key?.id?.href, keyId.href);
 	strictEqual(key?.ownerId?.href, id);
+	key = await verifyRequest(await signedRequest(), {
+		documentLoader: createLoader({ [id]: await sign(await actorJson({
+			id,
+			gateways: [gw1],
+			assertionMethod: false
+		})) }),
+		contextLoader
+	});
+	strictEqual(key?.id?.href, keyId.href);
+	const evil = "https://evil.example";
+	const evilId = compatibleId(evil);
+	const evilKeyId = new URL(`${evilId}#main-key`);
+	const unsigned = await actorJson({
+		id: evilId,
+		gateways: [evil],
+		key: evilKeyId
+	});
+	const documentLoader = createLoader({ [evilId]: unsigned });
+	strictEqual(await verifyRequest(await signedRequest(void 0, evilKeyId), {
+		documentLoader,
+		contextLoader
+	}), null);
+	strictEqual(await getKeyOwner(evilKeyId, {
+		documentLoader,
+		contextLoader
+	}), null);
+	strictEqual(await verifyRequest(await signedRequest(), {
+		documentLoader: createLoader({ [id]: await sign(await actorJson({
+			id,
+			gateways: [gw1]
+		}), otherKeyPair.privateKey, `${otherDid}#${otherDid.slice(8)}`) }),
+		contextLoader
+	}), null);
+});
+test("keys at ordinary URLs cannot belong to portable actors", async () => {
+	const evil = "https://evil.example";
+	const evilActorId = compatibleId(evil);
+	const evilKeyId = new URL(`${evil}/keys/1`);
+	const options = {
+		documentLoader: createLoader({
+			[evilKeyId.href]: {
+				"@context": "https://w3id.org/security/v1",
+				id: evilKeyId.href,
+				type: "Key",
+				owner: evilActorId,
+				publicKeyPem: await exportSpki(gatewayPublicKey)
+			},
+			[evilActorId]: await actorJson({
+				id: evilActorId,
+				gateways: [evil],
+				key: evilKeyId,
+				assertionMethod: false
+			})
+		}),
+		contextLoader
+	};
+	strictEqual(await verifyRequest(await signedRequest(void 0, evilKeyId), options), null);
+	strictEqual((await fetchKey(evilKeyId, CryptographicKey, options)).key, null);
+	strictEqual(await getKeyOwner(evilKeyId, options), null);
+	const key = new CryptographicKey({
+		id: evilKeyId,
+		owner: new URL(evilActorId),
+		publicKey: gatewayPublicKey
+	});
+	strictEqual(await getKeyOwner(key, options), null);
+	ok(!await doesActorOwnKey(new Create({
+		id: new URL(`${evil}/activities/1`),
+		actor: new URL(evilActorId)
+	}), key, options));
+	const actorKeyId = new URL(`${evil}/users/alice#main-key`);
+	for (const document of [await actorJson({
+		id: evilActorId,
+		gateways: [evil],
+		key: actorKeyId
+	}), withoutPublicKeyOwner(await actorJson({
+		id: evilActorId,
+		gateways: [evil],
+		key: actorKeyId,
+		assertionMethod: false
+	}))]) {
+		const actorOptions = {
+			documentLoader: createLoader({ [`${evil}/users/alice`]: document }),
+			contextLoader
+		};
+		strictEqual(await verifyRequest(await signedRequest(void 0, actorKeyId), actorOptions), null);
+		strictEqual((await fetchKey(actorKeyId, CryptographicKey, actorOptions)).key, null);
+		strictEqual(await getKeyOwner(actorKeyId, actorOptions), null);
+	}
+	const ownerKeyId = new URL(`${evil}/keys/2`);
+	const ownerOptions = {
+		documentLoader: createLoader({
+			[ownerKeyId.href]: {
+				"@context": "https://w3id.org/security/v1",
+				id: ownerKeyId.href,
+				type: "Key",
+				owner: `${evil}/users/bob`,
+				publicKeyPem: await exportSpki(gatewayPublicKey)
+			},
+			[`${evil}/users/bob`]: await actorJson({
+				id: evilActorId,
+				gateways: [evil],
+				key: ownerKeyId,
+				assertionMethod: false
+			})
+		}),
+		contextLoader
+	};
+	strictEqual(await getKeyOwner(ownerKeyId, ownerOptions), null);
+	strictEqual(await getKeyOwner(new CryptographicKey({
+		id: ownerKeyId,
+		owner: new URL(`${evil}/users/bob`),
+		publicKey: gatewayPublicKey
+	}), ownerOptions), null);
+	const keyCache = {
+		get: () => Promise.resolve(key),
+		set: () => Promise.resolve()
+	};
+	strictEqual((await fetchKey(evilKeyId, CryptographicKey, {
+		...options,
+		keyCache
+	})).key, null);
 });
 test("gateway keys are neither cached nor accepted outside HTTP Signatures", async () => {
 	const calls = [];

package/dist/sig/proof.test.mjs

@@ -10,10 +10,10 @@ import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
 import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-4IJqPYos.mjs";
-import { a as verifyObject, l as verifyProof, n as hasProofLike, o as verifyPortableObjectProof, r as signObject, t as createProof } from "../proof-CVL7JnZd.mjs";
-import { l as verifyRequest } from "../http-CCJ97Jql.mjs";
+import { i as signObject, n as createProof, o as verifyObject, r as hasProofLike, s as verifyPortableObjectProof, u as verifyProof } from "../proof-DVXC6nYz.mjs";
+import { l as verifyRequest } from "../http-B2ftY0Ha.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-dA0RswUV.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-DJKcsAiF.mjs";
 import { Create, DataIntegrityProof, Document, Multikey, Note, PUBLIC_COLLECTION, Place, Translation } from "@fedify/vocab";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { decodeMultibase, encodeMultibase, exportDidKey, exportMultibaseKey, formatIri, importMultibaseKey, parseIri } from "@fedify/vocab-runtime";
@@ -1064,6 +1064,45 @@ test("verifyPortableObjectProof()", async (t) => {
 			reason: { type: "missingProof" }
 		});
 	});
+	await t.step("treats compatible identifiers as portable IDs", async () => {
+		const compatibleActorId = `https://gateway.example/.well-known/apgateway/did:key:${portableDidMethod}/actor`;
+		const actor = {
+			"@context": portableContext,
+			id: compatibleActorId,
+			type: "Person",
+			inbox: `${compatibleActorId}/inbox`,
+			outbox: `${compatibleActorId}/outbox`
+		};
+		const signed = await signPortableJsonLd(actor);
+		const result = await verifyPortableObjectProof(signed, options);
+		assert(result.verified);
+		assertEquals(result.keys[0].id, portableKeyId);
+		assertEquals(signed.id, compatibleActorId);
+		assertEquals(await verifyPortableObjectProof(actor, options), {
+			verified: false,
+			reason: { type: "missingProof" }
+		});
+		const otherId = `https://gateway.example/.well-known/apgateway/did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK/activities/1`;
+		assertEquals(await verifyPortableObjectProof(await signPortableJsonLd({
+			"@context": portableContext,
+			id: otherId,
+			type: "Create",
+			actor: compatibleActorId,
+			object: "https://social.example/objects/1"
+		}), options), {
+			verified: false,
+			reason: {
+				type: "verificationMethodMismatch",
+				proofIndex: 0,
+				objectId: new URL(otherId),
+				verificationMethod: portableKeyId
+			}
+		});
+		await assertRejects(() => verifyPortableObjectProof({
+			...actor,
+			id: `https://user@gateway.example/.well-known/apgateway/did:key:${portableDidMethod}/actor`
+		}, options), TypeError);
+	});
 	await t.step("keeps non-portable documents outside the policy", async () => {
 		for (const document of [
 			{
@@ -1072,7 +1111,7 @@ test("verifyPortableObjectProof()", async (t) => {
 			},
 			{
 				...unsignedObject,
-				id: "https://gateway.example/.well-known/apgateway/did:key:z6MkAlice/objects/1"
+				id: "https://gateway.example/.well-known/apgateway/hl:zQmdfTbBqBPQ"
 			},
 			{
 				"@context": portableContext,
@@ -1804,6 +1843,70 @@ test("verifyObject() rejects did:key proofs from another portable attribution or
 		contextLoader: mockDocumentLoader
 	}), null);
 });
+async function signCompatibleNote(attribution, keyId) {
+	const context = ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"];
+	return await (await signObject(new Note({
+		id: new URL(`${attribution}/notes/1`),
+		attribution: new URL(attribution),
+		content: "Note of a compatible-ID actor"
+	}), ed25519PrivateKey, keyId, {
+		contextLoader: mockDocumentLoader,
+		context
+	})).toJsonLd({
+		format: "compact",
+		contextLoader: mockDocumentLoader,
+		context
+	});
+}
+test("verifyObject() authenticates compatible-ID attributions by DID proofs", async () => {
+	const did = await exportDidKey(ed25519PublicKey.publicKey);
+	const keyId = new URL(`${did}#${did.substring(8)}`);
+	const options = {
+		documentLoader() {
+			throw new TypeError("did:key must not use the document loader");
+		},
+		contextLoader: mockDocumentLoader
+	};
+	for (const gateway of ["https://gw1.example", "https://gw2.example"]) assertInstanceOf(await verifyObject(Note, await signCompatibleNote(`${gateway}/.well-known/apgateway/${did}/actor`, keyId), options), Note);
+	assertEquals(await verifyObject(Note, await signCompatibleNote("https://gw1.example/.well-known/apgateway/did:key:z6MkOther/actor", keyId), options), null);
+});
+test("verifyObject() does not trust compatible-ID actors by web origin", async () => {
+	const did = await exportDidKey(ed25519PublicKey.publicKey);
+	const attribution = `https://evil.example/.well-known/apgateway/${did}/actor`;
+	const keyId = new URL("https://evil.example/keys/1");
+	const documents = {
+		[keyId.href]: {
+			"@context": "https://w3id.org/security/multikey/v1",
+			id: keyId.href,
+			type: "Multikey",
+			controller: attribution,
+			publicKeyMultibase: await exportMultibaseKey(ed25519PublicKey.publicKey)
+		},
+		[attribution]: {
+			"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/multikey/v1"],
+			id: attribution,
+			type: "Person",
+			inbox: `${attribution}/inbox`,
+			assertionMethod: keyId.href
+		}
+	};
+	const fetched = [];
+	assertEquals(await verifyObject(Note, await signCompatibleNote(attribution, keyId), {
+		documentLoader: (url) => {
+			fetched.push(url);
+			const document = documents[url];
+			if (document == null) throw new TypeError(`Unexpected: ${url}`);
+			return Promise.resolve({
+				contextUrl: null,
+				documentUrl: url,
+				document
+			});
+		},
+		contextLoader: mockDocumentLoader
+	}), null);
+	assertEquals(fetched, [keyId.href]);
+	assertEquals(await verifyObject(Note, await signCompatibleNote(`https://user@gw.example/.well-known/apgateway/${did}/actor`, new URL(`${did}#${did.substring(8)}`)), { contextLoader: mockDocumentLoader }), null);
+});
 test("signObject() preserves FEP-22cd contexts through proof verification", async () => {
 	const did = await exportDidKey(ed25519PublicKey.publicKey);
 	const keyId = new URL(`${did}#${did.substring(8)}`);

package/dist/{sig-Dpy1B1Ad.js → sig-B5Ell7pO.js}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { f as verifyPortableObjectProof, ht as version, m as verifyPortableObjectProofWithRoot, mt as name } from "./http-aqh3yFdM.js";
-import "./owner-jH1z_YfD.js";
+import { h as verifyPortableObjectProofWithRoot, p as verifyPortableObjectProof, vt as name, yt as version } from "./http-DyT7DP1Y.js";
+import "./owner-DAGSC5gX.js";
 import { getLogger } from "@logtape/logtape";
 import { CollectionPage, Object as Object$1, isActor } from "@fedify/vocab";
 import { trace } from "@opentelemetry/api";
@@ -49,6 +49,8 @@ function getContextState(context) {
 }
 function canonicalize(id) {
 	try {
+		const portable = fromCompatibleEf61Id(id);
+		if (portable != null) return canonicalizePortableUri(formatIri(portable));
 		return canonicalizePortableUri(typeof id === "string" ? id : formatIri(id));
 	} catch (error) {
 		if (error instanceof TypeError) return null;
@@ -229,7 +231,20 @@ async function fetchOwner(candidate, options) {
 	const contextLoader = options.contextLoader ?? getDocumentLoader();
 	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
 	const tracer = tracerProvider.getTracer(name, version);
-	const gateways = options.gateways ?? (getPortableGatewayCandidates(candidate).length > 0 ? void 0 : options.gatewayHints);
+	let inferredGateways;
+	try {
+		const portable = fromCompatibleEf61Id(candidate);
+		if (portable != null) {
+			inferredGateways = [new URL(candidate.origin)];
+			candidate = portable;
+		}
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		logger.debug("The owner {owner} of a portable collection is a malformed compatible identifier.", { owner: candidate.href });
+		return null;
+	}
+	const gateways = options.gateways ?? (inferredGateways != null || getPortableGatewayCandidates(candidate).length > 0 ? void 0 : options.gatewayHints);
+	if (options.gateways != null) inferredGateways = void 0;
 	const span = tracer.startSpan("activitypub.lookup_object");
 	try {
 		const object = await dereferencePortableIri(candidate, {
@@ -237,6 +252,7 @@ async function fetchOwner(candidate, options) {
 			contextLoader,
 			tracerProvider,
 			gateways,
+			...inferredGateways == null ? {} : { inferredGateways },
 			verifyPortableObject: (document, verifierOptions) => verifyPortableObjectProof(document, {
 				...options,
 				...verifierOptions

package/dist/{sig-xoqy3ATq.cjs → sig-CXOKN4Br.cjs}

@@ -1,6 +1,6 @@
 const { URLPattern } = require("urlpattern-polyfill");
-const require_http = require("./http-Dvy_IwRa.cjs");
-require("./owner-BpOxL5PG.cjs");
+const require_http = require("./http-DSaSAN7X.cjs");
+require("./owner-szIZl4qI.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_vocab = require("@fedify/vocab");
 let _opentelemetry_api = require("@opentelemetry/api");
@@ -48,6 +48,8 @@ function getContextState(context) {
 }
 function canonicalize(id) {
 	try {
+		const portable = (0, _fedify_vocab_runtime.fromCompatibleEf61Id)(id);
+		if (portable != null) return (0, _fedify_vocab_runtime.canonicalizePortableUri)((0, _fedify_vocab_runtime.formatIri)(portable));
 		return (0, _fedify_vocab_runtime.canonicalizePortableUri)(typeof id === "string" ? id : (0, _fedify_vocab_runtime.formatIri)(id));
 	} catch (error) {
 		if (error instanceof TypeError) return null;
@@ -228,7 +230,20 @@ async function fetchOwner(candidate, options) {
 	const contextLoader = options.contextLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)();
 	const tracerProvider = options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider();
 	const tracer = tracerProvider.getTracer(require_http.name, require_http.version);
-	const gateways = options.gateways ?? ((0, _fedify_vocab_runtime_internal_portable_dereference.getPortableGatewayCandidates)(candidate).length > 0 ? void 0 : options.gatewayHints);
+	let inferredGateways;
+	try {
+		const portable = (0, _fedify_vocab_runtime.fromCompatibleEf61Id)(candidate);
+		if (portable != null) {
+			inferredGateways = [new URL(candidate.origin)];
+			candidate = portable;
+		}
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		logger.debug("The owner {owner} of a portable collection is a malformed compatible identifier.", { owner: candidate.href });
+		return null;
+	}
+	const gateways = options.gateways ?? (inferredGateways != null || (0, _fedify_vocab_runtime_internal_portable_dereference.getPortableGatewayCandidates)(candidate).length > 0 ? void 0 : options.gatewayHints);
+	if (options.gateways != null) inferredGateways = void 0;
 	const span = tracer.startSpan("activitypub.lookup_object");
 	try {
 		const object = await (0, _fedify_vocab_runtime_internal_portable_dereference.dereferencePortableIri)(candidate, {
@@ -236,6 +251,7 @@ async function fetchOwner(candidate, options) {
 			contextLoader,
 			tracerProvider,
 			gateways,
+			...inferredGateways == null ? {} : { inferredGateways },
 			verifyPortableObject: (document, verifierOptions) => require_http.verifyPortableObjectProof(document, {
 				...options,
 				...verifierOptions

package/dist/{temporal-DNJ1cNpr.mjs → temporal-CqpKGEPk.mjs}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { c as getNormalizationContextLoader } from "./ld-l0B9nREb.mjs";
+import { c as getNormalizationContextLoader } from "./ld-BYZOoDzZ.mjs";
 import jsonld from "@fedify/vocab-runtime/jsonld";
 //#region src/federation/temporal.ts
 function isPlainObject(value) {

package/dist/testing/kv.test.mjs

@@ -6,7 +6,7 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as ManualClockKvStore } from "../kv-DBRWVx3Q.mjs";
 import { n as baseOptions, o as stringSchema, t as MockQueue } from "../tasks-dbCShlCb.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
-import { o as createFederation } from "../middleware-BMgzqBtr.mjs";
+import { o as createFederation } from "../middleware-E_0IH72m.mjs";
 //#region src/testing/kv.test.ts
 test("ManualClockKvStore keeps an entry at its exact expiration instant", async () => {
 	const kv = new ManualClockKvStore();

package/dist/utils/docloader.test.mjs

@@ -5,9 +5,9 @@ import { t as esm_default } from "../esm-BHXXx4Wx.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 { l as verifyRequest } from "../http-CCJ97Jql.mjs";
+import { l as verifyRequest } from "../http-B2ftY0Ha.mjs";
 import { i as rsaPrivateKey2 } from "../keys-DIJNHW-Y.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-dA0RswUV.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-DJKcsAiF.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, UrlError } from "@fedify/vocab-runtime";
 //#region src/utils/docloader.test.ts

package/dist/utils/kv-cache.test.mjs

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as kvCache, t as MockKvStore } from "../kv-cache-Bwwbh-xR.mjs";
+import { n as kvCache, t as MockKvStore } from "../kv-cache-D0yYukqk.mjs";
 import { deepStrictEqual, throws } from "node:assert";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { preloadedContexts } from "@fedify/vocab-runtime";

package/dist/utils/mod.cjs

@@ -1,5 +1,5 @@
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_kv_cache = require("../kv-cache-BP69NV0P.cjs");
+const require_kv_cache = require("../kv-cache-BSJAlP4C.cjs");
 exports.getAuthenticatedDocumentLoader = require_kv_cache.getAuthenticatedDocumentLoader;
 exports.kvCache = require_kv_cache.kvCache;

package/dist/utils/mod.js

@@ -1,4 +1,4 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-Y6SDRSX6.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-DmroAz3M.js";
 export { getAuthenticatedDocumentLoader, kvCache };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/fedify",
-  "version": "2.4.0-dev.2077+c29a03d4",
+  "version": "2.4.0-dev.2093+e9706a54",
   "description": "An ActivityPub server framework",
   "keywords": [
     "ActivityPub",
@@ -151,10 +151,10 @@
     "structured-field-values": "^2.0.4",
     "temporal-polyfill": "^1.0.1",
     "urlpattern-polyfill": "^10.1.0",
-    "@fedify/uri-template": "2.4.0-dev.2077+c29a03d4",
-    "@fedify/vocab": "2.4.0-dev.2077+c29a03d4",
-    "@fedify/vocab-runtime": "2.4.0-dev.2077+c29a03d4",
-    "@fedify/webfinger": "2.4.0-dev.2077+c29a03d4"
+    "@fedify/uri-template": "2.4.0-dev.2093+e9706a54",
+    "@fedify/vocab": "2.4.0-dev.2093+e9706a54",
+    "@fedify/webfinger": "2.4.0-dev.2093+e9706a54",
+    "@fedify/vocab-runtime": "2.4.0-dev.2093+e9706a54"
   },
   "devDependencies": {
     "@std/assert": "npm:@jsr/std__assert@^0.226.0",
@@ -166,8 +166,8 @@
     "tsx": "^4.21.0",
     "typescript": "^6.0.0",
     "wrangler": "^4.17.0",
-    "@fedify/vocab-tools": "^2.4.0-dev.2077+c29a03d4",
-    "@fedify/fixture": "2.0.0"
+    "@fedify/fixture": "2.0.0",
+    "@fedify/vocab-tools": "^2.4.0-dev.2093+e9706a54"
   },
   "scripts": {
     "build:self": "tsdown",