@fedify/fedify 1.6.0-dev.814 → 1.6.0-experiment.0

package/dist/federation/mod.d.ts

@@ -0,0 +1,15 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+import { KvKey, KvStore, KvStoreSetOptions, MemoryKvStore$1 as MemoryKvStore } from "./kv.js";
+import { SenderKeyPair } from "./send.js";
+import { ActorKeyPair, Context, ForwardActivityOptions, GetSignedKeyOptions, InboxContext, ParseUriResult, RequestContext, RouteActivityOptions, SendActivityOptions, SendActivityOptionsForCollection } from "./context.js";
+import { PageItems, buildCollectionSynchronizationHeader$1 as buildCollectionSynchronizationHeader, digest$1 as digest } from "./collection.js";
+import { ActorAliasMapper, ActorDispatcher, ActorHandleMapper, ActorKeyPairsDispatcher, AuthorizePredicate, CollectionCounter, CollectionCursor, CollectionDispatcher, InboxErrorHandler, InboxListener, NodeInfoDispatcher, ObjectAuthorizePredicate, ObjectDispatcher, OutboxErrorHandler, SharedInboxKeyDispatcher } from "./callback.js";
+import { InProcessMessageQueue$1 as InProcessMessageQueue, InProcessMessageQueueOptions, MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions, ParallelMessageQueue$1 as ParallelMessageQueue } from "./mq.js";
+import { CreateExponentialBackoffPolicyOptions, RetryContext, RetryPolicy, createExponentialBackoffPolicy$1 as createExponentialBackoffPolicy } from "./retry.js";
+import { CreateFederationOptions, FederationKvPrefixes, FederationOrigin, FederationQueueOptions, createFederation$1 as createFederation } from "./middleware.js";
+import { ActorCallbackSetters, CollectionCallbackSetters, Federatable, Federation, FederationBuilder, FederationFetchOptions, FederationOptions, FederationStartQueueOptions, InboxListenerSetters, ObjectCallbackSetters } from "./federation.js";
+import { RespondWithObjectOptions, respondWithObject$1 as respondWithObject, respondWithObjectIfAcceptable$1 as respondWithObjectIfAcceptable } from "./handler.js";
+import { Router$1 as Router, RouterError$1 as RouterError, RouterOptions, RouterRouteResult } from "./router.js";
+import { createFederationBuilder$1 as createFederationBuilder } from "./builder.js";
+export { ActorAliasMapper, ActorCallbackSetters, ActorDispatcher, ActorHandleMapper, ActorKeyPair, ActorKeyPairsDispatcher, AuthorizePredicate, CollectionCallbackSetters, CollectionCounter, CollectionCursor, CollectionDispatcher, Context, CreateExponentialBackoffPolicyOptions, CreateFederationOptions, Federatable, Federation, FederationBuilder, FederationFetchOptions, FederationKvPrefixes, FederationOptions, FederationOrigin, FederationQueueOptions, FederationStartQueueOptions, ForwardActivityOptions, GetSignedKeyOptions, InProcessMessageQueue, InProcessMessageQueueOptions, InboxContext, InboxErrorHandler, InboxListener, InboxListenerSetters, KvKey, KvStore, KvStoreSetOptions, MemoryKvStore, MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions, NodeInfoDispatcher, ObjectAuthorizePredicate, ObjectCallbackSetters, ObjectDispatcher, OutboxErrorHandler, PageItems, ParallelMessageQueue, ParseUriResult, RequestContext, RespondWithObjectOptions, RetryContext, RetryPolicy, RouteActivityOptions, Router, RouterError, RouterOptions, RouterRouteResult, SendActivityOptions, SendActivityOptionsForCollection, SenderKeyPair, SharedInboxKeyDispatcher, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, digest, respondWithObject, respondWithObjectIfAcceptable };

package/dist/federation/mod.js

@@ -0,0 +1,14 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Router, RouterError } from "./router.js";
+import { createFederationBuilder } from "./builder.js";
+import { buildCollectionSynchronizationHeader, digest } from "./collection.js";
+import { respondWithObject, respondWithObjectIfAcceptable } from "./handler.js";
+import { MemoryKvStore } from "./kv.js";
+import { createExponentialBackoffPolicy } from "./retry.js";
+import { createFederation } from "./middleware.js";
+import { InProcessMessageQueue, ParallelMessageQueue } from "./mq.js";
+
+export { InProcessMessageQueue, MemoryKvStore, ParallelMessageQueue, Router, RouterError, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, digest, respondWithObject, respondWithObjectIfAcceptable };

package/dist/federation/mq.d.ts

@@ -0,0 +1,127 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+
+//#region federation/mq.d.ts
+/**
+* Additional options for enqueuing a message in a queue.
+*
+* @since 0.5.0
+*/
+/**
+ * Additional options for enqueuing a message in a queue.
+ *
+ * @since 0.5.0
+ */
+interface MessageQueueEnqueueOptions {
+  /**
+   * The delay before the message is enqueued.  No delay by default.
+   *
+   * It must not be negative.
+   */
+  delay?: Temporal.Duration;
+}
+/**
+ * Additional options for listening to a message queue.
+ *
+ * @since 1.0.0
+ */
+interface MessageQueueListenOptions {
+  /**
+   * The signal to abort listening to the message queue.
+   */
+  signal?: AbortSignal;
+}
+/**
+ * An abstract interface for a message queue.
+ *
+ * @since 0.5.0
+ */
+interface MessageQueue {
+  /**
+   * Enqueues a message in the queue.
+   * @param message The message to enqueue.
+   * @param options Additional options for enqueuing the message.
+   */
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+   * Enqueues multiple messages in the queue.  This operation is optional,
+   * and may not be supported by all implementations.  If not supported,
+   * Fedify will invoke {@link enqueue} for each message.
+   *
+   * @param messages The messages to enqueue.
+   * @param options Additional options for enqueuing the messages.
+   */
+  enqueueMany?: (messages: any[], options?: MessageQueueEnqueueOptions) => Promise<void>;
+  /**
+   * Listens for messages in the queue.
+   * @param handler The handler for messages in the queue.
+   * @param options Additional options for listening to the message queue.
+   * @returns A promise that resolves when the listening is done.  It never
+   *          rejects, and is resolved when the signal is aborted.  If no
+   *          signal is provided, it never resolves.
+   */
+  listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+}
+/**
+ * Additional options for {@link InProcessMessageQueue}.
+ * @since 1.0.0
+ */
+interface InProcessMessageQueueOptions {
+  /**
+   * The interval to poll for messages in the queue.  5 seconds by default.
+   * @default `{ seconds: 5 }`
+   */
+  pollInterval?: Temporal.Duration | Temporal.DurationLike;
+}
+/**
+ * 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
+ */
+declare class InProcessMessageQueue implements MessageQueue {
+  #private;
+  /**
+   * Constructs a new {@link InProcessMessageQueue} with the given options.
+   * @param options Additional options for the in-process message queue.
+   */
+  constructor(options?: InProcessMessageQueueOptions);
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+}
+/**
+ * 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.
+ *
+ * @since 1.0.0
+ */
+declare class ParallelMessageQueue implements MessageQueue {
+  #private;
+  readonly queue: MessageQueue;
+  readonly workers: number;
+  /**
+   * 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: MessageQueue, workers: number);
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+} //#endregion
+export { InProcessMessageQueue as InProcessMessageQueue$1, InProcessMessageQueueOptions, MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions, ParallelMessageQueue as ParallelMessageQueue$1 };

package/dist/federation/mq.js

@@ -0,0 +1,147 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region 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;
+	/**
+	* 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");
+	}
+	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();
+		}
+		this.#messages.push(message);
+		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();
+		}
+		this.#messages.push(...messages);
+		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) {
+			while (this.#messages.length > 0) {
+				const message = this.#messages.shift();
+				await handler(message);
+			}
+			await this.#wait(this.#pollIntervalMs, 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.
+*
+* @since 1.0.0
+*/
+var ParallelMessageQueue = class ParallelMessageQueue {
+	queue;
+	workers;
+	/**
+	* 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;
+	}
+	enqueue(message, options) {
+		return this.queue.enqueue(message, options);
+	}
+	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);
+			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);
+	}
+	listen(handler, options = {}) {
+		const workers = 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 promise = this.#work(workerId, handler, message);
+			workers.set(workerId, promise);
+		}, options);
+	}
+	async #work(workerId, handler, message) {
+		await this.#sleep(0);
+		await handler(message);
+		return workerId;
+	}
+	#sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+
+//#endregion
+export { InProcessMessageQueue, ParallelMessageQueue };

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

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

package/dist/federation/mq.test.js

@@ -0,0 +1,124 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { InProcessMessageQueue, ParallelMessageQueue } from "./mq.js";
+import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
+import { test } from "../testing/mod.js";
+import { assertGreaterOrEqual } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_greater_or_equal.js";
+import { assertGreater } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_greater.js";
+import { delay } from "@es-toolkit/es-toolkit";
+
+//#region federation/mq.test.ts
+test("InProcessMessageQueue", async (t) => {
+	const mq = new InProcessMessageQueue();
+	const messages = [];
+	const controller = new AbortController();
+	const listening = mq.listen((message) => {
+		messages.push(message);
+	}, controller);
+	await t.step("enqueue()", async () => {
+		await mq.enqueue("Hello, world!");
+	});
+	await waitFor(() => messages.length > 0, 15e3);
+	await t.step("listen()", () => {
+		assertEquals(messages, ["Hello, world!"]);
+	});
+	let started = 0;
+	await t.step("enqueue() with delay", async () => {
+		started = Date.now();
+		await mq.enqueue("Delayed message", { delay: Temporal.Duration.from({ seconds: 3 }) });
+		assertEquals(messages, ["Hello, world!"]);
+	});
+	await waitFor(() => messages.length > 1, 15e3);
+	await t.step("listen() with delay", () => {
+		assertEquals(messages, ["Hello, world!", "Delayed message"]);
+		assertGreater(Date.now() - started, 3e3);
+	});
+	while (messages.length > 0) messages.pop();
+	await t.step("enqueueMany()", async () => {
+		const testMessages = Array.from({ length: 5 }, (_, i) => `Batch message ${i}!`);
+		await mq.enqueueMany(testMessages);
+	});
+	await waitFor(() => messages.length >= 5, 15e3);
+	await t.step("listen() [multiple]", () => {
+		assertEquals(messages.length, 5);
+		for (let i = 0; i < 5; i++) assertEquals(messages[i], `Batch message ${i}!`);
+	});
+	while (messages.length > 0) messages.pop();
+	started = 0;
+	await t.step("enqueueMany() with delay", async () => {
+		started = Date.now();
+		const testMessages = Array.from({ length: 3 }, (_, i) => `Delayed batch ${i}!`);
+		await mq.enqueueMany(testMessages, { delay: Temporal.Duration.from({ seconds: 2 }) });
+		assertEquals(messages.length, 0);
+	});
+	await waitFor(() => messages.length >= 3, 15e3);
+	await t.step("listen() [delayed multiple]", () => {
+		assertEquals(messages.length, 3);
+		assertGreater(Date.now() - started, 2e3);
+		for (let i = 0; i < 3; i++) assertEquals(messages[i], `Delayed batch ${i}!`);
+	});
+	controller.abort();
+	await listening;
+});
+const queues = { InProcessMessageQueue: () => Promise.resolve(new InProcessMessageQueue()) };
+if ("Deno" in globalThis && "openKv" in globalThis.Deno && typeof globalThis.Deno.openKv === "function") {
+	const { DenoKvMessageQueue } = await import("../x/denokv.js");
+	queues.DenoKvMessageQueue = async () => new DenoKvMessageQueue(await globalThis.Deno.openKv(":memory:"));
+}
+for (const mqName in queues) test(`ParallelMessageQueue [${mqName}]`, async (t) => {
+	const mq = await queues[mqName]();
+	const workers = new ParallelMessageQueue(mq, 5);
+	const messages = [];
+	const controller = new AbortController();
+	const listening = workers.listen(async (message) => {
+		for (let i = 0, cnt = 5 + Math.random() * 5; i < cnt; i++) await delay(250);
+		messages.push(message);
+	}, controller);
+	await t.step("enqueue() [single]", async () => {
+		await workers.enqueue("Hello, world!");
+	});
+	await waitFor(() => messages.length > 0, 15e3);
+	await t.step("listen() [single]", () => {
+		assertEquals(messages, ["Hello, world!"]);
+	});
+	messages.pop();
+	await t.step("enqueue() [multiple]", async () => {
+		for (let i = 0; i < 20; i++) await workers.enqueue(`Hello, ${i}!`);
+	});
+	await t.step("listen() [multiple]", async () => {
+		await delay(3e3);
+		assertGreaterOrEqual(messages.length, 5);
+		await waitFor(() => messages.length >= 20, 15e3);
+		assertEquals(messages.length, 20);
+	});
+	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);
+	});
+	await t.step("listen() [multiple]", async () => {
+		await delay(3e3);
+		assertGreaterOrEqual(messages.length, 5);
+		await waitFor(() => messages.length >= 20, 15e3);
+		assertEquals(messages.length, 20);
+	});
+	await waitFor(() => messages.length >= 20, 15e3);
+	controller.abort();
+	await listening;
+	if (Symbol.dispose in mq) {
+		const dispose = mq[Symbol.dispose];
+		if (typeof dispose === "function") dispose.call(mq);
+	}
+});
+async function waitFor(predicate, timeoutMs) {
+	const started = Date.now();
+	while (!predicate()) {
+		await delay(500);
+		if (Date.now() - started > timeoutMs) throw new Error("Timeout");
+	}
+}
+
+//#endregion

package/dist/federation/negotiation.js

@@ -0,0 +1,63 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region federation/negotiation.ts
+function compareSpecs(a, b) {
+	return b.q - a.q || (b.s ?? 0) - (a.s ?? 0) || (a.o ?? 0) - (b.o ?? 0) || a.i - b.i || 0;
+}
+function isQuality(spec) {
+	return spec.q > 0;
+}
+const simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
+function splitKeyValuePair(str) {
+	const [key, value] = str.split("=");
+	return [key.toLowerCase(), value];
+}
+function parseMediaType(str, i) {
+	const match = simpleMediaTypeRegExp.exec(str);
+	if (!match) return;
+	const [, type, subtype, parameters] = match;
+	if (!type || !subtype) return;
+	const params = Object.create(null);
+	let q = 1;
+	if (parameters) {
+		const kvps = parameters.split(";").map((p) => p.trim()).map(splitKeyValuePair);
+		for (const [key, val] of kvps) {
+			const value = val && val[0] === `"` && val[val.length - 1] === `"` ? val.slice(1, val.length - 1) : val;
+			if (key === "q" && value) {
+				q = parseFloat(value);
+				break;
+			}
+			params[key] = value;
+		}
+	}
+	return {
+		type,
+		subtype,
+		params,
+		i,
+		o: void 0,
+		q,
+		s: void 0
+	};
+}
+function parseAccept(accept) {
+	const accepts = accept.split(",").map((p) => p.trim());
+	const mediaTypes = [];
+	for (const [index, accept$1] of accepts.entries()) {
+		const mediaType = parseMediaType(accept$1.trim(), index);
+		if (mediaType) mediaTypes.push(mediaType);
+	}
+	return mediaTypes;
+}
+function getFullType(spec) {
+	return `${spec.type}/${spec.subtype}`;
+}
+function preferredMediaTypes(accept) {
+	const accepts = parseAccept(accept === void 0 ? "*/*" : accept ?? "");
+	return accepts.filter(isQuality).sort(compareSpecs).map(getFullType);
+}
+
+//#endregion
+export { preferredMediaTypes };

package/dist/federation/retry.d.ts

@@ -0,0 +1,71 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+
+//#region federation/retry.d.ts
+/**
+* The context passed to a {@link RetryPolicy} callback.
+* @since 0.12.0
+*/
+/**
+ * The context passed to a {@link RetryPolicy} callback.
+ * @since 0.12.0
+ */
+interface RetryContext {
+  /**
+   * The elapsed time since the first attempt.
+   */
+  readonly elapsedTime: Temporal.Duration;
+  /**
+   * The number of attempts so far.
+   */
+  readonly attempts: number;
+}
+/**
+ * A policy that determines the delay before the next retry.
+ * @param context The retry context.
+ * @returns The delay before the next retry, or `null` to stop retrying.
+ *          It must not negative.
+ * @since 0.12.0
+ */
+type RetryPolicy = (context: RetryContext) => Temporal.Duration | null;
+/**
+ * Options for {@link createExponentialBackoffPolicy} function.
+ * @since 0.12.0
+ */
+interface CreateExponentialBackoffPolicyOptions {
+  /**
+   * The initial delay before the first retry.  Defaults to 1 second.
+   */
+  readonly initialDelay?: Temporal.DurationLike;
+  /**
+   * The maximum delay between retries.  Defaults to 12 hours.
+   */
+  readonly maxDelay?: Temporal.DurationLike;
+  /**
+   * The maximum number of attempts before giving up.
+   * Defaults to 10.
+   */
+  readonly maxAttempts?: number;
+  /**
+   * The factor to multiply the previous delay by for each retry.
+   * Defaults to 2.
+   */
+  readonly factor?: number;
+  /**
+   * Whether to add jitter to the delay to avoid synchronization.
+   * Turned on by default.
+   */
+  readonly jitter?: boolean;
+}
+/**
+ * Creates an exponential backoff retry policy.  The delay between retries
+ * starts at the `initialDelay` and is multiplied by the `factor` for each
+ * subsequent retry, up to the `maxDelay`.  The policy will give up after
+ * `maxAttempts` attempts.  The actual delay is randomized to avoid
+ * synchronization (jitter).
+ * @param options The options for the policy.
+ * @returns The retry policy.
+ * @since 0.12.0
+ */
+declare function createExponentialBackoffPolicy(options?: CreateExponentialBackoffPolicyOptions): RetryPolicy; //#endregion
+export { CreateExponentialBackoffPolicyOptions, RetryContext, RetryPolicy, createExponentialBackoffPolicy as createExponentialBackoffPolicy$1 };

package/dist/federation/retry.js

@@ -0,0 +1,36 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region federation/retry.ts
+/**
+* Creates an exponential backoff retry policy.  The delay between retries
+* starts at the `initialDelay` and is multiplied by the `factor` for each
+* subsequent retry, up to the `maxDelay`.  The policy will give up after
+* `maxAttempts` attempts.  The actual delay is randomized to avoid
+* synchronization (jitter).
+* @param options The options for the policy.
+* @returns The retry policy.
+* @since 0.12.0
+*/
+function createExponentialBackoffPolicy(options = {}) {
+	const initialDelay = Temporal.Duration.from(options.initialDelay ?? { seconds: 1 });
+	const maxDelay = Temporal.Duration.from(options.maxDelay ?? { hours: 12 });
+	const maxAttempts = options.maxAttempts ?? 10;
+	const factor = options.factor ?? 2;
+	const jitter = options.jitter ?? true;
+	return ({ attempts }) => {
+		if (attempts >= maxAttempts) return null;
+		let milliseconds = initialDelay.total("millisecond");
+		milliseconds *= factor ** attempts;
+		if (jitter) {
+			milliseconds *= 1 + Math.random();
+			milliseconds = Math.round(milliseconds);
+		}
+		const delay = Temporal.Duration.from({ milliseconds });
+		return Temporal.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
+	};
+}
+
+//#endregion
+export { createExponentialBackoffPolicy };

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

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

package/dist/federation/retry.test.js

@@ -0,0 +1,44 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { createExponentialBackoffPolicy } from "./retry.js";
+import { AssertionError } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assertion_error.js";
+import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
+import { test } from "../testing/mod.js";
+import { assertNotEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_not_equals.js";
+
+//#region federation/retry.test.ts
+test("createExponentialBackoffPolicy()", () => {
+	const policy = createExponentialBackoffPolicy({ maxAttempts: 4 });
+	const noMatter = Temporal.Duration.from({ seconds: 0 });
+	for (let i = 0; i < 10; i++) assertDurationRange(policy({
+		elapsedTime: noMatter,
+		attempts: 0
+	}), { seconds: 1 }, { seconds: 2 });
+	for (let i = 0; i < 10; i++) assertDurationRange(policy({
+		elapsedTime: noMatter,
+		attempts: 1
+	}), { seconds: 2 }, { seconds: 4 });
+	for (let i = 0; i < 10; i++) assertDurationRange(policy({
+		elapsedTime: noMatter,
+		attempts: 2
+	}), { seconds: 4 }, { seconds: 8 });
+	for (let i = 0; i < 10; i++) assertDurationRange(policy({
+		elapsedTime: noMatter,
+		attempts: 3
+	}), { seconds: 8 }, { seconds: 16 });
+	assertEquals(policy({
+		elapsedTime: noMatter,
+		attempts: 4
+	}), null);
+});
+function assertDurationRange(actual, min, max) {
+	assertNotEquals(actual, null);
+	if (actual == null) return;
+	const minDuration = Temporal.Duration.from(min);
+	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