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

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

@@ -1,4 +1,4 @@
-import "temporal-polyfill";
+import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
@@ -8,10 +8,10 @@ import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
 import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { i as signObject, s as verifyPortableObjectProof } from "../proof-xdPYGPaA.mjs";
-import { d as verifyRequest, l as signRequest } from "../http-BcLnr2do.mjs";
+import { i as signObject, s as verifyPortableObjectProof } from "../proof-CW8k0R1G.mjs";
+import { d as verifyRequest, l as signRequest } from "../http-BFeK9sBg.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-BpwKvOpU.mjs";
+import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-BdhvduR9.mjs";
 import { n as RouterError } from "../router-u5O5KCQr.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { Note, Person, Tombstone, lookupObject } from "@fedify/vocab";
@@ -53,6 +53,8 @@ const users = {
 	tampered: did,
 	https: did,
 	tombstone: did,
+	"signed-tombstone": did,
+	"wrong-key-tombstone": did,
 	"mutated-id": did,
 	compatible: did,
 	"a b/ç": did
@@ -88,6 +90,12 @@ function createTestFederation(options = {}) {
 				return await sign(actor.clone({ id: toCompatibleEf61Id(actor.id, ORIGIN) }));
 			}
 			case "tombstone": return new Tombstone({ id: ctx.getPortableActorUri(identifier, userDid) });
+			case "signed-tombstone": return await sign(new Tombstone({
+				id: ctx.getPortableActorUri(identifier, userDid),
+				formerType: Person,
+				deleted: Temporal.Instant.from("2026-01-01T00:00:00Z")
+			}));
+			case "wrong-key-tombstone": return await sign(new Tombstone({ id: ctx.getPortableActorUri(identifier, userDid) }), otherKeyPair.privateKey, otherKeyId);
 			case "unsigned": return await portableActor(ctx, identifier, userDid);
 			case "wrong-key": return await sign(await portableActor(ctx, identifier, userDid), otherKeyPair.privateKey, otherKeyId);
 			case "tampered": return (await sign(await portableActor(ctx, identifier, userDid))).clone({ name: "Tampered" });
@@ -260,6 +268,7 @@ test("Federation.fetch() serves portable actors through the actor dispatcher", a
 			gatewayRequest("/users/missing"),
 			gatewayRequest("/users/https"),
 			gatewayRequest("/users/tombstone"),
+			gatewayRequest("/users/tombstone", { method: "HEAD" }),
 			gatewayRequest("/users/alice", { authority: otherDid }),
 			gatewayRequest("/users/mutated-id")
 		]) {
@@ -278,13 +287,36 @@ test("Federation.fetch() serves portable actors through the actor dispatcher", a
 		for (const identifier of [
 			"unsigned",
 			"wrong-key",
-			"tampered"
+			"tampered",
+			"wrong-key-tombstone"
 		]) {
 			const response = await federation.fetch(gatewayRequest(`/users/${identifier}`), { contextData: void 0 });
 			assertEquals(response.status, 500, identifier);
 			assertEquals(await response.text(), "Internal server error.");
 		}
 	});
+	await t.step("serves a signed tombstone with 410 Gone", async () => {
+		const response = await federation.fetch(gatewayRequest("/users/signed-tombstone"), { contextData: void 0 });
+		assertEquals(response.status, 410);
+		assertEquals(response.headers.get("Content-Type"), PORTABLE_OBJECT_CONTENT_TYPE);
+		assertEquals(response.headers.get("Vary"), "Accept");
+		const json = await response.json();
+		assertEquals(json.type, "Tombstone");
+		assertEquals(json.id, `ap+ef61://${did}/users/signed-tombstone`);
+		assertEquals(json.deleted, "2026-01-01T00:00:00Z");
+		assertEquals((await verifyPortableObjectProof(json, { contextLoader: mockDocumentLoader })).verified, true);
+	});
+	await t.step("responds to HEAD for a tombstone without a body", async () => {
+		const response = await federation.fetch(gatewayRequest("/users/signed-tombstone", { method: "HEAD" }), { contextData: void 0 });
+		assertEquals(response.status, 410);
+		assertEquals(response.headers.get("Content-Type"), PORTABLE_OBJECT_CONTENT_TYPE);
+		assertEquals(response.body, null);
+	});
+	await t.step("keeps ordinary tombstone requests unchanged", async () => {
+		const response = await federation.fetch(new Request(`${ORIGIN}/users/signed-tombstone`, { headers: { Accept: ACCEPT } }), { contextData: void 0 });
+		assertEquals(response.status, 410);
+		assertEquals(response.headers.get("Content-Type"), "application/activity+json");
+	});
 	await t.step("keeps ordinary actor requests unchanged", async () => {
 		const response = await federation.fetch(new Request(`${ORIGIN}/users/https`, { headers: { Accept: ACCEPT } }), { contextData: void 0 });
 		assertEquals(response.status, 200);
@@ -329,6 +361,21 @@ test("Federation.fetch() authorizes portable actor requests", async (t) => {
 		})).status, 401);
 		assertEquals(unauthorized, true);
 	});
+	await t.step("authorizes before serving a tombstone", async () => {
+		for (const identifier of ["signed-tombstone", "tombstone"]) {
+			identifiers.length = 0;
+			let unauthorized = false;
+			assertEquals((await federation.fetch(gatewayRequest(`/users/${identifier}`), {
+				contextData: void 0,
+				onUnauthorized() {
+					unauthorized = true;
+					return new Response("Unauthorized", { status: 401 });
+				}
+			})).status, 401, identifier);
+			assertEquals(unauthorized, true, identifier);
+			assertEquals(identifiers, [identifier]);
+		}
+	});
 	await t.step("denies a request whose target was tampered with", async () => {
 		const signed = await signRequest(gatewayRequest("/users/alice"), rsaPrivateKey3, rsaPublicKey3.id);
 		assertEquals((await federation.fetch(new Request(gatewayUrl("/actor"), { headers: signed.headers }), { contextData: void 0 })).status, 401);

package/dist/federation/portable-chain.test.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "temporal-polyfill";
+import { URLPattern } from "urlpattern-polyfill";

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-Cc1b6pW9.mjs";
+import { o as verifyObject, s as verifyPortableObjectProof } from "../proof-CW8k0R1G.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-BdhvduR9.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-CnT0f1nU.mjs";
-import { l as signRequest } from "../http-BcLnr2do.mjs";
+import { p as signJsonLd } from "../ld-DQNTIrAe.mjs";
+import { l as signRequest } from "../http-BFeK9sBg.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-BpwKvOpU.mjs";
+import { f as handleInbox, n as FederationImpl, o as createFederation } from "../middleware-BdhvduR9.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";

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-CnT0f1nU.mjs";
-import { i as signObject } from "../proof-xdPYGPaA.mjs";
-import { f as verifyRequestDetailed, l as signRequest } from "../http-BcLnr2do.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 { 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-BpwKvOpU.mjs";
+import { _ as coversDelivery, o as createFederation, v as forwardPortableInboxActivity, y as resolvePortableInboxForwardingOptions } from "../middleware-BdhvduR9.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";