@fedify/fedify 2.4.0-dev.2122 → 2.4.0-dev.2129

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

@@ -0,0 +1,358 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { n as exportJwk } from "../key-DolJjJab.mjs";
+import { o as verifyObject, s as verifyPortableObjectProof } from "../proof-B4_0E-KU.mjs";
+import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
+import { n as FederationImpl } from "../middleware-DN3MdTDg.mjs";
+import { Create, DataIntegrityProof, Note, OrderedCollection, Person, traverseCollection } from "@fedify/vocab";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { FetchError, encodeMultibase, exportDidKey } from "@fedify/vocab-runtime";
+import serialize from "json-canon";
+//#region src/federation/portable-chain.test.ts
+const did = await exportDidKey(ed25519PublicKey.publicKey);
+const keyId = `${did}#${did.slice(8)}`;
+const GATEWAY = "https://gw.example";
+const context = [
+	"https://www.w3.org/ns/activitystreams",
+	"https://w3id.org/security/data-integrity/v1",
+	"https://w3id.org/fep/ef61"
+];
+function compatible(path, gateway = GATEWAY) {
+	return `${gateway}/.well-known/apgateway/${did}${path}`;
+}
+async function sign(document, proofOptions = {}) {
+	const proofConfig = {
+		"@context": document["@context"],
+		...proofOptions,
+		type: "DataIntegrityProof",
+		cryptosuite: "eddsa-jcs-2022",
+		verificationMethod: keyId,
+		proofPurpose: "assertionMethod",
+		created: "2023-02-24T23:36:38Z"
+	};
+	const encoder = new TextEncoder();
+	const digest = /* @__PURE__ */ new Uint8Array(64);
+	digest.set(new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(serialize(proofConfig)))), 0);
+	digest.set(new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(serialize(document)))), 32);
+	const signature = await crypto.subtle.sign("Ed25519", ed25519PrivateKey, digest);
+	return {
+		...document,
+		proof: {
+			...proofConfig,
+			proofValue: new TextDecoder().decode(encodeMultibase("base58btc", new Uint8Array(signature)))
+		}
+	};
+}
+function note(path, content = "A portable note") {
+	return {
+		"@context": context,
+		id: compatible(path),
+		type: "Note",
+		attributedTo: compatible("/actor"),
+		content
+	};
+}
+function activity(object, id = compatible("/activities/1")) {
+	return {
+		"@context": context,
+		id,
+		type: "Create",
+		actor: compatible("/actor"),
+		object
+	};
+}
+function actor() {
+	return {
+		"@context": context,
+		id: compatible("/actor"),
+		type: "Person",
+		inbox: compatible("/actor/inbox"),
+		outbox: compatible("/actor/outbox"),
+		gateways: [GATEWAY]
+	};
+}
+function createLoader(responses) {
+	const fetched = [];
+	const loader = (url) => {
+		url = url.replace(/^ap\+ef61:/, "ap:");
+		fetched.push(url);
+		const document = responses[url];
+		if (document == null) {
+			if (!URL.canParse(url)) return Promise.reject(/* @__PURE__ */ new Error(`Not found: ${url}`));
+			if (!url.includes("/.well-known/apgateway/")) return mockDocumentLoader(url);
+			return Promise.reject(new FetchError(url, "HTTP 404", new Response(null, { status: 404 })));
+		}
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: structuredClone(document)
+		});
+	};
+	return Object.assign(loader, { fetched });
+}
+function createFederation(documentLoader, queue) {
+	return new FederationImpl({
+		kv: new MemoryKvStore(),
+		queue,
+		manuallyStartQueue: true,
+		contextLoaderFactory: () => mockDocumentLoader,
+		documentLoaderFactory: () => documentLoader
+	});
+}
+test("Context.verifyPortableObject", async (t) => {
+	const signed = await sign(note("/notes/1"));
+	const ctx = createFederation(createLoader({})).createContext(new URL("https://example.com/"));
+	await t.step("is an own property that survives spreading", () => {
+		assert(Object.hasOwn(ctx, "verifyPortableObject"));
+		assert({ ...ctx }.verifyPortableObject === ctx.verifyPortableObject);
+		assert(ctx.clone(void 0).verifyPortableObject != null);
+	});
+	await t.step("verifies portable objects with the context's loaders", async () => {
+		assertEquals((await ctx.verifyPortableObject(signed, {})).verified, true);
+		assertEquals((await ctx.verifyPortableObject(note("/notes/1"), {})).verified, false);
+		assertEquals((await ctx.verifyPortableObject({
+			...signed,
+			content: "Forged"
+		}, {})).verified, false);
+	});
+});
+test("accessors given a Context verify references of compatible-ID objects", async (t) => {
+	const signed = await sign(note("/notes/1"));
+	const create = () => Create.fromJsonLd(activity(compatible("/notes/1")), { contextLoader: mockDocumentLoader });
+	await t.step("a signed object at the reference", async () => {
+		const loader = createLoader({ [compatible("/notes/1")]: signed });
+		const ctx = createFederation(loader).createContext(new URL("https://example.com/"));
+		const object = await (await create()).getObject(ctx);
+		assertInstanceOf(object, Note);
+		assertEquals(object.content, "A portable note");
+		assertEquals(loader.fetched, [compatible("/notes/1")]);
+	});
+	await t.step("an unsigned object at the reference", async () => {
+		const ctx = createFederation(createLoader({ [compatible("/notes/1")]: note("/notes/1") })).createContext(new URL("https://example.com/"));
+		assertEquals(await (await create()).getObject(ctx), null);
+	});
+	await t.step("a forged object at the reference", async () => {
+		const ctx = createFederation(createLoader({ [compatible("/notes/1")]: {
+			...signed,
+			content: "Forged"
+		} })).createContext(new URL("https://example.com/"));
+		assertEquals(await (await create()).getObject(ctx), null);
+	});
+	await t.step("an ordinary object's compatible reference", async () => {
+		const loader = createLoader({ [compatible("/notes/1")]: note("/notes/1") });
+		const ctx = createFederation(loader).createContext(new URL("https://example.com/"));
+		const create = await Create.fromJsonLd(activity(compatible("/notes/1"), "https://example.com/activities/1"), { contextLoader: mockDocumentLoader });
+		assertEquals(await create.getObject(ctx), null);
+		assertInstanceOf(await create.getObject({
+			documentLoader: loader,
+			contextLoader: mockDocumentLoader
+		}), Note);
+	});
+});
+function createRecordingQueue() {
+	const queued = [];
+	return {
+		queued,
+		queue: {
+			enqueue(message) {
+				queued.push(message);
+				return Promise.resolve();
+			},
+			listen() {
+				return Promise.resolve();
+			}
+		}
+	};
+}
+test("inbox listeners dereference references of compatible-ID activities without options", async (t) => {
+	const signedNote = await sign(note("/notes/1"));
+	const signedCreate = await sign(activity(compatible("/notes/1")));
+	for (const queued of [false, true]) for (const [label, served] of [["signed", signedNote], ["unsigned", note("/notes/1")]]) await t.step(`${label} object${queued ? " through a queue" : ""}`, async () => {
+		const loader = createLoader({ [compatible("/notes/1")]: served });
+		const { queue, queued: messages } = createRecordingQueue();
+		const federation = createFederation(loader, queued ? queue : void 0);
+		const results = [];
+		federation.setActorDispatcher("/users/{identifier}", () => null);
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, async (_ctx, create) => {
+			const object = await create.getObject();
+			assert(object == null || object instanceof Note);
+			results.push(object);
+		});
+		assertEquals((await federation.fetch(new Request("https://example.com/inbox", {
+			method: "POST",
+			headers: { "Content-Type": "application/activity+json" },
+			body: JSON.stringify(signedCreate)
+		}), { contextData: void 0 })).status, 202);
+		if (queued) {
+			assertEquals(messages.length, 1);
+			assertEquals(messages[0].type, "inbox");
+			await federation.processQueuedTask(void 0, messages[0]);
+		}
+		assertEquals(results.length, 1);
+		if (label === "signed") {
+			assertInstanceOf(results[0], Note);
+			assertEquals(results[0].content, "A portable note");
+		} else assertEquals(results[0], null);
+		assertEquals(loader.fetched, [compatible("/notes/1")]);
+	});
+});
+test("verifyObject() does not leave its proof verifier to returned objects", async () => {
+	const proofUrl = `ap://${did}/proofs/1`;
+	const { proof, ...document } = await sign(activity(compatible("/notes/1")), { id: proofUrl });
+	const referenced = {
+		...document,
+		"https://w3id.org/security#proof": [{ "@graph": [proof] }, { "@graph": [{ "@id": proofUrl }] }]
+	};
+	const loader = createLoader({ [proofUrl]: proof });
+	const verifier = () => Promise.resolve({ verified: false });
+	for (const verifyPortableObject of [void 0, verifier]) {
+		const create = await verifyObject(Create, referenced, {
+			contextLoader: mockDocumentLoader,
+			documentLoader: loader,
+			verifyPortableObject
+		});
+		assertInstanceOf(create, Create);
+		assert(loader.fetched.includes(proofUrl));
+		const proofs = await Array.fromAsync(create.getProofs());
+		assertEquals(proofs.length, 2);
+		for (const p of proofs) {
+			assertInstanceOf(p, DataIntegrityProof);
+			assert(p._verifyPortableObject === verifyPortableObject);
+		}
+		assert(create._verifyPortableObject === verifyPortableObject);
+	}
+});
+test("Context.lookupObject() applies the gateway policy to unsecured collections", async (t) => {
+	const outbox = {
+		"@context": context,
+		id: compatible("/actor/outbox"),
+		type: "OrderedCollection",
+		attributedTo: compatible("/actor"),
+		orderedItems: [compatible("/notes/1")]
+	};
+	const signedActor = await sign(actor());
+	await t.step("from a listed gateway", async () => {
+		const ctx = createFederation(createLoader({
+			[compatible("/actor")]: signedActor,
+			[compatible("/actor/outbox")]: outbox,
+			[compatible("/notes/1")]: note("/notes/1")
+		})).createContext(new URL("https://example.com/"));
+		const collection = await ctx.lookupObject(compatible("/actor/outbox"));
+		assertInstanceOf(collection, OrderedCollection);
+		assertEquals(await Array.fromAsync(collection.getItems()), []);
+		assertEquals(await Array.fromAsync(traverseCollection(collection, ctx)), []);
+		assertEquals(await ctx.lookupObject(compatible("/actor/outbox"), { verifyPortableObject: verifyPortableObjectProof }), null);
+	});
+	await t.step("from an unlisted gateway", async () => {
+		const evil = "https://evil.example";
+		assertEquals(await createFederation(createLoader({
+			[compatible("/actor", evil)]: signedActor,
+			[compatible("/actor/outbox", evil)]: {
+				...outbox,
+				id: compatible("/actor/outbox", evil)
+			}
+		})).createContext(new URL("https://example.com/")).lookupObject(compatible("/actor/outbox", evil)), null);
+	});
+	await t.step("with signed items", async () => {
+		const collection = await createFederation(createLoader({
+			[compatible("/actor")]: signedActor,
+			[compatible("/actor/outbox")]: outbox,
+			[compatible("/notes/1")]: await sign(note("/notes/1"))
+		})).createContext(new URL("https://example.com/")).lookupObject(compatible("/actor/outbox"));
+		assertInstanceOf(collection, OrderedCollection);
+		const items = await Array.fromAsync(collection.getItems());
+		assertEquals(items.length, 1);
+		assertInstanceOf(items[0], Note);
+	});
+});
+test("traverseCollection() with a Context verifies pages and items of portable collections", async () => {
+	const loader = createLoader({
+		[compatible("/actor")]: await sign(actor()),
+		[compatible("/actor/outbox")]: {
+			"@context": context,
+			id: compatible("/actor/outbox"),
+			type: "OrderedCollection",
+			first: compatible("/actor/outbox/1")
+		},
+		[compatible("/actor/outbox/1")]: {
+			"@context": context,
+			id: compatible("/actor/outbox/1"),
+			type: "OrderedCollectionPage",
+			partOf: compatible("/actor/outbox"),
+			orderedItems: [compatible("/notes/1"), compatible("/notes/2")]
+		},
+		[compatible("/notes/1")]: await sign(note("/notes/1")),
+		[compatible("/notes/2")]: note("/notes/2", "Unsigned")
+	});
+	const ctx = createFederation(loader).createContext(new URL("https://example.com/"));
+	const outbox = await (await Person.fromJsonLd(actor(), { contextLoader: mockDocumentLoader })).getOutbox(ctx);
+	assertInstanceOf(outbox, OrderedCollection);
+	const items = await Array.fromAsync(traverseCollection(outbox, ctx));
+	assertEquals(items.length, 1);
+	assertInstanceOf(items[0], Note);
+	assertEquals(items[0].content, "A portable note");
+	let error;
+	try {
+		await items[0].getAttribution({ documentLoader: loader });
+	} catch (e) {
+		error = e;
+	}
+	assertInstanceOf(error, TypeError);
+	assertInstanceOf(await items[0].getAttribution(ctx), Person);
+});
+test("onOutboxError receives activities that verify portable objects by default", async () => {
+	const loader = createLoader({ [compatible("/notes/1")]: await sign(note("/notes/1")) });
+	const received = [];
+	const federation = new FederationImpl({
+		kv: new MemoryKvStore(),
+		queue: createRecordingQueue().queue,
+		manuallyStartQueue: true,
+		contextLoaderFactory: () => mockDocumentLoader,
+		documentLoaderFactory: () => loader,
+		authenticatedDocumentLoaderFactory: () => loader,
+		onOutboxError: async (_error, activity) => {
+			try {
+				received.push(await activity?.getObject());
+			} catch (error) {
+				received.push(error);
+			}
+		}
+	});
+	const message = {
+		type: "outbox",
+		id: crypto.randomUUID(),
+		baseUrl: "https://example.com",
+		keys: [{
+			keyId: rsaPublicKey2.id.href,
+			privateKey: await exportJwk(rsaPrivateKey2)
+		}],
+		activity: await sign(activity(compatible("/notes/1"))),
+		activityId: compatible("/activities/1"),
+		activityType: "https://www.w3.org/ns/activitystreams#Create",
+		inbox: "https://remote.example/inbox",
+		sharedInbox: false,
+		started: (/* @__PURE__ */ new Date()).toISOString(),
+		attempt: 0,
+		headers: {},
+		traceContext: {}
+	};
+	esm_default.spyGlobal();
+	esm_default.post("https://remote.example/inbox", 500);
+	try {
+		await federation.processQueuedTask(void 0, message);
+	} finally {
+		esm_default.hardReset();
+	}
+	assertEquals(received.length, 1);
+	assertInstanceOf(received[0], Note);
+	assertEquals(loader.fetched, [compatible("/notes/1")]);
+});
+//#endregion
+export {};

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

@@ -2,15 +2,15 @@ import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
-import { r as createRequestContext, t as createInboxContext } from "../context-CoNRxGYp.mjs";
+import { r as createRequestContext, t as createInboxContext } from "../context-DfSVPcJ8.mjs";
 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-u4JOD4iO.mjs";
-import { l as signRequest } from "../http-B9BQDNIy.mjs";
+import { p as signJsonLd } from "../ld-Dwc176V4.mjs";
+import { l as signRequest } from "../http-BpOiZE09.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-CgOqRkK-.mjs";
+import { f as handleInbox, n as FederationImpl, o as createFederation } from "../middleware-DN3MdTDg.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-u4JOD4iO.mjs";
-import { i as signObject } from "../proof-BCOg7Njv.mjs";
-import { f as verifyRequestDetailed, l as signRequest } from "../http-B9BQDNIy.mjs";
+import { p as signJsonLd } from "../ld-Dwc176V4.mjs";
+import { i as signObject } from "../proof-B4_0E-KU.mjs";
+import { f as verifyRequestDetailed, l as signRequest } from "../http-BpOiZE09.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-CgOqRkK-.mjs";
+import { _ as coversDelivery, o as createFederation, v as forwardPortableInboxActivity, y as resolvePortableInboxForwardingOptions } from "../middleware-DN3MdTDg.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-BCOg7Njv.mjs";
-import { l as signRequest } from "../http-B9BQDNIy.mjs";
+import { i as signObject, s as verifyPortableObjectProof } from "../proof-B4_0E-KU.mjs";
+import { l as signRequest } from "../http-BpOiZE09.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-CgOqRkK-.mjs";
+import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-DN3MdTDg.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-B9BQDNIy.mjs";
+import { d as verifyRequest } from "../http-BpOiZE09.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-CPFM-sqo.mjs";
-import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-C8eOPat3.mjs";
+import { t as doesActorOwnKey } from "../owner-BNHhwjNu.mjs";
+import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-Dpu5qbP5.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

@@ -3,8 +3,8 @@ import "urlpattern-polyfill";
 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-BWq1dCzx.mjs";
-import { o as createFederation } from "../../middleware-CgOqRkK-.mjs";
+import "../../testing-otQhu4aD.mjs";
+import { o as createFederation } from "../../middleware-DN3MdTDg.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

@@ -3,9 +3,9 @@ import "urlpattern-polyfill";
 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-BWq1dCzx.mjs";
-import { o as createFederation } from "../../middleware-CgOqRkK-.mjs";
-import { r as createFederationBuilder } from "../../builder-BCXywsZF.mjs";
+import "../../testing-otQhu4aD.mjs";
+import { o as createFederation } from "../../middleware-DN3MdTDg.mjs";
+import { r as createFederationBuilder } from "../../builder-C0bxZDL0.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-vjHOhBpy.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "../temporal-78JVR3GK.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

@@ -1,12 +1,12 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { r as createRequestContext } from "../context-CoNRxGYp.mjs";
+import { r as createRequestContext } from "../context-DfSVPcJ8.mjs";
 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-CgOqRkK-.mjs";
+import { o as createFederation, s as handleWebFinger } from "../middleware-DN3MdTDg.mjs";
 import { Image, Link, Person, Tombstone } from "@fedify/vocab";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { parseIri } from "@fedify/vocab-runtime";