@quave/agenda 1.0.0

package/dist/cjs/types/JobLogger.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=JobLogger.js.map

package/dist/cjs/types/JobLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JobLogger.js","sourceRoot":"","sources":["../../../src/types/JobLogger.ts"],"names":[],"mappings":""}

package/dist/cjs/types/JobParameters.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Branded type for job IDs.
+ * At runtime it's a string, but TypeScript treats it as a distinct type.
+ */
+export type JobId = string & {
+    readonly __brand: 'AgendaJobId';
+};
+/**
+ * Create a JobId from a string
+ */
+export declare function toJobId(id: string): JobId;
+/**
+ * Options for debouncing job execution.
+ * Debouncing delays job execution and resets the timer on subsequent saves,
+ * ensuring the job only runs once after a quiet period.
+ */
+export interface DebounceOptions {
+    /**
+     * Debounce window in milliseconds.
+     * The job will be scheduled to run this many ms after the last save.
+     */
+    delay: number;
+    /**
+     * Maximum time to wait before forcing execution (in milliseconds).
+     * If set, the job will execute within maxWait even if new saves keep coming.
+     * Without maxWait, continuous saves could delay execution indefinitely.
+     */
+    maxWait?: number;
+    /**
+     * Debounce strategy:
+     * - 'trailing' (default): Execute after quiet period ends (last call wins)
+     * - 'leading': Execute immediately on first call, ignore subsequent calls during window
+     */
+    strategy?: 'trailing' | 'leading';
+}
+/**
+ * Options for unique constraint behavior during job save.
+ */
+export interface UniqueOpts {
+    /**
+     * If true, only insert if no matching job exists.
+     * Existing jobs are returned unchanged.
+     */
+    insertOnly?: boolean;
+    /**
+     * Debounce options for combining rapid job saves.
+     * Requires a unique constraint to be set.
+     */
+    debounce?: DebounceOptions;
+}
+export interface JobParameters<DATA = unknown | void> {
+    /** Job ID */
+    _id?: JobId;
+    name: string;
+    priority: number;
+    nextRunAt: Date | null;
+    /**
+     * normal: job is queued and will be processed (regular case when the user adds a new job)
+     * single: job with this name is only queued once, if there is an existing entry in the database, the job is just updated, but not newly inserted (this is used for .every())
+     */
+    type: 'normal' | 'single';
+    lockedAt?: Date;
+    lastFinishedAt?: Date;
+    failedAt?: Date;
+    failCount?: number;
+    failReason?: string;
+    repeatTimezone?: string;
+    lastRunAt?: Date;
+    repeatInterval?: string | number;
+    data: DATA;
+    repeatAt?: string;
+    disabled?: boolean;
+    progress?: number;
+    /**
+     * Unique constraint query object.
+     * Keys are field paths (e.g., 'data.userId'), values are the expected values.
+     * The implementation interprets this for upsert operations.
+     */
+    unique?: Record<string, unknown>;
+    uniqueOpts?: UniqueOpts;
+    /**
+     * Tracks when debounce window started.
+     * Used internally for maxWait calculations.
+     */
+    debounceStartedAt?: Date;
+    lastModifiedBy?: string;
+    /** Forks a new node sub process for executing this job */
+    fork?: boolean;
+    /**
+     * The date when the job should start running.
+     * The job will not run before this date.
+     */
+    startDate?: Date;
+    /**
+     * The date when the job should stop running.
+     * The job will not run after this date (nextRunAt will be set to null).
+     */
+    endDate?: Date;
+    /**
+     * Days of the week to skip (0 = Sunday, 1 = Monday, ..., 6 = Saturday).
+     * The job will not run on these days.
+     */
+    skipDays?: number[];
+}
+export type TJobDatefield = keyof Pick<JobParameters, 'lastRunAt' | 'lastFinishedAt' | 'nextRunAt' | 'failedAt' | 'lockedAt' | 'startDate' | 'endDate' | 'debounceStartedAt'>;
+export declare const datefields: Array<TJobDatefield>;

package/dist/cjs/types/JobParameters.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datefields = void 0;
+exports.toJobId = toJobId;
+/**
+ * Create a JobId from a string
+ */
+function toJobId(id) {
+    return id;
+}
+exports.datefields = [
+    'lastRunAt',
+    'lastFinishedAt',
+    'nextRunAt',
+    'failedAt',
+    'lockedAt',
+    'startDate',
+    'endDate',
+    'debounceStartedAt'
+];
+//# sourceMappingURL=JobParameters.js.map

package/dist/cjs/types/JobParameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JobParameters.js","sourceRoot":"","sources":["../../../src/types/JobParameters.ts"],"names":[],"mappings":";;;AASA,0BAEC;AALD;;GAEG;AACH,SAAgB,OAAO,CAAC,EAAU;IACjC,OAAO,EAAW,CAAC;AACpB,CAAC;AAmHY,QAAA,UAAU,GAAyB;IAC/C,WAAW;IACX,gBAAgB;IAChB,WAAW;IACX,UAAU;IACV,UAAU;IACV,WAAW;IACX,SAAS;IACT,mBAAmB;CACnB,CAAC"}

package/dist/cjs/types/JobQuery.d.ts

@@ -0,0 +1,79 @@
+import type { JobParameters, JobId } from './JobParameters.js';
+import type { SortDirection } from './DbOptions.js';
+/**
+ * Computed job states based on job timestamps.
+ * These are derived from job data, not stored in the database.
+ * 'paused' is based on the disabled field rather than timestamps.
+ */
+export type JobState = 'running' | 'scheduled' | 'queued' | 'completed' | 'failed' | 'repeating' | 'paused';
+/**
+ * Overview statistics for a single job name
+ */
+export interface JobsOverview {
+    name: string;
+    total: number;
+    running: number;
+    scheduled: number;
+    queued: number;
+    completed: number;
+    failed: number;
+    repeating: number;
+    paused: number;
+}
+/**
+ * Job with computed state
+ */
+export interface JobWithState<DATA = unknown> extends JobParameters<DATA> {
+    _id: JobId;
+    state: JobState;
+}
+/**
+ * Sort options for job queries (database-agnostic)
+ */
+export interface JobsSort {
+    nextRunAt?: SortDirection;
+    lastRunAt?: SortDirection;
+    lastFinishedAt?: SortDirection;
+    priority?: SortDirection;
+    name?: SortDirection;
+    data?: SortDirection;
+}
+/**
+ * Database-agnostic query options for jobs
+ */
+export interface JobsQueryOptions {
+    /** Filter by job name */
+    name?: string;
+    /** Filter by job names (multiple) */
+    names?: string[];
+    /** Filter by computed state */
+    state?: JobState;
+    /** Filter by job ID */
+    id?: string;
+    /** Filter by job IDs (multiple) */
+    ids?: string[];
+    /** Text to search in job name */
+    search?: string;
+    /** Filter by job data (exact match or partial object match) */
+    data?: unknown;
+    /** Include disabled jobs (default: true) */
+    includeDisabled?: boolean;
+    /** Sort order */
+    sort?: JobsSort;
+    /** Number of jobs to skip (pagination) */
+    skip?: number;
+    /** Maximum number of jobs to return */
+    limit?: number;
+}
+/**
+ * Result of jobs query with state computation
+ */
+export interface JobsResult<DATA = unknown> {
+    jobs: JobWithState<DATA>[];
+    /** Total count (before pagination, after state filter) */
+    total: number;
+}
+/**
+ * Compute the state for a job based on its timestamps
+ */
+export declare function computeJobState(job: JobParameters, now?: Date): JobState;

package/dist/cjs/types/JobQuery.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeJobState = computeJobState;
+/**
+ * Compute the state for a job based on its timestamps
+ */
+function computeJobState(job, now = new Date()) {
+    const { lockedAt, lastFinishedAt, failedAt, nextRunAt, repeatInterval } = job;
+    // Running: currently locked and processing
+    if (lockedAt) {
+        return 'running';
+    }
+    // Failed: has failed and failure is at least as recent as completion
+    if (failedAt && (!lastFinishedAt || failedAt >= lastFinishedAt)) {
+        return 'failed';
+    }
+    // Repeating: has repeat interval and hasn't failed
+    if (repeatInterval) {
+        return 'repeating';
+    }
+    // Scheduled: next run is in the future
+    if (nextRunAt && nextRunAt > now) {
+        return 'scheduled';
+    }
+    // Queued: next run is now or past (ready to run)
+    if (nextRunAt && nextRunAt <= now) {
+        return 'queued';
+    }
+    // Completed: has finished and either no failure or completion is strictly more recent
+    if (lastFinishedAt && (!failedAt || lastFinishedAt > failedAt)) {
+        return 'completed';
+    }
+    // Default to completed if nothing else matches
+    return 'completed';
+}
+//# sourceMappingURL=JobQuery.js.map

package/dist/cjs/types/JobQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JobQuery.js","sourceRoot":"","sources":["../../../src/types/JobQuery.ts"],"names":[],"mappings":";;AAqFA,0CAmCC;AAtCD;;GAEG;AACH,SAAgB,eAAe,CAAC,GAAkB,EAAE,MAAY,IAAI,IAAI,EAAE;IACzE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,GAAG,GAAG,CAAC;IAE9E,2CAA2C;IAC3C,IAAI,QAAQ,EAAE,CAAC;QACd,OAAO,SAAS,CAAC;IAClB,CAAC;IAED,qEAAqE;IACrE,IAAI,QAAQ,IAAI,CAAC,CAAC,cAAc,IAAI,QAAQ,IAAI,cAAc,CAAC,EAAE,CAAC;QACjE,OAAO,QAAQ,CAAC;IACjB,CAAC;IAED,mDAAmD;IACnD,IAAI,cAAc,EAAE,CAAC;QACpB,OAAO,WAAW,CAAC;IACpB,CAAC;IAED,uCAAuC;IACvC,IAAI,SAAS,IAAI,SAAS,GAAG,GAAG,EAAE,CAAC;QAClC,OAAO,WAAW,CAAC;IACpB,CAAC;IAED,iDAAiD;IACjD,IAAI,SAAS,IAAI,SAAS,IAAI,GAAG,EAAE,CAAC;QACnC,OAAO,QAAQ,CAAC;IACjB,CAAC;IAED,sFAAsF;IACtF,IAAI,cAAc,IAAI,CAAC,CAAC,QAAQ,IAAI,cAAc,GAAG,QAAQ,CAAC,EAAE,CAAC;QAChE,OAAO,WAAW,CAAC;IACpB,CAAC;IAED,+CAA+C;IAC/C,OAAO,WAAW,CAAC;AACpB,CAAC"}

package/dist/cjs/types/JobRepository.d.ts

@@ -0,0 +1,101 @@
+import type { JobParameters, JobId } from './JobParameters.js';
+import type { JobsQueryOptions, JobsResult, JobsOverview } from './JobQuery.js';
+/**
+ * Options passed to repository methods that modify jobs
+ */
+export interface JobRepositoryOptions {
+    /** Name to set as lastModifiedBy on the job */
+    lastModifiedBy?: string;
+}
+/**
+ * Options for removing jobs (database-agnostic)
+ */
+export interface RemoveJobsOptions {
+    /** Remove job by ID */
+    id?: JobId | string;
+    /** Remove jobs by IDs */
+    ids?: (JobId | string)[];
+    /** Remove jobs by name */
+    name?: string;
+    /** Remove jobs by names (include) */
+    names?: string[];
+    /** Remove jobs NOT matching these names (exclude) */
+    notNames?: string[];
+    /** Remove jobs matching data */
+    data?: unknown;
+}
+/**
+ * Database-agnostic job repository interface.
+ * Implementations can be created for MongoDB, PostgreSQL, etc.
+ */
+export interface JobRepository {
+    /**
+     * Connect to the database
+     */
+    connect(): Promise<void>;
+    /**
+     * Query jobs with filtering, pagination, and state computation
+     */
+    queryJobs(options?: JobsQueryOptions): Promise<JobsResult>;
+    /**
+     * Get overview statistics for all job types
+     */
+    getJobsOverview(): Promise<JobsOverview[]>;
+    /**
+     * Get all distinct job names
+     */
+    getDistinctJobNames(): Promise<string[]>;
+    /**
+     * Get a single job by ID
+     */
+    getJobById(id: string): Promise<JobParameters | null>;
+    /**
+     * Get count of jobs ready to run (nextRunAt < now)
+     */
+    getQueueSize(): Promise<number>;
+    /**
+     * Remove jobs matching the given options
+     * @returns Number of jobs removed
+     */
+    removeJobs(options: RemoveJobsOptions): Promise<number>;
+    /**
+     * Save a job (insert or update)
+     */
+    saveJob<DATA = unknown>(job: JobParameters<DATA>, options: JobRepositoryOptions | undefined): Promise<JobParameters<DATA>>;
+    /**
+     * Update job state fields (lockedAt, lastRunAt, progress, etc.)
+     */
+    saveJobState(job: JobParameters, options: JobRepositoryOptions | undefined): Promise<void>;
+    /**
+     * Attempt to lock a job for processing
+     * @returns The locked job data, or undefined if lock failed
+     */
+    lockJob(job: JobParameters, options: JobRepositoryOptions | undefined): Promise<JobParameters | undefined>;
+    /**
+     * Unlock a single job
+     */
+    unlockJob(job: JobParameters): Promise<void>;
+    /**
+     * Unlock multiple jobs by ID
+     */
+    unlockJobs(jobIds: (JobId | string)[]): Promise<void>;
+    /**
+     * Find and lock the next job to run for a given job type
+     */
+    getNextJobToRun(jobName: string, nextScanAt: Date, lockDeadline: Date, now: Date | undefined, options: JobRepositoryOptions | undefined): Promise<JobParameters | undefined>;
+    /**
+     * Disable jobs matching the given options
+     * @returns Number of jobs disabled
+     */
+    disableJobs(options: RemoveJobsOptions): Promise<number>;
+    /**
+     * Enable jobs matching the given options
+     * @returns Number of jobs enabled
+     */
+    enableJobs(options: RemoveJobsOptions): Promise<number>;
+    /**
+     * Remove ALL jobs from the database unconditionally.
+     * @returns Number of jobs removed
+     */
+    purgeAllJobs(): Promise<number>;
+}

package/dist/cjs/types/JobRepository.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=JobRepository.js.map

package/dist/cjs/types/JobRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JobRepository.js","sourceRoot":"","sources":["../../../src/types/JobRepository.ts"],"names":[],"mappings":""}

package/dist/cjs/types/NotificationChannel.d.ts

@@ -0,0 +1,120 @@
+import type { JobId } from './JobParameters.js';
+/**
+ * Notification payload sent when a job is saved/updated
+ */
+export interface JobNotification {
+    jobId: JobId;
+    jobName: string;
+    nextRunAt: Date | null;
+    priority: number;
+    timestamp: Date;
+    source?: string;
+}
+/**
+ * Types of job state events that can be published
+ */
+export type JobStateType = 'start' | 'progress' | 'success' | 'fail' | 'complete' | 'retry';
+/**
+ * Notification payload sent when a job's state changes during execution.
+ * This enables bi-directional communication so that all subscribers
+ * can receive job lifecycle events (start, success, fail, complete, etc.)
+ */
+export interface JobStateNotification {
+    type: JobStateType;
+    jobId: JobId;
+    jobName: string;
+    timestamp: Date;
+    source?: string;
+    /** Progress percentage (0-100) for 'progress' events */
+    progress?: number;
+    /** Error message for 'fail' events */
+    error?: string;
+    /** Failure count for 'fail' events */
+    failCount?: number;
+    /** Scheduled retry time for 'retry' events */
+    retryAt?: Date;
+    /** Retry attempt number for 'retry' events */
+    retryAttempt?: number;
+    /** Job execution duration in ms for 'complete' events */
+    duration?: number;
+    /** When the job started for 'complete' events */
+    lastRunAt?: Date;
+    /** When the job finished for 'complete' events */
+    lastFinishedAt?: Date;
+}
+/**
+ * Handler function for processing job state notifications
+ */
+export type StateNotificationHandler = (notification: JobStateNotification) => void | Promise<void>;
+/**
+ * Handler function for processing job notifications
+ */
+export type NotificationHandler = (notification: JobNotification) => void | Promise<void>;
+/**
+ * Possible states of a notification channel
+ */
+export type NotificationChannelState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+/**
+ * Configuration options for notification channels
+ */
+export interface NotificationChannelConfig {
+    channelName?: string;
+    reconnect?: {
+        enabled: boolean;
+        maxAttempts?: number;
+        initialDelayMs?: number;
+        maxDelayMs?: number;
+    };
+}
+/**
+ * Interface for notification channels that enable cross-process job notifications.
+ * Implementations can use Redis, PostgreSQL LISTEN/NOTIFY, or other pub/sub systems.
+ */
+export interface NotificationChannel {
+    /**
+     * Current state of the channel
+     */
+    readonly state: NotificationChannelState;
+    /**
+     * Connect to the notification backend
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the notification backend
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Subscribe to job notifications
+     * @param handler - Function to call when a notification is received
+     * @returns Unsubscribe function
+     */
+    subscribe(handler: NotificationHandler): () => void;
+    /**
+     * Publish a job notification
+     * @param notification - The notification to publish
+     */
+    publish(notification: JobNotification): Promise<void>;
+    /**
+     * Register an event listener
+     */
+    on(event: 'stateChange', listener: (state: NotificationChannelState) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    /**
+     * Remove an event listener
+     */
+    off(event: 'stateChange', listener: (state: NotificationChannelState) => void): this;
+    off(event: 'error', listener: (error: Error) => void): this;
+    /**
+     * Publish a job state notification (bi-directional communication).
+     * Optional - only implement if the channel supports state notifications.
+     * @param notification - The state notification to publish
+     */
+    publishState?(notification: JobStateNotification): Promise<void>;
+    /**
+     * Subscribe to job state notifications (bi-directional communication).
+     * Optional - only implement if the channel supports state notifications.
+     * @param handler - Function to call when a state notification is received
+     * @returns Unsubscribe function
+     */
+    subscribeState?(handler: StateNotificationHandler): () => void;
+}

package/dist/cjs/types/NotificationChannel.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=NotificationChannel.js.map

package/dist/cjs/types/NotificationChannel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotificationChannel.js","sourceRoot":"","sources":["../../../src/types/NotificationChannel.ts"],"names":[],"mappings":""}

package/dist/cjs/utils/backoff.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Backoff strategy utilities for job retry logic
+ */
+/**
+ * Context passed to backoff strategy functions
+ */
+export interface BackoffContext {
+    /** Current attempt number (1-based, so first retry is attempt 1) */
+    attempt: number;
+    /** The error that caused the failure */
+    error: Error;
+    /** Job name */
+    jobName: string;
+    /** Job data */
+    jobData: unknown;
+}
+/**
+ * A backoff strategy is a function that returns the delay in milliseconds
+ * before the next retry attempt, or `null` to stop retrying.
+ */
+export type BackoffStrategy = (context: BackoffContext) => number | null;
+/**
+ * Options for built-in backoff strategies
+ */
+export interface BackoffOptions {
+    /** Initial delay in milliseconds (default: 1000) */
+    delay?: number;
+    /** Maximum delay in milliseconds (default: Infinity) */
+    maxDelay?: number;
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Add randomness to prevent thundering herd (default: 0, range: 0-1) */
+    jitter?: number;
+}
+/**
+ * Options specific to exponential backoff
+ */
+export interface ExponentialBackoffOptions extends BackoffOptions {
+    /** Multiplier for each attempt (default: 2) */
+    factor?: number;
+}
+/**
+ * Options specific to linear backoff
+ */
+export interface LinearBackoffOptions extends BackoffOptions {
+    /** Amount to increase delay by each attempt (default: same as delay) */
+    increment?: number;
+}
+/**
+ * Constant backoff - same delay between each retry
+ *
+ * @example
+ * ```ts
+ * agenda.define('myJob', handler, {
+ *   backoff: constant({ delay: 5000, maxRetries: 5 })
+ * });
+ * // Retries at: 5s, 5s, 5s, 5s, 5s
+ * ```
+ */
+export declare function constant(options?: BackoffOptions): BackoffStrategy;
+/**
+ * Linear backoff - delay increases by a fixed amount each retry
+ *
+ * @example
+ * ```ts
+ * agenda.define('myJob', handler, {
+ *   backoff: linear({ delay: 1000, increment: 2000, maxRetries: 4 })
+ * });
+ * // Retries at: 1s, 3s, 5s, 7s
+ * ```
+ */
+export declare function linear(options?: LinearBackoffOptions): BackoffStrategy;
+/**
+ * Exponential backoff - delay multiplies by a factor each retry
+ *
+ * @example
+ * ```ts
+ * agenda.define('myJob', handler, {
+ *   backoff: exponential({ delay: 1000, factor: 2, maxRetries: 5 })
+ * });
+ * // Retries at: 1s, 2s, 4s, 8s, 16s
+ *
+ * // With jitter to prevent thundering herd:
+ * agenda.define('myJob', handler, {
+ *   backoff: exponential({ delay: 1000, factor: 2, maxRetries: 5, jitter: 0.2 })
+ * });
+ * ```
+ */
+export declare function exponential(options?: ExponentialBackoffOptions): BackoffStrategy;
+/**
+ * Combine multiple strategies - tries each in sequence until one returns non-null
+ * Useful for implementing complex retry logic
+ *
+ * @example
+ * ```ts
+ * // Retry quickly at first, then back off
+ * agenda.define('myJob', handler, {
+ *   backoff: combine(
+ *     // First 2 retries: immediate (100ms)
+ *     (ctx) => ctx.attempt <= 2 ? 100 : null,
+ *     // Then exponential backoff for 3 more attempts
+ *     exponential({ delay: 1000, maxRetries: 3 })
+ *   )
+ * });
+ * ```
+ */
+export declare function combine(...strategies: BackoffStrategy[]): BackoffStrategy;
+/**
+ * Conditional backoff - only retry if condition is met
+ *
+ * @example
+ * ```ts
+ * // Only retry on specific errors
+ * agenda.define('myJob', handler, {
+ *   backoff: when(
+ *     (ctx) => ctx.error.message.includes('timeout'),
+ *     exponential({ delay: 1000, maxRetries: 3 })
+ *   )
+ * });
+ * ```
+ */
+export declare function when(condition: (context: BackoffContext) => boolean, strategy: BackoffStrategy): BackoffStrategy;
+/**
+ * Pre-configured backoff strategies for common use cases
+ */
+export declare const backoffStrategies: {
+    /** Constant 1s delay, 3 retries */
+    constant: typeof constant;
+    /** Linear increase starting at 1s, 3 retries */
+    linear: typeof linear;
+    /** Exponential with factor 2, starting at 1s, 3 retries */
+    exponential: typeof exponential;
+    /** Combine multiple strategies */
+    combine: typeof combine;
+    /** Conditional retry */
+    when: typeof when;
+    /**
+     * Aggressive retry - quick retries for transient failures
+     * 100ms, 200ms, 400ms (3 retries in ~700ms total)
+     */
+    aggressive: () => BackoffStrategy;
+    /**
+     * Relaxed retry - gentle backoff for rate-limited APIs
+     * 5s, 15s, 45s, 135s (4 retries over ~3 minutes)
+     */
+    relaxed: () => BackoffStrategy;
+    /**
+     * Standard retry - balanced approach
+     * 1s, 2s, 4s, 8s, 16s (5 retries over ~31 seconds)
+     */
+    standard: () => BackoffStrategy;
+};