@fedify/fedify 2.5.0-dev.2609 → 2.5.0-dev.2618

package/dist/federation/outbound-workers.test.d.mts

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

package/dist/federation/outbound-workers.test.mjs

@@ -0,0 +1,64 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as projectSenderPayload } from "../outbound-document-BMgwLXTY.mjs";
+import { t as captureResponseBody } from "../outbound-capture-DVgnRzlf.mjs";
+import { test } from "@fedify/fixture";
+import { deepStrictEqual, ok, rejects, strictEqual } from "node:assert/strict";
+//#region src/federation/outbound-workers.test.ts
+test("outbound sender payload privacy on Workers", () => {
+	const secret = "https://private.example/recipient";
+	const input = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Create",
+		bcc: [secret],
+		object: {
+			"as:bto": [secret],
+			content: "visible"
+		}
+	};
+	const result = projectSenderPayload(input);
+	ok(result.type === "available");
+	strictEqual(result.redacted, true);
+	strictEqual(JSON.stringify(result.value).includes(secret), false);
+	ok(Object.isFrozen(result.value));
+	strictEqual(input.bcc[0], secret);
+	deepStrictEqual(projectSenderPayload({
+		...input,
+		"@context": [input["@context"], { private: "as:bcc" }]
+	}), {
+		stage: "sender-payload",
+		type: "unavailable",
+		reason: "privacy-filter-unavailable"
+	});
+});
+test("outbound body capture revocation on Workers", async () => {
+	let cancelled = 0;
+	let reader;
+	let signal;
+	const source = new ReadableStream({
+		pull() {},
+		cancel() {
+			cancelled++;
+			return new Promise(() => {});
+		}
+	}, { highWaterMark: 0 });
+	deepStrictEqual(await captureResponseBody(new Response(source), {
+		maxBytes: 16,
+		timeoutMs: 10
+	}, async (body, current) => {
+		signal = current;
+		reader = body.getReader();
+		await rejects(reader.read());
+	}), {
+		type: "deadline",
+		bytesExposed: 0
+	});
+	ok(signal.aborted);
+	strictEqual(cancelled, 1);
+	strictEqual(source.locked, false);
+	await rejects(reader.read());
+	reader.releaseLock();
+});
+//#endregion
+export {};

package/dist/federation/outbound-workflow.test.d.mts

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

package/dist/federation/outbound-workflow.test.mjs

@@ -0,0 +1,154 @@
+import { Temporal } from "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { i as rsaPrivateKey2, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
+import { o as createFederation } from "../middleware-DMrpt2wD.mjs";
+import { Create, Person } from "@fedify/vocab";
+import { test } from "@fedify/fixture";
+import { deepStrictEqual, ok, strictEqual } from "node:assert/strict";
+import { once } from "node:events";
+import { createServer } from "node:http";
+//#region src/federation/outbound-workflow.test.ts
+const { Deno: deno } = globalThis;
+test({
+	name: "outbound recorder archives real HTTP exchanges across a queued retry",
+	ignore: deno != null && (await deno.permissions.query({ name: "net" })).state !== "granted",
+	async fn() {
+		let accepting = false;
+		const received = [];
+		const receiverErrors = [];
+		const server = createServer((request, response) => {
+			(async () => {
+				let body = "";
+				for await (const chunk of request) body += chunk.toString();
+				const status = accepting ? 202 : 503;
+				received.push({
+					status,
+					activity: JSON.parse(body)
+				});
+				response.writeHead(status, {
+					"Content-Type": "text/plain",
+					"Connection": "close"
+				});
+				response.end(accepting ? "accepted" : "retry later");
+			})().catch((error) => {
+				receiverErrors.push(error);
+				response.writeHead(500);
+				response.end();
+			});
+		});
+		server.listen(0, "127.0.0.1");
+		await once(server, "listening");
+		const inbox = new URL(`http://127.0.0.1:${server.address().port}/inbox`);
+		const queued = [];
+		const attempts = [];
+		const exchanges = [];
+		const workers = [];
+		const archive = /* @__PURE__ */ new Map();
+		const federation = createFederation({
+			kv: new MemoryKvStore(),
+			allowPrivateAddress: true,
+			manuallyStartQueue: true,
+			circuitBreaker: false,
+			outboxRetryPolicy: () => Temporal.Duration.from({ milliseconds: 0 }),
+			queue: { outbox: {
+				enqueue(message) {
+					queued.push(message);
+					return Promise.resolve();
+				},
+				listen: () => Promise.resolve()
+			} }
+		});
+		federation.setOutboundObservers({
+			senderPayload: true,
+			responseBodyCapture: {
+				maxBytes: 4096,
+				timeoutMs: 1e3,
+				async onBody(_ctx, event) {
+					const key = `${event.attemptId}:${event.exchangeIndex}`;
+					const chunks = [];
+					archive.set(key, chunks);
+					const reader = event.body.getReader();
+					try {
+						while (true) {
+							const chunk = await reader.read();
+							if (chunk.done) break;
+							chunks.push(chunk.value.slice());
+						}
+					} finally {
+						reader.releaseLock();
+					}
+				}
+			},
+			onAttempt(_ctx, report) {
+				attempts.push(report);
+			},
+			onHttpExchange(_ctx, report) {
+				exchanges.push(report);
+			},
+			onWorker(_ctx, report) {
+				workers.push(report);
+			}
+		});
+		try {
+			await federation.createContext(new URL("https://example.com"), void 0).sendActivity({
+				keyId: rsaPublicKey2.id,
+				privateKey: rsaPrivateKey2
+			}, new Person({
+				id: new URL(inbox.origin + "/actor"),
+				inbox
+			}), new Create({
+				id: new URL("https://example.com/workflow/activity"),
+				actor: new URL("https://example.com/person2")
+			}), {
+				fanout: "skip",
+				dispatchId: "saved-workflow-dispatch"
+			});
+			strictEqual(received.length, 0);
+			strictEqual(queued.length, 1);
+			await federation.processQueuedTask(void 0, queued.shift());
+			strictEqual(attempts.length, 1);
+			strictEqual(attempts[0].outcome.type, "failed");
+			ok(attempts[0].outcome.response.type === "final");
+			strictEqual(attempts[0].outcome.response.metadata.status, 503);
+			strictEqual(queued.length, 1);
+			const retry = workers[0].actions.find((action) => action.type === "scheduled" && action.action === "retry");
+			ok(retry?.type === "scheduled");
+			strictEqual(retry.queue.queueAttempt, 1);
+			accepting = true;
+			await federation.processQueuedTask(void 0, queued.shift());
+			strictEqual(queued.length, 0);
+			strictEqual(attempts.length, 2);
+			strictEqual(attempts[1].outcome.type, "succeeded");
+			strictEqual(attempts[0].deliveryId, attempts[1].deliveryId);
+			ok(attempts[0].attemptId !== attempts[1].attemptId);
+			deepStrictEqual(attempts[0].broadcast, attempts[1].broadcast);
+			strictEqual(attempts[1].queue?.queueAttempt, 1);
+			for (const report of attempts) {
+				strictEqual(report.provenance.dispatchId, "saved-workflow-dispatch");
+				strictEqual(report.senderPayload.type, "available");
+				strictEqual(report.httpExchangeCount, exchanges.filter((exchange) => exchange.attemptId === report.attemptId).length);
+			}
+			strictEqual(received.length, exchanges.length);
+			strictEqual(archive.size, exchanges.length);
+			for (const [index, exchange] of exchanges.entries()) {
+				deepStrictEqual(exchange.bodyCapture, {
+					type: "complete",
+					bytesExposed: received[index].status === 503 ? 11 : 8
+				});
+				const chunks = archive.get(`${exchange.attemptId}:${exchange.exchangeIndex}`);
+				const decoder = new TextDecoder();
+				strictEqual(chunks.map((chunk) => decoder.decode(chunk)).join(""), received[index].status === 503 ? "retry later" : "accepted");
+			}
+			deepStrictEqual(workers.map((worker) => worker.attemptsStarted), [1, 1]);
+			deepStrictEqual(receiverErrors, []);
+		} finally {
+			const closed = new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+			server.closeAllConnections();
+			await closed;
+		}
+	}
+});
+//#endregion
+export {};

package/dist/federation/outgoing-proof.test.mjs

@@ -7,11 +7,11 @@ import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { s as detachSignature, x as exportJwk } from "../ld-CZsMAfOw.mjs";
-import { s as signObject } from "../proof-D6Kb0Qq9.mjs";
+import { s as detachSignature, x as exportJwk } from "../ld-CEOS8Pho.mjs";
+import { s as signObject } from "../proof-VrE-GaGv.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { C as getEmbeddedFirstGateway, S as getCompactRootId, c as assertPortableActorActivity, n as FederationImpl, o as createFederation, w as warnCompatibleIdsInJson } from "../middleware-CIRoIVSU.mjs";
-import { o as verifyCompoundPortableObjectProofs } from "../compound-proof-DNhLvscb.mjs";
+import { C as getEmbeddedFirstGateway, S as getCompactRootId, c as assertPortableActorActivity, n as FederationImpl, o as createFederation, w as warnCompatibleIdsInJson } from "../middleware-DMrpt2wD.mjs";
+import { o as verifyCompoundPortableObjectProofs } from "../compound-proof-B6Mz3pzt.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { Accept, Announce, Create, Follow, Note, Person } from "@fedify/vocab";
 import { exportDidKey, parseIri } from "@fedify/vocab-runtime";

package/dist/federation/portable-actor.test.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 { d as verifyPortableObjectProof, s as signObject } from "../proof-D6Kb0Qq9.mjs";
-import { p as verifyRequest, u as signRequest } from "../http-TgeyuTDM.mjs";
+import { d as verifyPortableObjectProof, s as signObject } from "../proof-VrE-GaGv.mjs";
+import { p as verifyRequest, u as signRequest } from "../http-NYqvoigN.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-CIRoIVSU.mjs";
+import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-DMrpt2wD.mjs";
 import { n as RouterError } from "../router-u5O5KCQr.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { Note, Person, Tombstone, lookupObject } from "@fedify/vocab";

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

@@ -7,10 +7,10 @@ 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 { x as exportJwk } from "../ld-CZsMAfOw.mjs";
-import { d as verifyPortableObjectProof, l as verifyObject } from "../proof-D6Kb0Qq9.mjs";
+import { x as exportJwk } from "../ld-CEOS8Pho.mjs";
+import { d as verifyPortableObjectProof, l as verifyObject } from "../proof-VrE-GaGv.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-CIRoIVSU.mjs";
+import { n as FederationImpl } from "../middleware-DMrpt2wD.mjs";
 import { Create, DataIntegrityProof, Note, OrderedCollection, Person, traverseCollection } from "@fedify/vocab";
 import { FetchError, encodeMultibase, exportDidKey } from "@fedify/vocab-runtime";
 import { mockDocumentLoader, test } from "@fedify/fixture";

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

@@ -7,11 +7,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 { d as verifyPortableObjectProof, s as signObject } from "../proof-D6Kb0Qq9.mjs";
+import { d as verifyPortableObjectProof, s as signObject } from "../proof-VrE-GaGv.mjs";
 import { n as ed25519PrivateKey, r as ed25519PublicKey } from "../keys-DIJNHW-Y.mjs";
-import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-CIRoIVSU.mjs";
-import { t as verifyPortableObject } from "../portable-collection-Oxfavx8f.mjs";
-import { c as verifyServedPortableObjects } from "../compound-proof-DNhLvscb.mjs";
+import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-DMrpt2wD.mjs";
+import { t as verifyPortableObject } from "../portable-collection-BBSMcaDY.mjs";
+import { c as verifyServedPortableObjects } from "../compound-proof-B6Mz3pzt.mjs";
 import { n as RouterError } from "../router-u5O5KCQr.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { Create, Note, Object as Object$1, OrderedCollection, PUBLIC_COLLECTION, Person, Tombstone, lookupObject, traverseCollection } from "@fedify/vocab";

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

@@ -4,12 +4,12 @@ globalThis.addEventListener = () => {};
 import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
 import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { i as rsaPrivateKey2, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { n as FederationImpl, r as InboxContextImpl } from "../middleware-CIRoIVSU.mjs";
-import { n as extractInboxes, t as SendActivityError } from "../send-BFti0L3I.mjs";
+import { n as FederationImpl, r as InboxContextImpl, t as ContextImpl } from "../middleware-DMrpt2wD.mjs";
+import { n as extractInboxes, t as SendActivityError } from "../send-CY6agn9T.mjs";
 import { Create, Endpoints, Note, Person } from "@fedify/vocab";
 import { parseIri } from "@fedify/vocab-runtime";
 import { mockDocumentLoader, test } from "@fedify/fixture";
-import { deepStrictEqual, ok, rejects, strictEqual } from "node:assert/strict";
+import { deepStrictEqual, notStrictEqual, ok, rejects, strictEqual } from "node:assert/strict";
 //#region src/federation/portable-delivery.test.ts
 const DID = "did:key:z6MkrJVnaZkeFzdQyMZu1cgjg7k1pZZ6pvBQ7XJPt4swbTQ2";
 const OTHER_DID = "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK";
@@ -344,6 +344,77 @@ test("Context.sendActivity() to a portable inbox", async (t) => {
 	});
 	esm_default.hardReset();
 });
+test("portable fallback attempts retain one delivery across concrete gateway sends", async (t) => {
+	for (const operation of [
+		"send",
+		"inbox-forward",
+		"outbox-forward"
+	]) for (const accepted of [true, false]) await t.step(`${operation}: ${accepted ? "accepted fallback" : "exhausted gateways"}`, async () => {
+		const raw = {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Create",
+			id: "https://example.com/activities/forwarded",
+			actor: "https://example.com/person2",
+			extra: "preserve received payload"
+		};
+		const reports = [];
+		const deliveries = [];
+		const submitted = [];
+		esm_default.mockGlobal().post("begin:https://gw1.example/", (call) => {
+			submitted.push(JSON.parse(String(call.options.body)));
+			return 503;
+		}).post("begin:https://gw2.example/", (call) => {
+			submitted.push(JSON.parse(String(call.options.body)));
+			return accepted ? 202 : 502;
+		});
+		try {
+			const federation = new FederationImpl({
+				kv: new MemoryKvStore(),
+				allowPrivateAddress: true
+			});
+			federation.setOutboundObservers({
+				onDelivery(_ctx, event) {
+					deliveries.push(event);
+				},
+				onAttempt(_ctx, report) {
+					reports.push(report);
+					throw new Error("attempt observer cannot stop gateway fallback");
+				}
+			});
+			const ctx = federation.createContext(new URL("https://example.com/"));
+			ok(ctx instanceof ContextImpl);
+			const target = portableActor({ gateways: ["https://gw1.example", "https://gw2.example"] });
+			const pending = operation === "send" ? ctx.sendActivity(sender, target, createActivity(), { immediate: true }) : (operation === "inbox-forward" ? ctx.toInboxContext(null, raw, raw.id, Create.typeId.href) : ctx.toOutboxContext("alice", raw, raw.id, Create.typeId.href)).forwardActivity(sender, target, {
+				immediate: true,
+				skipIfUnsigned: false
+			});
+			if (accepted) await pending;
+			else await rejects(pending, (error) => error instanceof SendActivityError && error.statusCode === 502);
+			strictEqual(reports.length, 2);
+			deepStrictEqual(reports.map((report) => report.inboxUrl), [inboxOn("https://gw1.example"), inboxOn("https://gw2.example")]);
+			notStrictEqual(reports[0].attemptId, reports[1].attemptId);
+			strictEqual(reports[0].deliveryId, reports[1].deliveryId);
+			deepStrictEqual(reports[0].broadcast, reports[1].broadcast);
+			for (const report of reports) {
+				strictEqual(report.destinationInbox, inboxOn("https://gw1.example"));
+				strictEqual(report.portableInbox, PORTABLE_INBOX);
+				strictEqual(report.deliveryId, deliveries[0].deliveryId);
+			}
+			strictEqual(reports[0].outcome.type, "failed");
+			strictEqual(reports[1].outcome.type, accepted ? "succeeded" : "failed");
+			for (const [index, report] of reports.entries()) {
+				const response = report.outcome.response;
+				ok(response.type === "final");
+				strictEqual(response.metadata.status, index === 0 ? 503 : accepted ? 202 : 502);
+				strictEqual(report.httpExchangeCount, index === 1 && accepted ? 1 : 2);
+				strictEqual(response.exchangeIndex, report.httpExchangeCount - 1);
+			}
+			if (operation !== "send") for (const payload of submitted) deepStrictEqual(payload, raw);
+		} finally {
+			esm_default.hardReset();
+		}
+	});
+});
 test("InboxContext.forwardActivity() to a portable inbox", async (t) => {
 	esm_default.spyGlobal();
 	const activity = {
@@ -374,25 +445,44 @@ test("InboxContext.forwardActivity() to a portable inbox", async (t) => {
 			requests.push(call.url);
 			return 202;
 		});
-		await createInboxContext(new FederationImpl({
+		const federation = new FederationImpl({
 			kv: new MemoryKvStore(),
 			allowPrivateAddress: true
-		})).forwardActivity(sender, recipient, {
+		});
+		const events = [];
+		federation.setOutboundObservers({ onDelivery(_ctx, event) {
+			events.push(event);
+		} });
+		await createInboxContext(federation).forwardActivity(sender, recipient, {
 			immediate: true,
 			skipIfUnsigned: false
 		});
 		deepStrictEqual([...new Set(requests)], [inboxOn("https://gw1.example"), inboxOn("https://gw2.example")]);
+		deepStrictEqual(events.map((event) => event.stage), ["planned", "handoff"]);
+		strictEqual(events[0].deliveryId, events[1].deliveryId);
+		for (const event of events) {
+			strictEqual(event.destinationInbox, inboxOn("https://gw1.example"));
+			strictEqual(event.portableInbox, PORTABLE_INBOX);
+		}
+		const planned = events[0];
+		ok(planned.stage === "planned");
+		strictEqual(planned.mode, "portable-fallback");
 	});
 	await t.step("through the queue", async () => {
 		esm_default.hardReset();
 		esm_default.spyGlobal();
 		const { queue, queued } = createQueue();
-		await createInboxContext(new FederationImpl({
+		const federation = new FederationImpl({
 			kv: new MemoryKvStore(),
 			queue,
 			manuallyStartQueue: true,
 			allowPrivateAddress: true
-		})).forwardActivity(sender, recipient, {
+		});
+		const events = [];
+		federation.setOutboundObservers({ onDelivery(_ctx, event) {
+			events.push(event);
+		} });
+		await createInboxContext(federation).forwardActivity(sender, recipient, {
 			orderingKey: "key",
 			skipIfUnsigned: false
 		});
@@ -402,6 +492,15 @@ test("InboxContext.forwardActivity() to a portable inbox", async (t) => {
 		strictEqual(message.portableInbox, PORTABLE_INBOX);
 		deepStrictEqual(message.gatewayInboxes, [inboxOn("https://gw1.example"), inboxOn("https://gw2.example")]);
 		strictEqual(queued[0].options?.orderingKey, `key\n${DID}`);
+		deepStrictEqual(events.map((event) => event.stage), ["planned", "handoff"]);
+		strictEqual(events[0].deliveryId, events[1].deliveryId);
+		for (const event of events) {
+			strictEqual(event.destinationInbox, inboxOn("https://gw1.example"));
+			strictEqual(event.portableInbox, PORTABLE_INBOX);
+		}
+		const planned = events[0];
+		ok(planned.stage === "planned");
+		strictEqual(planned.mode, "portable-fallback");
 	});
 	esm_default.hardReset();
 });

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

@@ -8,12 +8,12 @@ import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { r as getVerifiedKeyOwnerEvidence } from "../key-owner-evidence-APB6NpSk.mjs";
-import { m as signJsonLd } from "../ld-CZsMAfOw.mjs";
-import { m as verifyRequestDetailed, p as verifyRequest, u as signRequest } from "../http-TgeyuTDM.mjs";
+import { m as signJsonLd } from "../ld-CEOS8Pho.mjs";
+import { m as verifyRequestDetailed, p as verifyRequest, u as signRequest } from "../http-NYqvoigN.mjs";
 import { a as rsaPrivateKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { n as getAuthenticatedDocumentLoader } from "../docloader-B9RO5nh9.mjs";
-import { f as handleInbox, n as FederationImpl, o as createFederation } from "../middleware-CIRoIVSU.mjs";
-import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-Dwz4fGUW.mjs";
+import { n as getAuthenticatedDocumentLoader } from "../docloader-kYMkiXaB.mjs";
+import { f as handleInbox, n as FederationImpl, o as createFederation } from "../middleware-DMrpt2wD.mjs";
+import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-BOyHaAlU.mjs";
 import { t as ActivityListenerSet } from "../activity-listener-CELFAodc.mjs";
 import { t as KvKeyCache } from "../keycache-N2opu4-3.mjs";
 import { Create, CryptographicKey, Person } from "@fedify/vocab";