@tstdl/base 0.93.141 → 0.93.142

package/task-queue/task-queue.d.ts

@@ -1,4 +1,5 @@
-import type { CancellationSignal } from '../cancellation/token.js';
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
+import type { CancellationSignal } from '../cancellation/index.js';
 import { type EnumType } from '../enumeration/enumeration.js';
 import { Injector } from '../injector/index.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
@@ -8,14 +9,38 @@ import { Transactional } from '../orm/server/transactional.js';
 import type { OneOrMany, Record, UndefinableJson } from '../types/types.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
 import type { ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TasksResults, TasksStates, TaskState, TaskTypes } from './types.js';
+/**
+ * Represents the result of processing a task.
+ * @template Result The type of the result data.
+ */
 export declare class TaskProcessResult<Result = unknown> {
     readonly payload: TaskProcessResultPayload<Result>;
     private constructor();
+    /**
+     * Creates a successful process result.
+     * @param result The optional result data.
+     */
     static Complete<Result>(result?: Result): TaskProcessResult<Result>;
+    /**
+     * Creates a failed process result.
+     * @param error The error that occurred.
+     * @param fatal Whether the error is fatal and the task should not be retried.
+     */
     static Fail<R>(error: unknown, fatal?: boolean): TaskProcessResult<R>;
+    /**
+     * Creates a result that reschedules the task to a specific timestamp.
+     * @param timestamp The timestamp to reschedule to.
+     */
     static RescheduleTo<R>(timestamp: number): TaskProcessResult<R>;
+    /**
+     * Creates a result that reschedules the task by a specific number of milliseconds.
+     * @param milliseconds The number of milliseconds to reschedule by.
+     */
     static RescheduleBy<R>(milliseconds: number): TaskProcessResult<R>;
 }
+/**
+ * Represents the status of a task in the queue.
+ */
 export declare const TaskStatus: {
     /**
      * The task is ready to be processed and is waiting for a worker.
@@ -49,40 +74,103 @@ export declare const TaskStatus: {
      * The task has been manually paused and will not be dequeued until resumed.
      */
     readonly Paused: "paused";
+    /**
+     * The task has failed but has remaining attempts and is waiting for its next scheduled attempt.
+     */
+    readonly Retrying: "retrying";
+    /**
+     * The task was forcefully terminated because its execution time exceeded maxExecutionTime.
+     */
+    readonly TimedOut: "timed-out";
+    /**
+     * The task expired in the queue before it could be picked up by a worker.
+     */
+    readonly Expired: "expired";
+    /**
+     * The task was never attempted because one of its prerequisites failed or was cancelled.
+     */
+    readonly Skipped: "skipped";
+    /**
+     * The task was abandoned by a worker and has exhausted all retry attempts.
+     */
+    readonly Orphaned: "orphaned";
 };
+/**
+ * Type of task status.
+ */
 export type TaskStatus = EnumType<typeof TaskStatus>;
+/**
+ * Represents the type of dependency between tasks.
+ */
 export declare const TaskDependencyType: {
+    /**
+     * The task should only be scheduled after the dependency has reached a specific status.
+     */
     readonly Schedule: "schedule";
+    /**
+     * The task is only considered complete after the dependency has reached a specific status.
+     */
     readonly Complete: "complete";
+    /**
+     * The task is only considered complete after the child task has reached a specific status.
+     */
+    readonly Child: "child";
 };
+/**
+ * Type of task dependency.
+ */
 export type TaskDependencyType = EnumType<typeof TaskDependencyType>;
+/**
+ * Represents a task in the queue.
+ * @template Definitions The type map of task definitions.
+ */
 export type Task<Definitions extends TaskDefinitionMap = Record<string, {
     data: unknown;
     state: unknown;
     result: unknown;
 }>> = {
     [Type in TaskTypes<Definitions>]: {
+        /** The unique ID of the task. */
         id: string;
+        /** The namespace the task belongs to. */
         namespace: string;
+        /** The type of the task. */
         type: Type;
+        /** The current status of the task. */
         status: TaskStatus;
+        /**
+         * The unique token assigned to the worker processing the task.
+         * Null if the task is not currently being processed.
+         */
         token: string | null;
         /**
          * The lower the number, the higher the priority.
          * @default 1000
          */
         priority: number;
+        /** An optional key used for idempotency. */
         idempotencyKey: string | null;
+        /** An optional trace ID for distributed tracing. */
         traceId: string | null;
+        /** Tags associated with the task. */
         tags: string[];
+        /** The number of unresolved schedule dependencies. */
         unresolvedScheduleDependencies: number;
+        /** The number of unresolved completion dependencies. */
         unresolvedCompleteDependencies: number;
+        /** Whether to skip the task if any of its dependencies fail. */
         failFast: boolean;
+        /** The data associated with the task. */
         data: TaskData<Definitions, Type>;
+        /** The ID of the parent task, if any. */
         parentId: string | null;
+        /** The number of times the task has been attempted. */
         tries: number;
+        /** The timestamp when the task was created. */
         creationTimestamp: number;
+        /** The timestamp when the task's priority was last aged. */
         priorityAgeTimestamp: number;
+        /** The timestamp when the task is scheduled to be processed. */
         scheduleTimestamp: number;
         /**
          * Timestamp when the task most recently switched to Running state.
@@ -98,48 +186,95 @@ export type Task<Definitions extends TaskDefinitionMap = Record<string, {
          * Token expiration (Soft Timeout).
          */
         visibilityDeadline: number | null;
+        /** The timestamp when the task was completed. */
         completeTimestamp: number | null;
         /** A number between 0 and 1 indicating the progress of the task. */
         progress: number;
         /** A snapshot of the current state of the task. */
         state: TaskState<Definitions, Type> | null;
+        /** The result of the task, if successful. */
         result: TaskResult<Definitions, Type> | null;
+        /** The error that occurred, if the task failed. */
         error: UndefinableJson | null;
     };
 }[Extract<keyof Definitions, string>];
+/** Default priority for tasks. */
 export declare const defaultTaskPriority = 1000;
+/**
+ * Represents a task dependency specification.
+ * Can be:
+ * - A string: The ID of the task.
+ * - A number: The index of the task in the current batch.
+ * - An object: Providing ID or index, and optional namespace and required statuses.
+ */
+export type TaskDependencySpecification = number | string | {
+    /** The ID of the task to depend on. */
+    id?: string;
+    /** The index of the task in the batch to depend on. */
+    index?: number;
+    /** The statuses the dependency must reach. Defaults to [TaskStatus.Completed]. */
+    requiredStatuses?: TaskStatus[];
+};
+/**
+ * Options for enqueuing a task.
+ */
 export type EnqueueOptions = {
+    /** The priority of the task. */
     priority?: number;
+    /** The ID of the parent task. */
     parentId?: string;
+    /** A unique key for idempotency. */
     idempotencyKey?: string;
+    /** Whether to replace an existing task with the same idempotency key. */
     replace?: boolean;
+    /** Tags to associate with the task. */
     tags?: string[];
-    scheduleAfter?: (string | {
-        id: string;
-        requiredStatuses?: TaskStatus[];
-    })[];
-    completeAfter?: (string | {
-        id: string;
-        requiredStatuses?: TaskStatus[];
-    })[];
+    /**
+     * Tasks that must reach a specific status before this task can be scheduled.
+     * Can be an ID, an index in the batch, or an object with ID or index, and namespace.
+     */
+    scheduleAfter?: TaskDependencySpecification[];
+    /**
+     * Tasks that must reach a specific status before this task is considered complete.
+     * Can be an ID, an index in the batch, or an object with ID or index, and namespace.
+     */
+    completeAfter?: TaskDependencySpecification[];
+    /** Whether to skip the task if any of its dependencies fail. */
     failFast?: boolean;
+    /** Whether the parent task should wait for this task to complete. */
     waitForCompletion?: boolean;
+    /** The timestamp when the task should be processed. */
     scheduleTimestamp?: number;
+    /** The duration (ms) before the task is considered expired. */
     timeToLive?: number;
+    /** The transaction to use for the operation. */
     transaction?: Transaction;
 };
+/** Options for enqueuing a single task. */
 export type EnqueueOneOptions = EnqueueOptions;
+/**
+ * An item to be enqueued in a batch operation.
+ * @template Definitions The type map of task definitions.
+ * @template Type The type of the task.
+ */
 export type EnqueueManyItem<Definitions extends TaskDefinitionMap = TaskDefinitionMap, Type extends TaskTypes<Definitions> = TaskTypes<Definitions>> = {
     [Type in TaskTypes<Definitions>]: {
+        /** The type of the task. */
         type: Type;
+        /** The data for the task. */
         data: TaskData<Definitions, Type>;
     } & EnqueueOptions;
 }[Type];
+/** Options for enqueuing multiple tasks in a batch. */
 export type EnqueueManyOptions = {
+    /** Whether to replace existing tasks with the same idempotency keys. */
     replace?: boolean;
+    /** Whether to return the enqueued tasks. */
     returnTasks?: boolean;
+    /** The transaction to use for the operation. */
     transaction?: Transaction;
 };
+/** Configuration for a task queue. */
 export type QueueConfig = {
     /**
      * Duration (ms) before a worker token is considered lost.
@@ -156,8 +291,6 @@ export type QueueConfig = {
     maxTries?: number;
     /** Duration to retain terminal tasks before archival. Default: 30 days */
     retention?: number;
-    /** Maximum number of running tasks across all workers (`null` = unlimited) */
-    globalConcurrency?: number | null;
     /** Number of consecutive failures before tripping the circuit breaker */
     circuitBreakerThreshold?: number;
     /** Milliseconds to wait before trying to close the circuit breaker */
@@ -183,86 +316,191 @@ export type QueueConfig = {
     /** Time to retain idempotency keys (ms). Default: 1 hour */
     idempotencyWindow?: number;
 };
+/** Argument for injecting a task queue. Can be a namespace string or a full configuration. */
 export type TaskQueueArgument = string | (QueueConfig & {
     namespace: string;
 });
+/** Options for waiting for tasks to complete. */
 export type TaskQueueWaitOptions = {
+    /** The statuses to wait for. Defaults to finalized statuses (Completed, Cancelled, Dead, TimedOut, Expired, Skipped, Orphaned). */
+    statuses?: TaskStatus[];
+    /** The interval (ms) at which to check the task status. */
     interval?: number;
+    /** The maximum duration (ms) to wait. */
     timeout?: number;
+    /** A signal used to cancel the wait operation. */
     cancellationSignal?: CancellationSignal;
 };
+/** The result of waiting for tasks. */
 export type TaskQueueWaitResult = {
+    /** Whether the wait was cancelled. */
     cancelled: boolean;
 };
 export declare const defaultQueueConfig: Required<QueueConfig>;
+/**
+ * Abstract base class for task queues.
+ * @template Definitions The type map of task definitions.
+ */
 export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap = TaskDefinitionMap> extends Transactional<QueueConfig & {
     namespace: string;
 }> implements Resolvable<TaskQueueArgument> {
-    readonly [resolveArgumentType]: TaskQueueArgument;
+    #private;
     protected readonly injector: Injector;
     protected readonly config: QueueConfig & {
         namespace: string;
     };
     protected readonly logger: Logger;
+    get namespace(): string;
+    /** Duration (ms) before a worker token is considered lost. */
     abstract readonly visibilityTimeout: number;
+    /** Maximum number of attempts allowed for a task. */
     abstract readonly maxTries: number;
+    readonly [resolveArgumentType]: TaskQueueArgument;
+    /**
+     * Starts a new batch operation for enqueuing multiple tasks.
+     * @returns A TaskQueueEnqueueBatch instance.
+     */
     batch(): TaskQueueEnqueueBatch<Definitions>;
+    /**
+     * Enqueues a single task.
+     * @param type The type of the task.
+     * @param data The data for the task.
+     * @param options Enqueue options.
+     * @returns A promise that resolves to the enqueued task.
+     */
     abstract enqueue<Type extends TaskTypes<Definitions>>(type: Type, data: TaskData<Definitions, Type>, options?: EnqueueOneOptions): Promise<TaskOfType<Definitions, Type>>;
     /**
-     * Enqueues multiple tasks.
+     * Enqueues multiple tasks in a batch.
      * @param items The items to enqueue.
-     * @param options Enqueue options. If `returnTasks` is true, returns the enqueued tasks.
-     * **NOTE:** The order of returned tasks is NOT guaranteed to match the order of input items.
+     * @param options Enqueue options.
      */
     abstract enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions & {
         returnTasks?: false;
     }): Promise<void>;
+    /**
+     * Enqueues multiple tasks in a batch and returns the enqueued tasks.
+     * @param items The items to enqueue.
+     * @param options Enqueue options with returnTasks set to true.
+     * @returns A promise that resolves to an array of the enqueued tasks.
+     */
     abstract enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options: EnqueueManyOptions & {
         returnTasks: true;
     }): Promise<TaskOfType<Definitions, Type>[]>;
+    /**
+     * Enqueues multiple tasks in a batch.
+     * @param items The items to enqueue.
+     * @param options Enqueue options.
+     * @returns A promise that resolves to an array of the enqueued tasks if returnTasks is true, otherwise undefined.
+     */
     abstract enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions): Promise<TaskOfType<Definitions, Type>[] | undefined>;
+    /**
+     * Checks if a task with the given ID exists in the queue.
+     * @param id The ID of the task.
+     * @param options Optional transaction.
+     * @returns A promise that resolves to true if the task exists, false otherwise.
+     */
     abstract has(id: string, options?: {
         transaction?: Transaction;
     }): Promise<boolean>;
-    abstract getTask(id: string, options?: {
+    /**
+     * Counts tasks in the current namespace.
+     * @param options Optional status filter and transaction.
+     * @returns A promise that resolves to the number of tasks.
+     */
+    abstract count(options?: {
+        status?: TaskStatus;
+        transaction?: Transaction;
+    }): Promise<number>;
+    /**
+     * Retrieves a task by its ID.
+     * @param id The ID of the task.
+     * @param options Optional transaction.
+     * @returns A promise that resolves to the task if found, undefined otherwise.
+     */
+    abstract getTask<Type extends TaskTypes<Definitions> = TaskTypes<Definitions>>(id: string, options?: {
         transaction?: Transaction;
-    }): Promise<Task<Definitions> | undefined>;
-    abstract getManyByTags(tags: OneOrMany<string>, options?: {
+    }): Promise<TaskOfType<Definitions, Type> | undefined>;
+    /**
+     * Retrieves tasks associated with the given tags.
+     * @param tags One or more tags.
+     * @param options Optional transaction.
+     * @returns A promise that resolves to an array of tasks.
+     */
+    abstract getManyByTags<Type extends TaskTypes<Definitions>>(tags: OneOrMany<string>, options?: {
         transaction?: Transaction;
-    }): Promise<Task<Definitions>[]>;
+    }): Promise<TaskOfType<Definitions, Type>[]>;
+    /**
+     * Counts tasks associated with the given tags.
+     * @param tags One or more tags.
+     * @param options Optional transaction.
+     * @returns A promise that resolves to the number of tasks.
+     */
     abstract countByTags(tags: OneOrMany<string>, options?: {
         transaction?: Transaction;
     }): Promise<number>;
+    /**
+     * Retrieves all descendants of the given root task ID(s).
+     * @param rootId The root task ID or an array of root task IDs.
+     * @param options Optional transaction.
+     * @returns A promise that resolves to an array of tasks in the tree.
+     */
     abstract getTree(rootId: string | string[], options?: {
         transaction?: Transaction;
     }): Promise<Task[]>;
     /**
-     * Waits for the specified tasks to reach a finalized state (Completed, Cancelled, or Dead) or be removed/archived from queue (non-existent).
+     * Waits for the specified tasks to reach a finalized state (Completed, Cancelled, or Dead) or be removed from the queue.
      * @param ids The IDs of the tasks to wait for.
      * @param options Timeout and cancellation options.
+     * @returns A promise that resolves to a TaskQueueWaitResult.
+     */
+    abstract waitForTasks(ids: string[], options?: TaskQueueWaitOptions): Promise<TaskQueueWaitResult>;
+    /**
+     * Cancels a task.
+     * @param id The ID of the task to cancel.
+     * @param options Optional transaction.
      */
-    abstract waitForTasks(ids: string[], options?: {
-        timeout?: number;
-        cancellationSignal?: CancellationSignal;
-    }): Promise<TaskQueueWaitResult>;
     abstract cancel(id: string, options?: {
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Cancels multiple tasks by their IDs.
+     * @param ids The IDs of the tasks to cancel.
+     * @param options Optional transaction.
+     */
     abstract cancelMany(ids: string[], options?: {
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Cancels all tasks associated with the given tags.
+     * @param tags One or more tags.
+     * @param options Optional transaction.
+     */
     abstract cancelManyByTags(tags: OneOrMany<string>, options?: {
         transaction?: Transaction;
     }): Promise<void>;
-    /** Clears all tasks from the queue. Use with caution! */
+    /**
+     * Clears all tasks from the queue. Use with caution!
+     * @param options Optional transaction.
+     */
     abstract clear(options?: {
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Dequeues a task for processing.
+     * @param options Dequeue options.
+     * @returns A promise that resolves to a task if one is available, undefined otherwise.
+     */
     abstract dequeue<Type extends TaskTypes<Definitions>>(options?: {
         forceDequeue?: boolean;
         types?: Type[];
         transaction?: Transaction;
     }): Promise<TaskOfType<Definitions, Type> | undefined>;
+    /**
+     * Dequeues multiple tasks for processing.
+     * @param count The number of tasks to dequeue.
+     * @param options Dequeue options.
+     * @returns A promise that resolves to an array of dequeued tasks.
+     */
     abstract dequeueMany<Type extends TaskTypes<Definitions>>(count: number, options?: {
         forceDequeue?: boolean;
         types?: Type[];
@@ -270,20 +508,36 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
     }): Promise<TaskOfType<Definitions, Type>[]>;
     /**
      * Reschedules a task to run at a specific time.
-     * NOTE: If the task is currently running, its retry count is decremented (refunded) so this attempt doesn't count against maxTries.
+     * @param id The ID of the task.
+     * @param timestamp The timestamp when the task should run.
+     * @param options Optional transaction.
      */
     abstract reschedule(id: string, timestamp: number, options?: {
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Reschedules multiple tasks to run at a specific time.
+     * @param ids The IDs of the tasks.
+     * @param timestamp The timestamp when the tasks should run.
+     * @param options Optional transaction.
+     */
     abstract rescheduleMany(ids: string[], timestamp: number, options?: {
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Reschedules tasks with the given tags to run at a specific time.
+     * @param tags One or more tags.
+     * @param timestamp The timestamp when the tasks should run.
+     * @param options Optional transaction.
+     */
     abstract rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, options?: {
         transaction?: Transaction;
     }): Promise<void>;
     /**
-     * Updates task progress, state and lock.
-     * Returns the updated task if successful, `undefined` if task is lost/cancelled/timed out.
+     * Updates a task's progress and state and refreshes its lock.
+     * @param task The task to touch.
+     * @param options Progress, state, and optional transaction.
+     * @returns A promise that resolves to the updated task, or undefined if the task was lost.
      */
     abstract touch<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>, options?: {
         progress?: number;
@@ -291,53 +545,100 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
         transaction?: Transaction;
     }): Promise<TaskOfType<Definitions, Type> | undefined>;
     /**
-     * Updates multiple tasks' progress, state and lock.
-     * Returns the IDs of the successfully updated tasks.
+     * Updates multiple tasks' progress and state and refreshes their locks.
+     * @param tasks The tasks to touch.
+     * @param options Progresses, states, and optional transaction.
+     * @returns A promise that resolves to an array of successfully updated task IDs.
      */
     abstract touchMany<Tasks extends Task<Definitions>[]>(tasks: Tasks, options?: {
         progresses?: number[];
         states?: TasksStates<Tasks>;
         transaction?: Transaction;
     }): Promise<string[]>;
+    /**
+     * Marks a task as completed.
+     * @param task The task to complete.
+     * @param options Optional result and transaction.
+     */
     abstract complete<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>, options?: {
         result?: TaskResult<Definitions, Type>;
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Marks multiple tasks as completed.
+     * @param tasks The tasks to complete.
+     * @param options Optional results and transaction.
+     */
     abstract completeMany<Tasks extends Task<Definitions>[]>(tasks: Tasks, options?: {
         results?: TasksResults<Tasks>;
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Marks a task as failed.
+     * @param task The task that failed.
+     * @param error The error that occurred.
+     * @param options Optional fatal flag and transaction.
+     */
     abstract fail(task: Task<Definitions>, error: unknown, options?: {
         fatal?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Marks multiple tasks as failed.
+     * @param tasks The tasks that failed.
+     * @param errors The errors that occurred.
+     * @param options Optional transaction.
+     */
     abstract failMany(tasks: Task<Definitions>[], errors: unknown[], options?: {
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Performs maintenance tasks on the queue (e.g., handling timeouts, aging priorities, archival).
+     * @param options Optional transaction.
+     */
     abstract maintenance(options?: {
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Restarts a task from its initial state.
+     * @param id The ID of the task to restart.
+     * @param options Optional resetState flag and transaction.
+     */
     abstract restart(id: string, options?: {
         resetState?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
     /**
      * Notifies the queue that new tasks might be available for processing.
-     * Used to wake up waiting consumers.
-     * Useful for unit tests.
+     * @param namespace The namespace to notify. Defaults to the current namespace.
      * @internal
      */
-    abstract notify(): void;
+    abstract notify(namespace?: string): void;
+    /**
+     * Gets an async iterator for consuming tasks from the queue.
+     * @param cancellationSignal A signal to stop consuming tasks.
+     * @param options Dequeue options.
+     * @returns An async iterable iterator of tasks.
+     */
     abstract getConsumer<Type extends TaskTypes<Definitions>>(cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
         types?: Type[];
     }): AsyncIterableIterator<TaskOfType<Definitions, Type>>;
+    /**
+     * Gets an async iterator for consuming batches of tasks from the queue.
+     * @param size The batch size.
+     * @param cancellationSignal A signal to stop consuming tasks.
+     * @param options Dequeue options.
+     * @returns An async iterable iterator of task batches.
+     */
     abstract getBatchConsumer<Type extends TaskTypes<Definitions>>(size: number, cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
         types?: Type[];
     }): AsyncIterableIterator<TaskOfType<Definitions, Type>[]>;
     /**
-     * Starts processing tasks with the provided worker function in the background until the cancellation signal is triggered.
+     * Starts processing tasks with the provided worker function.
+     * @param options Concurrency, cancellation signal, task types, and forceDequeue flag.
+     * @param handler The worker function to process tasks.
      */
     process<Type extends TaskTypes<Definitions>>({ concurrency, cancellationSignal, types, forceDequeue }: {
         concurrency?: number;
@@ -349,7 +650,10 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
         namespace: string;
     };
     /**
-     * Starts processing tasks with the provided worker function in the foreground until the cancellation signal is triggered.
+     * Internal method to process tasks using a worker function.
+     * @param cancellationSignal A signal to stop processing tasks.
+     * @param handler The worker function.
+     * @param options Dequeue options.
      */
     processWorker<Type extends TaskTypes<Definitions>>(cancellationSignal: CancellationSignal, handler: ProcessWorker<Definitions, Type>, options?: {
         types?: Type[];