@fedify/fedify 0.12.0-dev.263 → 0.12.0-dev.266

package/CHANGES.md

@@ -8,6 +8,29 @@ Version 0.12.0
 
 To be released.
 
+ -  Incoming activities are now queued before being dispatched to the inbox
+    listener if the `queue` option is provided to the `createFederation()`
+    function.  [[#70]]
+
+     -  The type of `InboxListener` callback type's first parameter became
+        `Context` (was `RequestContext`).
+     -  The type of `InboxErrorHandler` callback type's first parameter became
+        `Context` (was `RequestContext`).
+     -  The type of `SharedInboxKeyDispatcher` callback type's first parameter
+        became `Context` (was `RequestContext`).
+
+ -  Implemented fully customizable retry policy for failed tasks in the task
+    queue.  By default, the task queue retries the failed tasks with
+    an exponential backoff policy with decorrelated jitter.
+
+     -  Added `outboxRetryPolicy` option to `CreateFederationOptions` interface.
+     -  Added `inboxRetryPolicy` option to `CreateFederationOptions` interface.
+        [[#70]]
+     -  Added `RetryPolicy` callback type.
+     -  Added `RetryContext` interface.
+     -  Added `createExponentialBackoffPolicy()` function.
+     -  Added `CreateExponentialBackoffPolicyOptions` interface.
+
  -  Added `ChatMessage` class to Activity Vocabulary API.  [[#85]]
 
  -  Improved multitenancy (virtual hosting) support.  [[#66]]
@@ -18,7 +41,19 @@ To be released.
      -  The type of `ActorKeyPairsDispatcher<TContextData>`'s first parameter
         became `Context` (was `TContextData`).
 
+ -  Deprecated `Federation.sendActivity()` method.  Use `Context.sendActivity()`
+    method instead.
+
+ -  The last parameter of `Federation.sendActivity()` method is no longer
+    optional.  Also, it now takes the required `contextData` option.
+
+ -  Added more log messages using the [LogTape] library.  Currently the below
+    logger categories are used:
+
+     -  `["fedify", "federation", "queue"]`
+
 [#66]: https://github.com/dahlia/fedify/issues/66
+[#70]: https://github.com/dahlia/fedify/issues/70
 [#85]: https://github.com/dahlia/fedify/issues/85
 
 

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/concat.js

@@ -9,7 +9,7 @@
  * @example Basic usage
  * ```ts
  * import { concat } from "@std/bytes/concat";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const a = new Uint8Array([0, 1, 2]);
  * const b = new Uint8Array([3, 4, 5]);

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/copy.js

@@ -16,7 +16,7 @@
  * @example Basic usage
  * ```ts
  * import { copy } from "@std/bytes/copy";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const src = new Uint8Array([9, 8, 7]);
  * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);
@@ -28,7 +28,7 @@
  * @example Copy with offset
  * ```ts
  * import { copy } from "@std/bytes/copy";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const src = new Uint8Array([1, 1, 1, 1]);
  * const dst = new Uint8Array([0, 0, 0, 0]);

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/ends_with.js

@@ -14,7 +14,7 @@
  * @example Basic usage
  * ```ts
  * import { endsWith } from "@std/bytes/ends-with";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
  * const suffix = new Uint8Array([1, 2, 3]);

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/equals.js

@@ -61,7 +61,7 @@ const THRESHOLD_32_BIT = 160;
  * @example Basic usage
  * ```ts
  * import { equals } from "@std/bytes/equals";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const a = new Uint8Array([1, 2, 3]);
  * const b = new Uint8Array([1, 2, 3]);

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/includes_needle.js

@@ -16,7 +16,7 @@ import { indexOfNeedle } from "./index_of_needle.js";
  * @example Basic usage
  * ```ts
  * import { includesNeedle } from "@std/bytes/includes-needle";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
  * const needle = new Uint8Array([1, 2]);
@@ -27,7 +27,7 @@ import { indexOfNeedle } from "./index_of_needle.js";
  * @example Start index
  * ```ts
  * import { includesNeedle } from "@std/bytes/includes-needle";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
  * const needle = new Uint8Array([1, 2]);

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/index_of_needle.js

@@ -19,7 +19,7 @@
  * @example Basic usage
  * ```ts
  * import { indexOfNeedle } from "@std/bytes/index-of-needle";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
  * const needle = new Uint8Array([1, 2]);
@@ -32,7 +32,7 @@
  * @example Start index
  * ```ts
  * import { indexOfNeedle } from "@std/bytes/index-of-needle";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
  * const needle = new Uint8Array([1, 2]);

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/last_index_of_needle.js

@@ -16,7 +16,7 @@
  * @example Basic usage
  * ```ts
  * import { lastIndexOfNeedle } from "@std/bytes/last-index-of-needle";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
  * const needle = new Uint8Array([1, 2]);
@@ -29,7 +29,7 @@
  * @example Start index
  * ```ts
  * import { lastIndexOfNeedle } from "@std/bytes/last-index-of-needle";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
  * const needle = new Uint8Array([1, 2]);

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/mod.js

@@ -7,7 +7,7 @@
  *
  * ```ts
  * import { concat, indexOfNeedle, endsWith } from "@std/bytes";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const a = new Uint8Array([0, 1, 2]);
  * const b = new Uint8Array([3, 4, 5]);

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/repeat.js

@@ -13,7 +13,7 @@ import { copy } from "./copy.js";
  * @example Basic usage
  * ```ts
  * import { repeat } from "@std/bytes/repeat";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2]);
  *
@@ -23,7 +23,7 @@ import { copy } from "./copy.js";
  * @example Zero count
  * ```ts
  * import { repeat } from "@std/bytes/repeat";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2]);
  *

package/esm/deps/jsr.io/@std/bytes/{1.0.0 → 1.0.1}/starts_with.js

@@ -14,7 +14,7 @@
  * @example Basic usage
  * ```ts
  * import { startsWith } from "@std/bytes/starts-with";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
  * const prefix = new Uint8Array([0, 1, 2]);

package/esm/federation/handler.js

@@ -166,7 +166,7 @@ function filterCollectionItems(items, collectionName, filterPredicate) {
     }
     return result;
 }
-export async function handleInbox(request, { handle, context, kv, kvPrefix, actorDispatcher, inboxListeners, inboxErrorHandler, onNotFound, signatureTimeWindow, }) {
+export async function handleInbox(request, { handle, context, kv, kvPrefix, queue, actorDispatcher, inboxListeners, inboxErrorHandler, onNotFound, signatureTimeWindow, }) {
     const logger = getLogger(["fedify", "federation", "inbox"]);
     if (actorDispatcher == null) {
         logger.error("Actor dispatcher is not set.", { handle });
@@ -185,7 +185,12 @@ export async function handleInbox(request, { handle, context, kv, kvPrefix, acto
     }
     catch (error) {
         logger.error("Failed to parse JSON:\n{error}", { handle, error });
-        await inboxErrorHandler?.(context, error);
+        try {
+            await inboxErrorHandler?.(context, error);
+        }
+        catch (error) {
+            logger.error("An unexpected error occurred in inbox error handler:\n{error}", { error, activity: json });
+        }
         return new Response("Invalid JSON.", {
             status: 400,
             headers: { "Content-Type": "text/plain; charset=utf-8" },
@@ -197,7 +202,12 @@ export async function handleInbox(request, { handle, context, kv, kvPrefix, acto
     }
     catch (error) {
         logger.error("Failed to parse activity:\n{error}", { handle, json, error });
-        await inboxErrorHandler?.(context, error);
+        try {
+            await inboxErrorHandler?.(context, error);
+        }
+        catch (error) {
+            logger.error("An unexpected error occurred in inbox error handler:\n{error}", { error, activity: json });
+        }
         return new Response("Invalid activity.", {
             status: 400,
             headers: { "Content-Type": "text/plain; charset=utf-8" },
@@ -256,29 +266,39 @@ export async function handleInbox(request, { handle, context, kv, kvPrefix, acto
         });
         return response;
     }
-    // deno-lint-ignore no-explicit-any
-    let cls = activity
-        // deno-lint-ignore no-explicit-any
-        .constructor;
-    while (true) {
-        if (inboxListeners.has(cls))
-            break;
-        if (cls === Activity) {
-            logger.error("Unsupported activity type:\n{activity}", { activity: json });
-            return new Response("", {
-                status: 202,
-                headers: { "Content-Type": "text/plain; charset=utf-8" },
-            });
-        }
-        cls = globalThis.Object.getPrototypeOf(cls);
+    if (queue != null) {
+        await queue.enqueue({
+            type: "inbox",
+            baseUrl: request.url,
+            activity: json,
+            handle,
+            attempt: 0,
+            started: new Date().toISOString(),
+        });
+        return new Response("Activity is enqueued.", {
+            status: 202,
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+        });
+    }
+    const listener = inboxListeners?.dispatch(activity);
+    if (listener == null) {
+        logger.error("Unsupported activity type:\n{activity}", { activity: json });
+        return new Response("", {
+            status: 202,
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+        });
     }
-    const listener = inboxListeners.get(cls);
     try {
         await listener(context, activity);
     }
     catch (error) {
-        logger.error("Failed to process the activity:\n{error}", { error, activity: json });
-        await inboxErrorHandler?.(context, error);
+        try {
+            await inboxErrorHandler?.(context, error);
+        }
+        catch (error) {
+            logger.error("An unexpected error occurred in inbox error handler:\n{error}", { error, activityId: activity.id?.href, activity: json });
+        }
+        logger.error("Failed to process the incoming activity {activityId}:\n{error}", { error, activityId: activity.id?.href, activity: json });
         return new Response("Internal server error.", {
             status: 500,
             headers: { "Content-Type": "text/plain; charset=utf-8" },

package/esm/federation/inbox.js

@@ -0,0 +1,34 @@
+import { Activity } from "../vocab/vocab.js";
+export class InboxListenerSet {
+    #listeners;
+    constructor() {
+        this.#listeners = new Map();
+    }
+    add(
+    // deno-lint-ignore no-explicit-any
+    type, listener) {
+        if (this.#listeners.has(type)) {
+            throw new TypeError("Listener already set for this type.");
+        }
+        this.#listeners.set(type, listener);
+    }
+    dispatch(activity) {
+        // deno-lint-ignore no-explicit-any
+        let cls = activity
+            // deno-lint-ignore no-explicit-any
+            .constructor;
+        const inboxListeners = this.#listeners;
+        if (inboxListeners == null) {
+            return null;
+        }
+        while (true) {
+            if (inboxListeners.has(cls))
+                break;
+            if (cls === Activity)
+                return null;
+            cls = globalThis.Object.getPrototypeOf(cls);
+        }
+        const listener = inboxListeners.get(cls);
+        return listener;
+    }
+}

package/esm/federation/middleware.js

@@ -9,6 +9,8 @@ import { Activity, CryptographicKey, Multikey, } from "../vocab/vocab.js";
 import { handleWebFinger } from "../webfinger/handler.js";
 import { buildCollectionSynchronizationHeader } from "./collection.js";
 import { handleActor, handleCollection, handleInbox, handleObject, } from "./handler.js";
+import { InboxListenerSet } from "./inbox.js";
+import { createExponentialBackoffPolicy } from "./retry.js";
 import { Router, RouterError } from "./router.js";
 import { extractInboxes, sendActivity } from "./send.js";
 const invokedByCreateFederation = Symbol("invokedByCreateFederation");
@@ -25,6 +27,7 @@ export function createFederation(options) {
         [invokedByCreateFederation]: true,
     });
 }
+const invokedByContext = Symbol("invokedByContext");
 /**
  * An object that registers federation-related business logic and dispatches
  * requests to the appropriate handlers.
@@ -59,13 +62,15 @@ export class Federation {
     #treatHttps;
     #onOutboxError;
     #signatureTimeWindow;
-    #backoffSchedule;
+    #outboxRetryPolicy;
+    #inboxRetryPolicy;
     /**
      * Create a new {@link Federation} instance.
      * @param parameters Parameters for initializing the instance.
      * @deprecated Use {@link createFederation} method instead.
      */
-    constructor(options) {
+    constructor(parameters) {
+        const options = parameters;
         const logger = getLogger(["fedify", "federation"]);
         // @ts-ignore: This is a private symbol.
         if (!options[invokedByCreateFederation]) {
@@ -97,37 +102,42 @@ export class Federation {
             options.authenticatedDocumentLoaderFactory ??
                 getAuthenticatedDocumentLoader;
         this.#onOutboxError = options.onOutboxError;
-        this.#treatHttps = options.treatHttps ?? false;
-        if (options.treatHttps) {
+        this.#treatHttps = parameters.treatHttps ?? false;
+        if (parameters.treatHttps) {
             logger.warn("The treatHttps option is deprecated and will be removed in " +
                 "a future release.  Instead, use the x-forwarded-fetch library" +
                 " to recognize the X-Forwarded-Host and X-Forwarded-Proto " +
                 "headers.  See also: <https://github.com/dahlia/x-forwarded-fetch>.");
         }
         this.#signatureTimeWindow = options.signatureTimeWindow ?? { minutes: 1 };
-        this.#backoffSchedule = options.backoffSchedule ?? [
-            3000,
-            15000,
-            60000,
-            15 * 60000,
-            60 * 60000,
-        ].map((ms) => dntShim.Temporal.Duration.from({ milliseconds: ms }));
+        this.#outboxRetryPolicy = options.outboxRetryPolicy ??
+            createExponentialBackoffPolicy();
+        this.#inboxRetryPolicy = options.inboxRetryPolicy ??
+            createExponentialBackoffPolicy();
     }
-    #startQueue() {
+    #startQueue(ctxData) {
         if (this.#queue != null && !this.#queueStarted) {
-            const logger = getLogger(["fedify", "federation", "outbox"]);
-            logger.debug("Starting an outbox queue.");
-            this.#queue?.listen(this.#listenQueue.bind(this));
+            const logger = getLogger(["fedify", "federation", "queue"]);
+            logger.debug("Starting a task queue.");
+            this.#queue?.listen((msg) => this.#listenQueue(ctxData, msg));
             this.#queueStarted = true;
         }
     }
-    async #listenQueue(message) {
+    async #listenQueue(ctxData, message) {
+        if (message.type === "outbox") {
+            await this.#listenOutboxMessage(ctxData, message);
+        }
+        else if (message.type === "inbox") {
+            await this.#listenInboxMessage(ctxData, message);
+        }
+    }
+    async #listenOutboxMessage(_, message) {
         const logger = getLogger(["fedify", "federation", "outbox"]);
         const logData = {
             keyIds: message.keys.map((pair) => pair.keyId),
             inbox: message.inbox,
             activity: message.activity,
-            trial: message.trial,
+            attempt: message.attempt,
             headers: message.headers,
         };
         let activity = null;
@@ -167,22 +177,120 @@ export class Federation {
             catch (error) {
                 logger.error("An unexpected error occurred in onError handler:\n{error}", { ...logData, error, activityId: activity?.id?.href });
             }
-            if (message.trial < this.#backoffSchedule.length) {
-                logger.error("Failed to send activity {activityId} to {inbox} (trial #{trial})" +
-                    "; retry...:\n{error}", { ...logData, error, activityId: activity?.id?.href });
+            const delay = this.#outboxRetryPolicy({
+                elapsedTime: dntShim.Temporal.Instant.from(message.started).until(dntShim.Temporal.Now.instant()),
+                attempts: message.attempt,
+            });
+            if (delay != null) {
+                logger.error("Failed to send activity {activityId} to {inbox} (attempt " +
+                    "#{attempt}); retry...:\n{error}", { ...logData, error, activityId: activity?.id?.href });
                 this.#queue?.enqueue({
                     ...message,
-                    trial: message.trial + 1,
-                }, { delay: this.#backoffSchedule[message.trial] });
+                    attempt: message.attempt + 1,
+                }, {
+                    delay: dntShim.Temporal.Duration.compare(delay, { seconds: 0 }) < 0
+                        ? dntShim.Temporal.Duration.from({ seconds: 0 })
+                        : delay,
+                });
             }
             else {
-                logger.error("Failed to send activity {activityId} to {inbox} after {trial} " +
-                    "trials; giving up:\n{error}", { ...logData, error, activityId: activity?.id?.href });
+                logger.error("Failed to send activity {activityId} to {inbox} after {attempt} " +
+                    "attempts; giving up:\n{error}", { ...logData, error, activityId: activity?.id?.href });
             }
             return;
         }
         logger.info("Successfully sent activity {activityId} to {inbox}.", { ...logData, activityId: activity?.id?.href });
     }
+    async #listenInboxMessage(ctxData, message) {
+        const logger = getLogger(["fedify", "federation", "inbox"]);
+        const baseUrl = new URL(message.baseUrl);
+        let context = this.#createContext(baseUrl, ctxData);
+        if (message.handle) {
+            context = this.#createContext(baseUrl, ctxData, {
+                documentLoader: await context.getDocumentLoader({
+                    handle: message.handle,
+                }),
+            });
+        }
+        else if (this.#sharedInboxKeyDispatcher != null) {
+            const identity = await this.#sharedInboxKeyDispatcher(context);
+            if (identity != null) {
+                context = this.#createContext(baseUrl, ctxData, {
+                    documentLoader: "handle" in identity
+                        ? await context.getDocumentLoader(identity)
+                        : context.getDocumentLoader(identity),
+                });
+            }
+        }
+        const activity = await Activity.fromJsonLd(message.activity, context);
+        const cacheKey = activity.id == null ? null : [
+            ...this.#kvPrefixes.activityIdempotence,
+            activity.id.href,
+        ];
+        if (cacheKey != null) {
+            const cached = await this.#kv.get(cacheKey);
+            if (cached === true) {
+                logger.debug("Activity {activityId} has already been processed.", {
+                    activityId: activity.id?.href,
+                    activity: message.activity,
+                });
+                return;
+            }
+        }
+        const listener = this.#inboxListeners?.dispatch(activity);
+        if (listener == null) {
+            logger.error("Unsupported activity type:\n{activity}", { activity: message.activity, trial: message.attempt });
+            return;
+        }
+        try {
+            await listener(context, activity);
+        }
+        catch (error) {
+            try {
+                await this.#inboxErrorHandler?.(context, error);
+            }
+            catch (error) {
+                logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
+                    error,
+                    trial: message.attempt,
+                    activityId: activity.id?.href,
+                    activity: message.activity,
+                });
+            }
+            const delay = this.#inboxRetryPolicy({
+                elapsedTime: dntShim.Temporal.Instant.from(message.started).until(dntShim.Temporal.Now.instant()),
+                attempts: message.attempt,
+            });
+            if (delay != null) {
+                logger.error("Failed to process the incoming activity {activityId} (attempt " +
+                    "#{attempt}); retry...:\n{error}", {
+                    error,
+                    attempt: message.attempt,
+                    activityId: activity.id?.href,
+                    activity: message.activity,
+                });
+                this.#queue?.enqueue({
+                    ...message,
+                    attempt: message.attempt + 1,
+                }, {
+                    delay: dntShim.Temporal.Duration.compare(delay, { seconds: 0 }) < 0
+                        ? dntShim.Temporal.Duration.from({ seconds: 0 })
+                        : delay,
+                });
+            }
+            else {
+                logger.error("Failed to process the incoming activity {activityId} after " +
+                    "{trial} attempts; giving up:\n{error}", { error, activityId: activity.id?.href, activity: message.activity });
+            }
+            return;
+        }
+        if (cacheKey != null) {
+            await this.#kv.set(cacheKey, true, {
+                ttl: dntShim.Temporal.Duration.from({ days: 1 }),
+            });
+        }
+        logger.info("Activity {activityId} has been processed.", { activityId: activity.id?.href, activity: message.activity });
+    }
     createContext(urlOrRequest, contextData) {
         return urlOrRequest instanceof Request
             ? this.#createContext(urlOrRequest, contextData)
@@ -827,15 +935,12 @@ export class Federation {
                 throw new RouterError("Path for shared inbox must have no variables.");
             }
         }
-        const listeners = this.#inboxListeners = new Map();
+        const listeners = this.#inboxListeners = new InboxListenerSet();
         const setters = {
             on(
             // deno-lint-ignore no-explicit-any
             type, listener) {
-                if (listeners.has(type)) {
-                    throw new TypeError("Listener already set for this type.");
-                }
-                listeners.set(type, listener);
+                listeners.add(type, listener);
                 return setters;
             },
             onError: (handler) => {
@@ -858,9 +963,15 @@ export class Federation {
      * @param activity The activity to send.
      * @param options Options for sending the activity.
      * @throws {TypeError} If the activity to send does not have an actor.
+     * @deprecated Use {@link Context.sendActivity} instead.
      */
-    async sendActivity(keys, recipients, activity, { preferSharedInbox, immediate, excludeBaseUris, collectionSync } = {}) {
+    async sendActivity(keys, recipients, activity, options) {
         const logger = getLogger(["fedify", "federation", "outbox"]);
+        if (!(invokedByContext in options) || !options[invokedByContext]) {
+            logger.warn("The Federation.sendActivity() method is deprecated.  Use " +
+                "Context.sendActivity() instead.");
+        }
+        const { preferSharedInbox, immediate, excludeBaseUris, collectionSync, contextData, } = options;
         if (keys.length < 1) {
             throw new TypeError("The sender's keys must not be empty.");
         }
@@ -871,7 +982,7 @@ export class Federation {
             logger.error("Activity {activityId} to send does not have an actor.", { activity, activityId: activity?.id?.href });
             throw new TypeError("The activity to send must have at least one actor property.");
         }
-        this.#startQueue();
+        this.#startQueue(contextData);
         if (activity.id == null) {
             activity = activity.clone({
                 id: new URL(`urn:uuid:${dntShim.crypto.randomUUID()}`),
@@ -925,7 +1036,8 @@ export class Federation {
                 keys: keyJwkPairs,
                 activity: activityJson,
                 inbox,
-                trial: 0,
+                started: new Date().toISOString(),
+                attempt: 0,
                 headers: collectionSync == null ? {} : {
                     "Collection-Synchronization": await buildCollectionSynchronizationHeader(collectionSync, inboxes[inbox]),
                 },
@@ -1067,7 +1179,7 @@ export class Federation {
                     kv: this.#kv,
                     kvPrefix: this.#kvPrefixes.activityIdempotence,
                     actorDispatcher: this.#actorCallbacks?.dispatcher,
-                    inboxListeners: this.#inboxListeners ?? new Map(),
+                    inboxListeners: this.#inboxListeners,
                     inboxErrorHandler: this.#inboxErrorHandler,
                     onNotFound,
                     signatureTimeWindow: this.#signatureTimeWindow,
@@ -1451,7 +1563,12 @@ class ContextImpl {
         else {
             keys = [sender];
         }
-        const opts = { ...options };
+        const opts = {
+            contextData: this.data,
+            ...options,
+            // @ts-ignore: This is a private symbol
+            [invokedByContext]: true,
+        };
         let expandedRecipients;
         if (Array.isArray(recipients)) {
             expandedRecipients = recipients;

package/esm/federation/mod.js

@@ -10,4 +10,5 @@ export { respondWithObject, respondWithObjectIfAcceptable, } from "./handler.js"
 export * from "./kv.js";
 export * from "./middleware.js";
 export * from "./mq.js";
+export * from "./retry.js";
 export * from "./router.js";

package/esm/federation/mq.js

@@ -13,7 +13,7 @@ export class InProcessMessageQueue {
     enqueue(message, options) {
         const delay = options?.delay == null
             ? 0
-            : options.delay.total("millisecond");
+            : Math.max(options.delay.total("millisecond"), 0);
         setTimeout(() => {
             for (const handler of this.#handlers)
                 handler(message);