@fedify/fedify 2.3.0 → 2.4.0-dev.1422

package/dist/{context-BBVLF7lx.d.cts → context-BuGH_Vft.d.cts}

@@ -8,6 +8,8 @@ import { Activity, Actor, Collection, CryptographicKey, Hashtag, Link, LookupObj
 import { AuthenticatedDocumentLoaderFactory, DocumentLoader, DocumentLoaderFactory, GetUserAgentOptions } from "@fedify/vocab-runtime";
 import { Link as Link$1, LookupWebFingerOptions, ResourceDescriptor } from "@fedify/webfinger";
 import { MeterProvider, Span, Tracer, TracerProvider } from "@opentelemetry/api";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
 //#region src/compat/types.d.ts
 /**
 * A function that transforms an activity object.
@@ -607,6 +609,201 @@ declare function respondWithObject(object: Object$1, options?: RespondWithObject
 */
 declare function respondWithObjectIfAcceptable(object: Object$1, request: Request, options?: RespondWithObjectOptions): Promise<Response | null>;
 //#endregion
+//#region src/federation/retry.d.ts
+/**
+* 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
+//#region src/federation/tasks/task.d.ts
+/**
+* A callback that processes a custom background task.
+* @template TContextData The context data to pass to the {@link Context}.
+* @template TData The type of the task payload, inferred from the task's
+*                 schema.
+* @param ctx The context for the worker processing the task.
+* @param data The decoded and validated task payload.
+* @since 2.x.x
+*/
+type TaskHandler<TContextData, TData> = (ctx: Context<TContextData>, data: TData) => Promise<void> | void;
+/**
+* Options for {@link TaskRegistry.defineTask}.
+* @template TContextData The context data to pass to the {@link Context}.
+* @template TSchema The [Standard Schema](https://standardschema.dev/) that
+*                   validates the task payload.
+* @since 2.x.x
+*/
+interface TaskDefinitionOptions<TContextData, TSchema extends StandardSchemaV1> {
+  /**
+  * The [Standard Schema](https://standardschema.dev/) that validates the
+  * task payload.  The payload type is inferred from this schema.
+  *
+  * The payload is validated twice: once at enqueue time (fail fast) and
+  * once at dequeue time (drift protection against payloads enqueued by an
+  * older deployment).  Because the same schema runs on both sides, its
+  * validation must be idempotent: the validated output must itself be
+  * a valid input.  Transforming schemas (e.g., Zod's `.transform()`) whose
+  * output differs in shape from their input are not supported.
+  */
+  readonly schema: TSchema;
+  /**
+  * The callback that processes the task on a background worker.
+  */
+  readonly handler: TaskHandler<TContextData, StandardSchemaV1.InferOutput<TSchema>>;
+  /**
+  * The retry policy for this task.  If omitted, the federation-wide
+  * task retry policy is used, which defaults to an exponential backoff
+  * policy.
+  */
+  readonly retryPolicy?: RetryPolicy;
+  /**
+  * A callback invoked when the {@link handler} throws an error, before
+  * a retry is scheduled.
+  * @param ctx The context for the worker processing the task.
+  * @param error The error thrown by the handler.
+  * @param data The decoded and validated task payload.
+  */
+  readonly onError?: (ctx: Context<TContextData>, error: unknown, data: StandardSchemaV1.InferOutput<TSchema>) => Promise<void> | void;
+  /**
+  * The message queue dedicated to this task.  If omitted, the task is
+  * routed to the federation-wide task queue, falling back to the outbox
+  * queue (unless `taskQueueResolution: "strict"` is configured).
+  */
+  readonly queue?: MessageQueue;
+}
+/**
+* Phantom key binding a {@link TaskDefinition} to its federation's context
+* data type.  Declared only—no value exists at runtime, and the symbol is
+* not exported, so the marker stays out of user-facing completions.
+*/
+declare const contextDataBrand: unique symbol;
+/**
+* The handle returned by {@link TaskRegistry.defineTask}.  It carries the
+* task name and schema so that {@link Context.enqueueTask} can validate the
+* payload and infer its type at every call site.
+* @template TContextData The context data to pass to the {@link Context}.
+* @template TData The type of the task payload, inferred from the task's
+*                 schema.
+* @since 2.x.x
+*/
+interface TaskDefinition<TContextData, TData> {
+  /**
+  * The unique name of the task.
+  */
+  readonly name: string;
+  /**
+  * The [Standard Schema](https://standardschema.dev/) that validates the
+  * task payload.
+  */
+  readonly schema: StandardSchemaV1<unknown, TData>;
+  /**
+  * @internal Phantom marker binding the handle to its federation.
+  */
+  readonly [contextDataBrand]?: TContextData;
+}
+/**
+* Registration of custom background tasks.  Both {@link Federation} and
+* {@link FederationBuilder} implement this interface.
+* @template TContextData The context data to pass to the {@link Context}.
+* @since 2.x.x
+*/
+interface TaskRegistry<TContextData> {
+  /**
+  * Defines a custom background task.  The returned handle is passed to
+  * {@link Context.enqueueTask} to enqueue the task.
+  *
+  * @example
+  * ``` typescript
+  * const sendDigest = federation.defineTask("sendDigest", {
+  *   schema: digestSchema,
+  *   handler: async (ctx, data) => {
+  *     // …process the payload on a background worker…
+  *   },
+  * });
+  * ```
+  *
+  * @param name The unique name of the task.
+  * @param options The task definition options.  The payload type is
+  *                inferred from `options.schema`.
+  * @returns The handle to pass to {@link Context.enqueueTask}.
+  * @throws {TypeError} If a task with the same name is already defined.
+  */
+  defineTask<TSchema extends StandardSchemaV1>(name: string, options: TaskDefinitionOptions<TContextData, TSchema>): TaskDefinition<TContextData, StandardSchemaV1.InferOutput<TSchema>>;
+}
+/**
+* Options for {@link Context.enqueueTask} and {@link Context.enqueueTaskMany}.
+* @since 2.x.x
+*/
+interface TaskEnqueueOptions {
+  /**
+  * The delay before the task is processed.  No delay by default.
+  */
+  readonly delay?: Temporal.DurationLike;
+  /**
+  * An optional key that ensures tasks with the same ordering key are
+  * processed sequentially (one at a time).
+  */
+  readonly orderingKey?: string;
+}
+//#endregion
 //#region src/federation/builder.d.ts
 /**
 * Creates a new {@link FederationBuilder} instance.
@@ -629,7 +826,7 @@ interface SenderKeyJwkPair {
 * type.
 * @since 1.6.0
 */
-type Message = FanoutMessage | OutboxMessage | InboxMessage;
+type Message = FanoutMessage | OutboxMessage | InboxMessage | TaskMessage;
 interface FanoutMessage {
   readonly type: "fanout";
   readonly id: ReturnType<typeof crypto.randomUUID>;
@@ -683,6 +880,24 @@ interface OutboxMessage {
   readonly circuitHeldSince?: string;
   readonly traceContext: Readonly<Record<string, string>>;
 }
+/**
+* A message that carries a custom background task.  Every field is
+* a string, number, or plain record so that the message survives both
+* JSON serialization and structured clone on every queue backend.
+* @since 2.x.x
+*/
+interface TaskMessage {
+  readonly type: "task";
+  readonly id: ReturnType<typeof crypto.randomUUID>;
+  readonly baseUrl: string;
+  readonly taskName: string;
+  /** devalue-encoded task data; vocab objects bridged to expanded JSON-LD. */
+  readonly data: string;
+  readonly started: string;
+  readonly attempt: number;
+  readonly orderingKey?: string;
+  readonly traceContext: Readonly<Record<string, string>>;
+}
 interface InboxMessage {
   readonly type: "inbox";
   readonly id: ReturnType<typeof crypto.randomUUID>;
@@ -730,70 +945,6 @@ interface InboxMessage {
   readonly traceContext: Readonly<Record<string, string>>;
 }
 //#endregion
-//#region src/federation/retry.d.ts
-/**
-* 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
 //#region src/federation/middleware.d.ts
 /**
 * Configures the task queues for sending and receiving activities.
@@ -817,6 +968,13 @@ interface FederationQueueOptions {
   * {@link Context.sendActivity} calls.
   */
   readonly fanout?: MessageQueue;
+  /**
+  * The message queue for custom background tasks.  If not provided,
+  * tasks are routed to the outbox queue (unless
+  * {@link FederationOptions.taskQueueResolution} is `"strict"`).
+  * @since 2.x.x
+  */
+  readonly task?: MessageQueue;
 }
 /**
 * Prefixes for namespacing keys in the Deno KV store.
@@ -901,18 +1059,18 @@ interface FederationStartQueueOptions {
   signal?: AbortSignal;
   /**
   * Starts the task worker only for the specified queue.  If unspecified,
-  * which is the default, the task worker starts for all three queues:
-  * inbox, outbox, and fanout.
+  * which is the default, the task worker starts for all four queues:
+  * inbox, outbox, fanout, and task.
   * @since 1.3.0
   */
-  queue?: "inbox" | "outbox" | "fanout";
+  queue?: "inbox" | "outbox" | "fanout" | "task";
 }
 /**
 * A common interface between {@link Federation} and {@link FederationBuilder}.
 * @template TContextData The context data to pass to the {@link Context}.
 * @since 1.6.0
 */
-interface Federatable<TContextData> {
+interface Federatable<TContextData> extends TaskRegistry<TContextData> {
   /**
   * Registers a NodeInfo dispatcher.
   * @param path The URI path pattern for the NodeInfo dispatcher.  The syntax
@@ -1619,6 +1777,26 @@ interface FederationOptions<TContextData> {
   */
   inboxRetryPolicy?: RetryPolicy;
   /**
+  * The retry policy for processing custom background tasks.  By default,
+  * this uses an exponential backoff strategy with a maximum of 10 attempts
+  * and a maximum delay of 12 hours.  A per-task retry policy
+  * ({@link TaskDefinitionOptions.retryPolicy}) overrides this.
+  * @since 2.x.x
+  */
+  taskRetryPolicy?: RetryPolicy;
+  /**
+  * How a queue is resolved for a custom background task when neither
+  * a per-task queue ({@link TaskDefinitionOptions.queue}) nor a dedicated
+  * task queue ({@link FederationQueueOptions.task}) is configured.
+  *
+  * - `"fallback"` (the default): the task is routed to the outbox queue.
+  * - `"strict"`: no fallback; enqueuing the task throws instead of
+  *   silently sharing the outbox queue.
+  * @default `"fallback"`
+  * @since 2.x.x
+  */
+  taskQueueResolution?: "fallback" | "strict";
+  /**
   * Activity transformers that are applied to outgoing activities.  It is
   * useful for adjusting outgoing activities to satisfy some ActivityPub
   * implementations.
@@ -2371,6 +2549,44 @@ interface Context<TContextData> {
   */
   routeActivity(recipient: string | null, activity: Activity, options?: RouteActivityOptions): Promise<boolean>;
   /**
+  * Enqueues a custom background task.  The payload is validated against
+  * the task's schema, serialized, and processed by the task's handler on
+  * a background worker.
+  *
+  * @example
+  * ``` typescript
+  * await ctx.enqueueTask(sendDigest, { userId: "alice" });
+  * ```
+  *
+  * @template TData The type of the task payload, inferred from the task's
+  *                 schema.
+  * @param task The handle returned by {@link TaskRegistry.defineTask}.
+  * @param data The task payload.  It is validated against the task's
+  *             schema before being enqueued.
+  * @param options Options for enqueuing the task.
+  * @throws {TypeError} If the task is not defined on this federation,
+  *                     if no message queue is configured for tasks, or if
+  *                     the payload fails schema validation.
+  * @since 2.x.x
+  */
+  enqueueTask<TData>(task: TaskDefinition<TContextData, TData>, data: TData, options?: TaskEnqueueOptions): Promise<void>;
+  /**
+  * Enqueues multiple payloads for a custom background task at once.
+  * Uses the queue's bulk enqueue operation when available, falling back
+  * to parallel single enqueues.
+  * @template TData The type of the task payload, inferred from the task's
+  *                 schema.
+  * @param task The handle returned by {@link TaskRegistry.defineTask}.
+  * @param payloads The task payloads.  Each is validated against the
+  *                 task's schema before being enqueued.
+  * @param options Options for enqueuing the tasks.
+  * @throws {TypeError} If the task is not defined on this federation,
+  *                     if no message queue is configured for tasks, or if
+  *                     a payload fails schema validation.
+  * @since 2.x.x
+  */
+  enqueueTaskMany<TData>(task: TaskDefinition<TContextData, TData>, payloads: readonly TData[], options?: TaskEnqueueOptions): Promise<void>;
+  /**
   * Builds the URI of a collection of objects with the given name and values.
   * @param name The name of the collection, which can be a string or a symbol.
   * @param values The values of the URI parameters.
@@ -2881,4 +3097,4 @@ interface ActorKeyPair extends CryptoKeyPair {
   readonly multikey: Multikey;
 }
 //#endregion
-export { CustomCollectionCursor as $, Rfc6570Expression as A, parseCircuitBreakerKvState as At, createFederationBuilder as B, FederationStartQueueOptions as C, CircuitBreakerFailurePolicy as Ct, InboxListenerSetters as D, CircuitBreakerStateChange as Dt, InboxChallengePolicy as E, CircuitBreakerState as Et, CreateExponentialBackoffPolicyOptions as F, ActorDispatcher as G, respondWithObject as H, RetryContext as I, AuthorizePredicate as J, ActorHandleMapper as K, RetryPolicy as L, FederationOrigin as M, FederationQueueOptions as N, ObjectCallbackSetters as O, NormalizedCircuitBreakerOptions as Ot, createFederation as P, CustomCollectionCounter as Q, createExponentialBackoffPolicy as R, FederationOptions as S, CircuitBreakerCreateOptions as St, IdempotencyStrategy as T, CircuitBreakerOptions as Tt, respondWithObjectIfAcceptable as U, RespondWithObjectOptions as V, ActorAliasMapper as W, CollectionCursor as X, CollectionCounter as Y, CollectionDispatcher as Z, Federatable as _, buildCollectionSynchronizationHeader as _t, GetSignedKeyOptions as a, ObjectDispatcher as at, FederationBuilder as b, CircuitBreakerActivityDrop as bt, ParseUriResult as c, OutboxListenerErrorHandler as ct, SendActivityOptions as d, UnverifiedActivityHandler as dt, CustomCollectionDispatcher as et, SendActivityOptionsForCollection as f, UnverifiedActivityReason as ft, CustomCollectionCallbackSetters as g, PageItems as gt, ConstructorWithTypeId as h, SenderKeyPair as ht, GetActorOptions as i, ObjectAuthorizePredicate as it, FederationKvPrefixes as j, ActivityTransformer as jt, OutboxListenerSetters as k, normalizeCircuitBreakerOptions as kt, RequestContext as l, OutboxPermanentFailureHandler as lt, CollectionCallbackSetters as m, SendActivityError as mt, Context as n, InboxListener as nt, InboxContext as o, OutboxErrorHandler as ot, ActorCallbackSetters as p, WebFingerLinksDispatcher as pt, ActorKeyPairsDispatcher as q, ForwardActivityOptions as r, NodeInfoDispatcher as rt, OutboxContext as s, OutboxListener as st, ActorKeyPair as t, InboxErrorHandler as tt, RouteActivityOptions as u, SharedInboxKeyDispatcher as ut, Federation as v, digest as vt, IdempotencyKeyCallback as w, CircuitBreakerKvState as wt, FederationFetchOptions as x, CircuitBreakerBeforeSendDecision as xt, FederationBenchmarkOptions as y, CircuitBreaker as yt, Message as z };
+export { AuthorizePredicate as $, Rfc6570Expression as A, CircuitBreakerOptions as At, TaskHandler as B, FederationStartQueueOptions as C, digest as Ct, InboxListenerSetters as D, CircuitBreakerCreateOptions as Dt, InboxChallengePolicy as E, CircuitBreakerBeforeSendDecision as Et, Message as F, parseCircuitBreakerKvState as Ft, createExponentialBackoffPolicy as G, CreateExponentialBackoffPolicyOptions as H, createFederationBuilder as I, ActivityTransformer as It, respondWithObjectIfAcceptable as J, RespondWithObjectOptions as K, TaskDefinition as L, FederationOrigin as M, CircuitBreakerStateChange as Mt, FederationQueueOptions as N, NormalizedCircuitBreakerOptions as Nt, ObjectCallbackSetters as O, CircuitBreakerFailurePolicy as Ot, createFederation as P, normalizeCircuitBreakerOptions as Pt, ActorKeyPairsDispatcher as Q, TaskDefinitionOptions as R, FederationOptions as S, buildCollectionSynchronizationHeader as St, IdempotencyStrategy as T, CircuitBreakerActivityDrop as Tt, RetryContext as U, TaskRegistry as V, RetryPolicy as W, ActorDispatcher as X, ActorAliasMapper as Y, ActorHandleMapper as Z, Federatable as _, UnverifiedActivityReason as _t, GetSignedKeyOptions as a, CustomCollectionDispatcher as at, FederationBuilder as b, SenderKeyPair as bt, ParseUriResult as c, NodeInfoDispatcher as ct, SendActivityOptions as d, OutboxErrorHandler as dt, CollectionCounter as et, SendActivityOptionsForCollection as f, OutboxListener as ft, CustomCollectionCallbackSetters as g, UnverifiedActivityHandler as gt, ConstructorWithTypeId as h, SharedInboxKeyDispatcher as ht, GetActorOptions as i, CustomCollectionCursor as it, FederationKvPrefixes as j, CircuitBreakerState as jt, OutboxListenerSetters as k, CircuitBreakerKvState as kt, RequestContext as l, ObjectAuthorizePredicate as lt, CollectionCallbackSetters as m, OutboxPermanentFailureHandler as mt, Context as n, CollectionDispatcher as nt, InboxContext as o, InboxErrorHandler as ot, ActorCallbackSetters as p, OutboxListenerErrorHandler as pt, respondWithObject as q, ForwardActivityOptions as r, CustomCollectionCounter as rt, OutboxContext as s, InboxListener as st, ActorKeyPair as t, CollectionCursor as tt, RouteActivityOptions as u, ObjectDispatcher as ut, Federation as v, WebFingerLinksDispatcher as vt, IdempotencyKeyCallback as w, CircuitBreaker as wt, FederationFetchOptions as x, PageItems as xt, FederationBenchmarkOptions as y, SendActivityError as yt, TaskEnqueueOptions as z };