@fedify/fedify 2.2.0-dev.613 → 2.2.0-dev.622

package/dist/federation/mod.js

@@ -1,13 +1,322 @@
-
-          import { Temporal } from "@js-temporal/polyfill";
-          import { URLPattern } from "urlpattern-polyfill";
-        
-import "../transformers-C3FLHUd6.js";
-import "../http-IFqEftoZ.js";
-import { Router, RouterError, SendActivityError, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, digest, handleWebFinger, respondWithObject, respondWithObjectIfAcceptable } from "../middleware-DcpBikad.js";
-import "../proof-DdGGXVWM.js";
-import { InProcessMessageQueue, MemoryKvStore, ParallelMessageQueue } from "../federation-DaMfqRm4.js";
-import "../types-C93Ob9cU.js";
-import "../kv-cache-Drlz6O_Y.js";
-
-export { InProcessMessageQueue, MemoryKvStore, ParallelMessageQueue, Router, RouterError, SendActivityError, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, digest, handleWebFinger, respondWithObject, respondWithObjectIfAcceptable };
+import { Temporal } from "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+import { a as createExponentialBackoffPolicy, c as buildCollectionSynchronizationHeader, d as Router, f as RouterError, i as SendActivityError, l as digest, o as respondWithObject, r as handleWebFinger, s as respondWithObjectIfAcceptable, t as createFederation, u as createFederationBuilder } from "../middleware-BmsVSOeS.js";
+import { isEqual } from "es-toolkit";
+//#region src/federation/kv.ts
+/**
+* A key–value store that stores values in memory.
+* Do not use this in production as it does not persist values.
+*
+* @since 0.5.0
+*/
+var MemoryKvStore = class {
+	#values = {};
+	#encodeKey(key) {
+		return JSON.stringify(key);
+	}
+	/**
+	* {@inheritDoc KvStore.get}
+	*/
+	get(key) {
+		const encodedKey = this.#encodeKey(key);
+		const entry = this.#values[encodedKey];
+		if (entry == null) return Promise.resolve(void 0);
+		const [value, expiration] = entry;
+		if (expiration != null && Temporal.Now.instant().until(expiration).sign < 0) {
+			delete this.#values[encodedKey];
+			return Promise.resolve(void 0);
+		}
+		return Promise.resolve(value);
+	}
+	/**
+	* {@inheritDoc KvStore.set}
+	*/
+	set(key, value, options) {
+		const encodedKey = this.#encodeKey(key);
+		const expiration = options?.ttl == null ? null : Temporal.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
+		this.#values[encodedKey] = [value, expiration];
+		return Promise.resolve();
+	}
+	/**
+	* {@inheritDoc KvStore.delete}
+	*/
+	delete(key) {
+		const encodedKey = this.#encodeKey(key);
+		delete this.#values[encodedKey];
+		return Promise.resolve();
+	}
+	/**
+	* {@inheritDoc KvStore.cas}
+	*/
+	cas(key, expectedValue, newValue, options) {
+		const encodedKey = this.#encodeKey(key);
+		const entry = this.#values[encodedKey];
+		let currentValue;
+		if (entry == null) currentValue = void 0;
+		else {
+			const [value, expiration] = entry;
+			if (expiration != null && Temporal.Now.instant().until(expiration).sign < 0) {
+				delete this.#values[encodedKey];
+				currentValue = void 0;
+			} else currentValue = value;
+		}
+		if (!isEqual(currentValue, expectedValue)) return Promise.resolve(false);
+		const expiration = options?.ttl == null ? null : Temporal.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
+		this.#values[encodedKey] = [newValue, expiration];
+		return Promise.resolve(true);
+	}
+	/**
+	* {@inheritDoc KvStore.list}
+	*/
+	async *list(prefix) {
+		const now = Temporal.Now.instant();
+		for (const [encodedKey, entry] of Object.entries(this.#values)) {
+			const key = JSON.parse(encodedKey);
+			if (prefix != null) {
+				if (key.length < prefix.length) continue;
+				if (!prefix.every((p, i) => key[i] === p)) continue;
+			}
+			const [value, expiration] = entry;
+			if (expiration != null && now.until(expiration).sign < 0) {
+				delete this.#values[encodedKey];
+				continue;
+			}
+			yield {
+				key,
+				value
+			};
+		}
+	}
+};
+//#endregion
+//#region src/federation/mq.ts
+/**
+* A message queue that processes messages in the same process.
+* Do not use this in production as it does neither persist messages nor
+* distribute them across multiple processes.
+*
+* @since 0.5.0
+*/
+var InProcessMessageQueue = class {
+	#messages;
+	#monitors;
+	#pollIntervalMs;
+	/**
+	* Tracks which ordering keys are currently being processed to ensure
+	* sequential processing for messages with the same key.
+	*/
+	#processingKeys;
+	/**
+	* In-process message queue does not provide native retry mechanisms.
+	* @since 1.7.0
+	*/
+	nativeRetrial = false;
+	/**
+	* Constructs a new {@link InProcessMessageQueue} with the given options.
+	* @param options Additional options for the in-process message queue.
+	*/
+	constructor(options = {}) {
+		this.#messages = [];
+		this.#monitors = {};
+		this.#pollIntervalMs = Temporal.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
+		this.#processingKeys = /* @__PURE__ */ new Set();
+	}
+	enqueue(message, options) {
+		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
+		if (delay > 0) {
+			setTimeout(() => this.enqueue(message, {
+				...options,
+				delay: void 0
+			}), delay);
+			return Promise.resolve();
+		}
+		const orderingKey = options?.orderingKey ?? null;
+		this.#messages.push({
+			message,
+			orderingKey
+		});
+		for (const monitorId in this.#monitors) this.#monitors[monitorId]();
+		return Promise.resolve();
+	}
+	enqueueMany(messages, options) {
+		if (messages.length === 0) return Promise.resolve();
+		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
+		if (delay > 0) {
+			setTimeout(() => this.enqueueMany(messages, {
+				...options,
+				delay: void 0
+			}), delay);
+			return Promise.resolve();
+		}
+		const orderingKey = options?.orderingKey ?? null;
+		for (const message of messages) this.#messages.push({
+			message,
+			orderingKey
+		});
+		for (const monitorId in this.#monitors) this.#monitors[monitorId]();
+		return Promise.resolve();
+	}
+	async listen(handler, options = {}) {
+		const signal = options.signal;
+		while (signal == null || !signal.aborted) {
+			const idx = this.#messages.findIndex((m) => m.orderingKey == null || !this.#processingKeys.has(m.orderingKey));
+			if (idx >= 0) {
+				const { message, orderingKey } = this.#messages.splice(idx, 1)[0];
+				if (orderingKey != null) this.#processingKeys.add(orderingKey);
+				try {
+					await handler(message);
+				} finally {
+					if (orderingKey != null) this.#processingKeys.delete(orderingKey);
+				}
+			} else if (this.#messages.length === 0) await this.#wait(this.#pollIntervalMs, signal);
+			else await this.#wait(10, signal);
+		}
+	}
+	#wait(ms, signal) {
+		let timer = null;
+		return Promise.any([new Promise((resolve) => {
+			signal?.addEventListener("abort", () => {
+				if (timer != null) clearTimeout(timer);
+				resolve();
+			}, { once: true });
+			const monitorId = crypto.randomUUID();
+			this.#monitors[monitorId] = () => {
+				delete this.#monitors[monitorId];
+				if (timer != null) clearTimeout(timer);
+				resolve();
+			};
+		}), new Promise((resolve) => timer = setTimeout(resolve, ms))]);
+	}
+};
+/**
+* A message queue that processes messages in parallel.  It takes another
+* {@link MessageQueue}, and processes messages in parallel up to a certain
+* number of workers.
+*
+* Actually, it's rather a decorator than a queue itself.
+*
+* Note that the workers do not run in truly parallel, in the sense that they
+* are not running in separate threads or processes.  They are running in the
+* same process, but are scheduled to run in parallel.  Hence, this is useful
+* for I/O-bound tasks, but not for CPU-bound tasks, which is okay for Fedify's
+* workloads.
+*
+* When using `ParallelMessageQueue`, the ordering guarantee is preserved
+* *only if* the underlying queue implementation delivers messages in a wrapper
+* format that includes the `__fedify_ordering_key__` property.  Currently,
+* only `DenoKvMessageQueue` and `WorkersMessageQueue` use this format.
+* For other queue implementations (e.g., `InProcessMessageQueue`,
+* `RedisMessageQueue`, `PostgresMessageQueue`, `SqliteMessageQueue`,
+* `AmqpMessageQueue`), the ordering key cannot be detected by
+* `ParallelMessageQueue`, so ordering guarantees are handled by those
+* implementations directly rather than at the `ParallelMessageQueue` level.
+*
+* Messages with the same ordering key will never be processed concurrently
+* by different workers, ensuring sequential processing within each key.
+* Messages with different ordering keys (or no ordering key) can still be
+* processed in parallel.
+*
+* @since 1.0.0
+*/
+var ParallelMessageQueue = class ParallelMessageQueue {
+	queue;
+	workers;
+	/**
+	* Inherits the native retry capability from the wrapped queue.
+	* @since 1.7.0
+	*/
+	nativeRetrial;
+	/**
+	* Tracks which ordering keys are currently being processed to ensure
+	* sequential processing for messages with the same key.
+	*/
+	#processingKeys = /* @__PURE__ */ new Set();
+	/**
+	* Pending messages waiting for their ordering key to become available.
+	*/
+	#pendingMessages = [];
+	/**
+	* Constructs a new {@link ParallelMessageQueue} with the given queue and
+	* number of workers.
+	* @param queue The message queue to use under the hood.  Note that
+	*              {@link ParallelMessageQueue} cannot be nested.
+	* @param workers The number of workers to process messages in parallel.
+	* @throws {TypeError} If the given queue is an instance of
+	*                     {@link ParallelMessageQueue}.
+	*/
+	constructor(queue, workers) {
+		if (queue instanceof ParallelMessageQueue) throw new TypeError("Cannot nest ParallelMessageQueue.");
+		this.queue = queue;
+		this.workers = workers;
+		this.nativeRetrial = queue.nativeRetrial;
+	}
+	enqueue(message, options) {
+		return this.queue.enqueue(message, options);
+	}
+	async enqueueMany(messages, options) {
+		if (this.queue.enqueueMany == null) {
+			const errors = (await Promise.allSettled(messages.map((message) => this.queue.enqueue(message, options)))).filter((r) => r.status === "rejected").map((r) => r.reason);
+			if (errors.length > 1) throw new AggregateError(errors, "Failed to enqueue messages.");
+			else if (errors.length === 1) throw errors[0];
+			return;
+		}
+		await this.queue.enqueueMany(messages, options);
+	}
+	/**
+	* Extracts ordering key from a message if present.
+	*
+	* This method only works for queue implementations that deliver messages
+	* in the wrapper format with `__fedify_ordering_key__` property.  Currently,
+	* only `DenoKvMessageQueue` and `WorkersMessageQueue` use this format.
+	*
+	* For other queue implementations (`InProcessMessageQueue`,
+	* `RedisMessageQueue`, `PostgresMessageQueue`, `SqliteMessageQueue`,
+	* `AmqpMessageQueue`), messages are delivered as raw payloads without the
+	* wrapper, so the ordering key cannot be detected here.  Those
+	* implementations handle ordering guarantees internally.
+	*/
+	#extractOrderingKey(message) {
+		if (message != null && typeof message === "object") {
+			if ("__fedify_ordering_key__" in message) return message.__fedify_ordering_key__;
+		}
+	}
+	listen(handler, options = {}) {
+		const workers = /* @__PURE__ */ new Map();
+		return this.queue.listen(async (message) => {
+			while (workers.size >= this.workers) {
+				const consumedId = await Promise.any(workers.values());
+				workers.delete(consumedId);
+			}
+			const workerId = crypto.randomUUID();
+			const orderingKey = this.#extractOrderingKey(message);
+			if (orderingKey != null && this.#processingKeys.has(orderingKey)) await new Promise((resolve) => {
+				this.#pendingMessages.push({
+					message,
+					orderingKey,
+					resolve
+				});
+			});
+			if (orderingKey != null) this.#processingKeys.add(orderingKey);
+			const promise = this.#work(workerId, handler, message, orderingKey);
+			workers.set(workerId, promise);
+		}, options);
+	}
+	async #work(workerId, handler, message, orderingKey) {
+		await this.#sleep(0);
+		try {
+			await handler(message);
+		} finally {
+			if (orderingKey != null) {
+				this.#processingKeys.delete(orderingKey);
+				const pendingIdx = this.#pendingMessages.findIndex((p) => p.orderingKey === orderingKey);
+				if (pendingIdx >= 0) this.#pendingMessages.splice(pendingIdx, 1)[0].resolve();
+			}
+		}
+		return workerId;
+	}
+	#sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+//#endregion
+export { InProcessMessageQueue, MemoryKvStore, ParallelMessageQueue, Router, RouterError, SendActivityError, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, digest, handleWebFinger, respondWithObject, respondWithObjectIfAcceptable };

package/dist/federation/mq.test.d.mts

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

package/dist/federation/{mq.test.js → mq.test.mjs}

@@ -1,18 +1,12 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-      globalThis.addEventListener = () => {};
-    
-import { assertEquals } from "../assert_equals-DSbWqCm3.js";
-import { assert } from "../assert-MZs1qjMx.js";
-import "../assert_instance_of-DHz7EHNU.js";
-import { assertGreater, assertGreaterOrEqual } from "../std__assert-X-_kMxKM.js";
-import { assertFalse } from "../assert_rejects-0h7I2Esa.js";
-import "../assert_throws-rjdMBf31.js";
-import "../assert_not_equals-f3m3epl3.js";
+import { Temporal } from "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
+import { i as assertGreaterOrEqual, r as assertGreater } from "../std__assert-Duiq_YC9.mjs";
+import { n as assertFalse } from "../assert_rejects-B-qJtC9Z.mjs";
+import { t as assert } from "../assert-ddO5KLpe.mjs";
 import { test } from "@fedify/fixture";
 import { delay } from "es-toolkit";
-
 //#region src/federation/mq.ts
 /**
 * A message queue that processes messages in the same process.
@@ -46,12 +40,12 @@ var InProcessMessageQueue = class {
 		this.#processingKeys = /* @__PURE__ */ new Set();
 	}
 	enqueue(message, options) {
-		const delay$1 = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
-		if (delay$1 > 0) {
+		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
+		if (delay > 0) {
 			setTimeout(() => this.enqueue(message, {
 				...options,
 				delay: void 0
-			}), delay$1);
+			}), delay);
 			return Promise.resolve();
 		}
 		const orderingKey = options?.orderingKey ?? null;
@@ -64,12 +58,12 @@ var InProcessMessageQueue = class {
 	}
 	enqueueMany(messages, options) {
 		if (messages.length === 0) return Promise.resolve();
-		const delay$1 = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
-		if (delay$1 > 0) {
+		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
+		if (delay > 0) {
 			setTimeout(() => this.enqueueMany(messages, {
 				...options,
 				delay: void 0
-			}), delay$1);
+			}), delay);
 			return Promise.resolve();
 		}
 		const orderingKey = options?.orderingKey ?? null;
@@ -85,8 +79,7 @@ var InProcessMessageQueue = class {
 		while (signal == null || !signal.aborted) {
 			const idx = this.#messages.findIndex((m) => m.orderingKey == null || !this.#processingKeys.has(m.orderingKey));
 			if (idx >= 0) {
-				const queued = this.#messages.splice(idx, 1)[0];
-				const { message, orderingKey } = queued;
+				const { message, orderingKey } = this.#messages.splice(idx, 1)[0];
 				if (orderingKey != null) this.#processingKeys.add(orderingKey);
 				try {
 					await handler(message);
@@ -180,8 +173,7 @@ var ParallelMessageQueue = class ParallelMessageQueue {
 	}
 	async enqueueMany(messages, options) {
 		if (this.queue.enqueueMany == null) {
-			const results = await Promise.allSettled(messages.map((message) => this.queue.enqueue(message, options)));
-			const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+			const errors = (await Promise.allSettled(messages.map((message) => this.queue.enqueue(message, options)))).filter((r) => r.status === "rejected").map((r) => r.reason);
 			if (errors.length > 1) throw new AggregateError(errors, "Failed to enqueue messages.");
 			else if (errors.length === 1) throw errors[0];
 			return;
@@ -205,7 +197,6 @@ var ParallelMessageQueue = class ParallelMessageQueue {
 		if (message != null && typeof message === "object") {
 			if ("__fedify_ordering_key__" in message) return message.__fedify_ordering_key__;
 		}
-		return void 0;
 	}
 	listen(handler, options = {}) {
 		const workers = /* @__PURE__ */ new Map();
@@ -236,10 +227,7 @@ var ParallelMessageQueue = class ParallelMessageQueue {
 			if (orderingKey != null) {
 				this.#processingKeys.delete(orderingKey);
 				const pendingIdx = this.#pendingMessages.findIndex((p) => p.orderingKey === orderingKey);
-				if (pendingIdx >= 0) {
-					const pending = this.#pendingMessages.splice(pendingIdx, 1)[0];
-					pending.resolve();
-				}
+				if (pendingIdx >= 0) this.#pendingMessages.splice(pendingIdx, 1)[0].resolve();
 			}
 		}
 		return workerId;
@@ -248,7 +236,6 @@ var ParallelMessageQueue = class ParallelMessageQueue {
 		return new Promise((resolve) => setTimeout(resolve, ms));
 	}
 };
-
 //#endregion
 //#region src/federation/mq.test.ts
 test("InProcessMessageQueue", async (t) => {
@@ -410,8 +397,7 @@ test("MessageQueue.nativeRetrial", async (t) => {
 				throw new TypeError("WorkersMessageQueue does not support listen()");
 			}
 		}
-		const mq = new TestWorkersMessageQueue(new MockQueue());
-		assert(mq.nativeRetrial);
+		assert(new TestWorkersMessageQueue(new MockQueue()).nativeRetrial);
 	});
 });
 const queues = { InProcessMessageQueue: () => Promise.resolve(new InProcessMessageQueue()) };
@@ -455,8 +441,8 @@ for (const mqName in queues) test({
 		await waitFor(() => messages.length >= 20, 15e3);
 		while (messages.length > 0) messages.pop();
 		await t.step("enqueueMany()", async () => {
-			const messages$1 = Array.from({ length: 20 }, (_, i) => `Hello, ${i}!`);
-			await workers.enqueueMany(messages$1);
+			const messages = Array.from({ length: 20 }, (_, i) => `Hello, ${i}!`);
+			await workers.enqueueMany(messages);
 		});
 		await t.step("listen() [multiple]", async () => {
 			await delay(3e3);
@@ -480,5 +466,5 @@ async function waitFor(predicate, timeoutMs) {
 		if (Date.now() - started > timeoutMs) throw new Error("Timeout");
 	}
 }
-
-//#endregion
+//#endregion
+export {};

package/dist/federation/negotiation.test.d.mts

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

package/dist/federation/{negotiation.test.js → negotiation.test.mjs}

@@ -1,18 +1,11 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-      globalThis.addEventListener = () => {};
-    
-import "../assert_equals-DSbWqCm3.js";
-import { assert } from "../assert-MZs1qjMx.js";
-import "../assert_instance_of-DHz7EHNU.js";
-import { acceptsJsonLd } from "../negotiation-BlAuS_nr.js";
-import "../std__assert-X-_kMxKM.js";
-import { assertFalse } from "../assert_rejects-0h7I2Esa.js";
-import "../assert_throws-rjdMBf31.js";
-import "../assert_not_equals-f3m3epl3.js";
+import "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import "../std__assert-Duiq_YC9.mjs";
+import { n as assertFalse } from "../assert_rejects-B-qJtC9Z.mjs";
+import { t as assert } from "../assert-ddO5KLpe.mjs";
+import { t as acceptsJsonLd } from "../negotiation-DnsfFF8I.mjs";
 import { test } from "@fedify/fixture";
-
 //#region src/federation/negotiation.test.ts
 test("acceptsJsonLd()", () => {
 	assert(acceptsJsonLd(new Request("https://example.com/", { headers: { Accept: "application/activity+json" } })));
@@ -21,5 +14,5 @@ test("acceptsJsonLd()", () => {
 	assertFalse(acceptsJsonLd(new Request("https://example.com/", { headers: { Accept: "application/ld+json; q=0.5, text/html; q=0.8" } })));
 	assertFalse(acceptsJsonLd(new Request("https://example.com/", { headers: { Accept: "application/ld+json; q=0.4, application/xhtml+xml; q=0.9" } })));
 });
-
-//#endregion
+//#endregion
+export {};

package/dist/federation/retry.test.d.mts

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

package/dist/federation/{retry.test.js → retry.test.mjs}

@@ -1,13 +1,10 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-      globalThis.addEventListener = () => {};
-    
-import { AssertionError, assertEquals } from "../assert_equals-DSbWqCm3.js";
-import { createExponentialBackoffPolicy } from "../retry-mqLf4b-R.js";
-import { assertNotEquals } from "../assert_not_equals-f3m3epl3.js";
+import { Temporal } from "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { l as AssertionError, t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
+import { t as assertNotEquals } from "../assert_not_equals--wG9hV7u.mjs";
+import { t as createExponentialBackoffPolicy } from "../retry-B_E3V_Dx.mjs";
 import { test } from "@fedify/fixture";
-
 //#region src/federation/retry.test.ts
 test("createExponentialBackoffPolicy()", () => {
 	const policy = createExponentialBackoffPolicy({ maxAttempts: 4 });
@@ -40,5 +37,5 @@ function assertDurationRange(actual, min, max) {
 	const maxDuration = Temporal.Duration.from(max);
 	if (Temporal.Duration.compare(actual, minDuration) < 0 || Temporal.Duration.compare(actual, maxDuration) > 0) throw new AssertionError(`Expected ${actual} to be between ${min} and ${max}`);
 }
-
-//#endregion
+//#endregion
+export {};

package/dist/federation/router.test.d.mts

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

package/dist/federation/{router.test.js → router.test.mjs}

@@ -1,18 +1,13 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-      globalThis.addEventListener = () => {};
-    
-import { assertEquals } from "../assert_equals-DSbWqCm3.js";
-import { assert } from "../assert-MZs1qjMx.js";
-import "../assert_instance_of-DHz7EHNU.js";
-import { Router, RouterError } from "../router-D9eI0s4b.js";
-import "../std__assert-X-_kMxKM.js";
-import { assertFalse } from "../assert_rejects-0h7I2Esa.js";
-import { assertThrows } from "../assert_throws-rjdMBf31.js";
-import "../assert_not_equals-f3m3epl3.js";
+import "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { n as RouterError, t as Router } from "../router-CrMLXoOr.mjs";
+import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
+import "../std__assert-Duiq_YC9.mjs";
+import { n as assertFalse } from "../assert_rejects-B-qJtC9Z.mjs";
+import { t as assertThrows } from "../assert_throws-4NwKEy2q.mjs";
+import { t as assert } from "../assert-ddO5KLpe.mjs";
 import { test } from "@fedify/fixture";
-
 //#region src/federation/router.test.ts
 function setUp(options = {}) {
 	const router = new Router(options);
@@ -93,5 +88,5 @@ test("Router.build()", () => {
 		postId: "123"
 	}), "/users/alice/posts/123");
 });
-
-//#endregion
+//#endregion
+export {};

package/dist/federation/send.test.d.mts

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

package/dist/federation/{send.test.js → send.test.mjs}

@@ -1,26 +1,19 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-      globalThis.addEventListener = () => {};
-    
-import { esm_default } from "../esm-nLm00z9V.js";
-import { assertEquals } from "../assert_equals-DSbWqCm3.js";
-import { assert } from "../assert-MZs1qjMx.js";
-import { assertInstanceOf } from "../assert_instance_of-DHz7EHNU.js";
-import "../deno-CnMqla6T.js";
-import "../accept-D7sAxyNa.js";
-import "../key-DFLFXKER.js";
-import { verifyRequest } from "../http-CKaqhjvP.js";
-import { doesActorOwnKey } from "../owner-Cye0yQB_.js";
-import { SendActivityError, extractInboxes, sendActivity } from "../send-C2a_3YAF.js";
-import "../std__assert-X-_kMxKM.js";
-import { assertFalse, assertRejects } from "../assert_rejects-0h7I2Esa.js";
-import "../assert_throws-rjdMBf31.js";
-import { assertNotEquals } from "../assert_not_equals-f3m3epl3.js";
-import { ed25519Multikey, ed25519PrivateKey, rsaPrivateKey2, rsaPublicKey2 } from "../keys-BFve7QQv.js";
+import "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as esm_default } from "../esm-DVILvP5e.mjs";
+import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
+import "../std__assert-Duiq_YC9.mjs";
+import { n as assertFalse, t as assertRejects } from "../assert_rejects-B-qJtC9Z.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-C4Ri6VuN.mjs";
+import { t as assertNotEquals } from "../assert_not_equals--wG9hV7u.mjs";
+import { t as assert } from "../assert-ddO5KLpe.mjs";
+import { l as verifyRequest } from "../http-CNsnyqrO.mjs";
+import { i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-BAK-tUlf.mjs";
+import { t as doesActorOwnKey } from "../owner-DF320w6K.mjs";
+import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-CJQubr5t.mjs";
 import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { Activity, Application, Endpoints, Group, Person, Service } from "@fedify/vocab";
-
 //#region src/federation/send.test.ts
 test("extractInboxes()", () => {
 	const recipients = [
@@ -387,14 +380,13 @@ test("sendActivity() records OpenTelemetry span events", async (t) => {
 	await t.step("successful send", async () => {
 		esm_default.get("https://example.com/", { status: 404 });
 		esm_default.post("https://example.com/inbox", { status: 202 });
-		const activity = {
-			"@context": "https://www.w3.org/ns/activitystreams",
-			type: "Create",
-			id: "https://example.com/activity",
-			actor: "https://example.com/person"
-		};
 		await sendActivity({
-			activity,
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://example.com/activity",
+				actor: "https://example.com/person"
+			},
 			activityId: "https://example.com/activity",
 			activityType: "https://www.w3.org/ns/activitystreams#Create",
 			keys: [{
@@ -423,5 +415,5 @@ test("sendActivity() records OpenTelemetry span events", async (t) => {
 		esm_default.hardReset();
 	});
 });
-
-//#endregion
+//#endregion
+export {};

package/dist/federation/webfinger.test.d.mts

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