poolifier 4.4.4 → 5.0.0

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { TransferListItem, MessagePort, WorkerOptions as WorkerOptions$1, MessageChannel, Worker as Worker$1 } from 'node:worker_threads';
+import { Transferable, MessagePort, MessageChannel, WorkerOptions as WorkerOptions$1, Worker as Worker$1 } from 'node:worker_threads';
 import { EventEmitter, EventEmitterAsyncResource } from 'node:events';
 import { AsyncResource } from 'node:async_hooks';
 import { EventLoopUtilization } from 'node:perf_hooks';
@@ -9,21 +9,16 @@ import { ClusterSettings, Worker } from 'node:cluster';
  * @internal
  */
 declare class CircularBuffer {
+    size: number;
     private readonly items;
     private readonly maxArrayIdx;
     private readIdx;
     private writeIdx;
-    size: number;
     /**
      * @param size - Buffer size. @defaultValue defaultBufferSize
      * @returns CircularBuffer.
      */
     constructor(size?: number);
-    /**
-     * Checks the buffer size.
-     * @param size - Buffer size.
-     */
-    private checkSize;
     /**
      * Checks whether the buffer is empty.
      * @returns Whether the buffer is empty.
@@ -49,6 +44,11 @@ declare class CircularBuffer {
      * @returns Numbers' array.
      */
     toArray(): number[];
+    /**
+     * Checks the buffer size.
+     * @param size - Buffer size.
+     */
+    private checkSize;
 }
 
 /**
@@ -76,47 +76,60 @@ declare const Measurements: Readonly<{
     waitTime: 'waitTime';
 }>;
 /**
- * Measurement.
- */
-type Measurement = keyof typeof Measurements;
-/**
- * Measurement options.
+ * Worker choice strategy interface.
+ * @internal
  */
-interface MeasurementOptions {
+interface IWorkerChoiceStrategy {
     /**
-     * Set measurement median.
+     * Chooses a worker node in the pool and returns its key.
+     * If no worker nodes are not eligible, `undefined` is returned.
+     * If `undefined` is returned, the caller retry.
+     * @returns The worker node key or `undefined`.
      */
-    readonly median: boolean;
-}
-/**
- * Worker choice strategy options.
- */
-interface WorkerChoiceStrategyOptions {
+    readonly choose: () => number | undefined;
     /**
-     * Event loop utilization options.
-     * @defaultValue \{ median: false \}
+     * Removes the worker node key from strategy internals.
+     * @param workerNodeKey - The worker node key.
+     * @returns `true` if the worker node key is removed, `false` otherwise.
      */
-    readonly elu?: MeasurementOptions;
+    readonly remove: (workerNodeKey: number) => boolean;
     /**
-     * Measurement to use in worker choice strategy supporting it.
+     * Resets strategy internals.
+     * @returns `true` if the reset is successful, `false` otherwise.
      */
-    readonly measurement?: Measurement;
+    readonly reset: () => boolean;
     /**
-     * Runtime options.
-     * @defaultValue \{ median: false \}
+     * Sets the worker choice strategy options.
+     * @param opts - The worker choice strategy options.
      */
-    readonly runTime?: MeasurementOptions;
+    readonly setOptions: (opts: undefined | WorkerChoiceStrategyOptions) => void;
     /**
-     * Wait time options.
-     * @defaultValue \{ median: false \}
+     * Strategy policy.
      */
-    readonly waitTime?: MeasurementOptions;
+    readonly strategyPolicy: StrategyPolicy;
     /**
-     * Worker weights to use for weighted round robin worker selection strategies.
-     * A weight is tasks maximum execution time in milliseconds for a worker node.
-     * @defaultValue Weights computed automatically given the CPU performance.
+     * Tasks statistics requirements.
      */
-    weights?: Record<number, number>;
+    readonly taskStatisticsRequirements: TaskStatisticsRequirements;
+    /**
+     * Updates the worker node key strategy internals.
+     * This is called after a task has been executed on a worker node.
+     * @returns `true` if the update is successful, `false` otherwise.
+     */
+    readonly update: (workerNodeKey: number) => boolean;
+}
+/**
+ * Measurement.
+ */
+type Measurement = keyof typeof Measurements;
+/**
+ * Measurement options.
+ */
+interface MeasurementOptions {
+    /**
+     * Set measurement median.
+     */
+    readonly median: boolean;
 }
 /**
  * Measurement statistics requirements.
@@ -136,24 +149,6 @@ interface MeasurementStatisticsRequirements {
      */
     median: boolean;
 }
-/**
- * Pool worker node worker usage statistics requirements.
- * @internal
- */
-interface TaskStatisticsRequirements {
-    /**
-     * Tasks event loop utilization requirements.
-     */
-    readonly elu: MeasurementStatisticsRequirements;
-    /**
-     * Tasks runtime requirements.
-     */
-    readonly runTime: MeasurementStatisticsRequirements;
-    /**
-     * Tasks wait time requirements.
-     */
-    readonly waitTime: MeasurementStatisticsRequirements;
-}
 /**
  * Strategy policy.
  * @internal
@@ -169,47 +164,52 @@ interface StrategyPolicy {
     readonly dynamicWorkerUsage: boolean;
 }
 /**
- * Worker choice strategy interface.
+ * Pool worker node worker usage statistics requirements.
  * @internal
  */
-interface IWorkerChoiceStrategy {
+interface TaskStatisticsRequirements {
     /**
-     * Chooses a worker node in the pool and returns its key.
-     * If no worker nodes are not eligible, `undefined` is returned.
-     * If `undefined` is returned, the caller retry.
-     * @returns The worker node key or `undefined`.
+     * Tasks event loop utilization requirements.
      */
-    readonly choose: () => number | undefined;
+    readonly elu: MeasurementStatisticsRequirements;
     /**
-     * Removes the worker node key from strategy internals.
-     * @param workerNodeKey - The worker node key.
-     * @returns `true` if the worker node key is removed, `false` otherwise.
+     * Tasks runtime requirements.
      */
-    readonly remove: (workerNodeKey: number) => boolean;
+    readonly runTime: MeasurementStatisticsRequirements;
     /**
-     * Resets strategy internals.
-     * @returns `true` if the reset is successful, `false` otherwise.
+     * Tasks wait time requirements.
      */
-    readonly reset: () => boolean;
+    readonly waitTime: MeasurementStatisticsRequirements;
+}
+/**
+ * Worker choice strategy options.
+ */
+interface WorkerChoiceStrategyOptions {
     /**
-     * Sets the worker choice strategy options.
-     * @param opts - The worker choice strategy options.
+     * Event loop utilization options.
+     * @defaultValue \{ median: false \}
      */
-    readonly setOptions: (opts: undefined | WorkerChoiceStrategyOptions) => void;
+    readonly elu?: MeasurementOptions;
     /**
-     * Strategy policy.
+     * Measurement to use in worker choice strategy supporting it.
      */
-    readonly strategyPolicy: StrategyPolicy;
+    readonly measurement?: Measurement;
     /**
-     * Tasks statistics requirements.
+     * Runtime options.
+     * @defaultValue \{ median: false \}
      */
-    readonly taskStatisticsRequirements: TaskStatisticsRequirements;
+    readonly runTime?: MeasurementOptions;
     /**
-     * Updates the worker node key strategy internals.
-     * This is called after a task has been executed on a worker node.
-     * @returns `true` if the update is successful, `false` otherwise.
+     * Wait time options.
+     * @defaultValue \{ median: false \}
      */
-    readonly update: (workerNodeKey: number) => boolean;
+    readonly waitTime?: MeasurementOptions;
+    /**
+     * Worker weights to use for weighted round robin worker selection strategies.
+     * A weight is tasks maximum execution time in milliseconds for a worker node.
+     * @defaultValue Weights computed automatically given the CPU performance.
+     */
+    weights?: Record<number, number>;
 }
 
 /**
@@ -261,83 +261,99 @@ interface WorkerOptions {
 }
 
 /**
- * Worker error.
- * @typeParam Data - Type of data sent to the worker triggering an error. This can only be structured-cloneable data.
+ * Message object that is passed between main worker and worker.
+ * @typeParam Data - Type of data sent to the worker or execution response. This can only be structured-cloneable data.
+ * @typeParam ErrorData - Type of data sent to the worker triggering an error. This can only be structured-cloneable data.
+ * @internal
  */
-interface WorkerError<Data = unknown> {
+interface MessageValue<Data = unknown, ErrorData = unknown> extends Task<Data> {
     /**
-     * Data triggering the error.
+     * Whether the worker starts or stops its activity check.
      */
-    readonly data?: Data;
+    readonly checkActive?: boolean;
     /**
-     * Error object.
+     * Kill code.
      */
-    readonly error?: Error;
+    readonly kill?: 'failure' | 'success' | KillBehavior | true;
     /**
-     * Error message.
+     * Message port.
      */
-    readonly message: string;
+    readonly port?: MessagePort;
     /**
-     * Task function name triggering the error.
+     * Whether the worker is ready or not.
      */
-    readonly name?: string;
+    readonly ready?: boolean;
     /**
-     * Error stack trace.
+     * Whether the worker computes the given statistics or not.
      */
-    readonly stack?: string;
-}
-/**
- * Task performance.
- * @internal
- */
-interface TaskPerformance {
+    readonly statistics?: WorkerStatistics;
     /**
-     * Task event loop utilization.
+     * Task function serialized to string.
      */
-    readonly elu?: EventLoopUtilization;
+    readonly taskFunction?: string;
     /**
-     * Task name.
+     * Task function operation:
+     * - `'add'` - Add a task function.
+     * - `'remove'` - Remove a task function.
+     * - `'default'` - Set a task function as default.
      */
-    readonly name: string;
+    readonly taskFunctionOperation?: 'add' | 'default' | 'remove';
     /**
-     * Task runtime.
+     * Whether the task function operation is successful or not.
      */
-    readonly runTime?: number;
+    readonly taskFunctionOperationStatus?: boolean;
     /**
-     * Task performance timestamp.
+     * Task function properties.
      */
-    readonly timestamp: number;
+    readonly taskFunctionProperties?: TaskFunctionProperties;
+    /**
+     * Task functions properties.
+     */
+    readonly taskFunctionsProperties?: TaskFunctionProperties[];
+    /**
+     * Task operation:
+     * - `'abort'` - Abort a task.
+     */
+    readonly taskOperation?: 'abort';
+    /**
+     * Task performance.
+     */
+    readonly taskPerformance?: TaskPerformance;
+    /**
+     * Worker error.
+     */
+    readonly workerError?: WorkerError<ErrorData>;
+    /**
+     * Worker id.
+     */
+    readonly workerId?: number;
 }
 /**
- * Worker task performance statistics computation settings.
+ * An object holding the task execution response promise resolve/reject callbacks.
+ * @typeParam Response - Type of execution response. This can only be structured-cloneable data.
  * @internal
  */
-interface WorkerStatistics {
+interface PromiseResponseWrapper<Response = unknown> {
     /**
-     * Whether the worker computes the task event loop utilization (ELU) or not.
+     * The task abort signal.
      */
-    readonly elu: boolean;
+    readonly abortSignal?: AbortSignal;
     /**
-     * Whether the worker computes the task runtime or not.
+     * The asynchronous resource used to track the task execution.
      */
-    readonly runTime: boolean;
-}
-/**
- * Task function properties.
- */
-interface TaskFunctionProperties {
+    readonly asyncResource?: AsyncResource;
     /**
-     * Task function name.
+     * Reject callback to reject the promise.
      */
-    readonly name: string;
+    readonly reject: (reason?: unknown) => void;
     /**
-     * Task function priority. Lower values have higher priority.
+     * Resolve callback to fulfill the promise.
      */
-    readonly priority?: number;
+    readonly resolve: (value: PromiseLike<Response> | Response) => void;
     /**
-     * Task function worker choice strategy.
+     * The worker node key executing the task.
      */
-    readonly strategy?: WorkerChoiceStrategy;
+    readonly workerNodeKey: number;
 }
 /**
  * Message object that is passed as a task between main worker and worker.
@@ -345,6 +361,10 @@ interface TaskFunctionProperties {
  * @internal
  */
 interface Task<Data = unknown> {
+    /**
+     * Whether the task is abortable or not.
+     */
+    readonly abortable?: boolean;
     /**
      * Task input data that will be passed to the worker.
      */
@@ -373,93 +393,90 @@ interface Task<Data = unknown> {
     /**
      * Array of transferable objects.
      */
-    readonly transferList?: readonly TransferListItem[];
+    readonly transferList?: readonly Transferable[];
 }
 /**
- * Message object that is passed between main worker and worker.
- * @typeParam Data - Type of data sent to the worker or execution response. This can only be structured-cloneable data.
- * @typeParam ErrorData - Type of data sent to the worker triggering an error. This can only be structured-cloneable data.
- * @internal
+ * Task function properties.
  */
-interface MessageValue<Data = unknown, ErrorData = unknown> extends Task<Data> {
+interface TaskFunctionProperties {
     /**
-     * Whether the worker starts or stops its activity check.
+     * Task function name.
      */
-    readonly checkActive?: boolean;
+    readonly name: string;
     /**
-     * Kill code.
+     * Task function priority. Lower values have higher priority.
      */
-    readonly kill?: 'failure' | 'success' | KillBehavior | true;
+    readonly priority?: number;
     /**
-     * Message port.
+     * Task function worker choice strategy.
      */
-    readonly port?: MessagePort;
+    readonly strategy?: WorkerChoiceStrategy;
+}
+/**
+ * Task performance.
+ * @internal
+ */
+interface TaskPerformance {
     /**
-     * Whether the worker is ready or not.
+     * Task event loop utilization.
      */
-    readonly ready?: boolean;
+    readonly elu?: EventLoopUtilization;
     /**
-     * Whether the worker computes the given statistics or not.
+     * Task name.
      */
-    readonly statistics?: WorkerStatistics;
+    readonly name: string;
     /**
-     * Task function serialized to string.
+     * Task runtime.
      */
-    readonly taskFunction?: string;
+    readonly runTime?: number;
     /**
-     * Task function operation:
-     * - `'add'` - Add a task function.
-     * - `'remove'` - Remove a task function.
-     * - `'default'` - Set a task function as default.
+     * Task performance timestamp.
      */
-    readonly taskFunctionOperation?: 'add' | 'default' | 'remove';
+    readonly timestamp: number;
+}
+/**
+ * Worker error.
+ * @typeParam Data - Type of data sent to the worker triggering an error. This can only be structured-cloneable data.
+ */
+interface WorkerError<Data = unknown> {
     /**
-     * Whether the task function operation is successful or not.
+     * Whether the error is an abort error or not.
      */
-    readonly taskFunctionOperationStatus?: boolean;
+    readonly aborted: boolean;
     /**
-     * Task function properties.
+     * Data triggering the error.
      */
-    readonly taskFunctionProperties?: TaskFunctionProperties;
+    readonly data?: Data;
     /**
-     * Task functions properties.
+     * Error object.
      */
-    readonly taskFunctionsProperties?: TaskFunctionProperties[];
+    readonly error?: Error;
     /**
-     * Task performance.
+     * Error message.
      */
-    readonly taskPerformance?: TaskPerformance;
+    readonly message: string;
     /**
-     * Worker error.
+     * Task function name triggering the error.
      */
-    readonly workerError?: WorkerError<ErrorData>;
+    readonly name?: string;
     /**
-     * Worker id.
+     * Error stack trace.
      */
-    readonly workerId?: number;
+    readonly stack?: string;
 }
 /**
- * An object holding the task execution response promise resolve/reject callbacks.
- * @typeParam Response - Type of execution response. This can only be structured-cloneable data.
+ * Worker task performance statistics computation settings.
  * @internal
  */
-interface PromiseResponseWrapper<Response = unknown> {
-    /**
-     * The asynchronous resource used to track the task execution.
-     */
-    readonly asyncResource?: AsyncResource;
-    /**
-     * Reject callback to reject the promise.
-     */
-    readonly reject: (reason?: unknown) => void;
+interface WorkerStatistics {
     /**
-     * Resolve callback to fulfill the promise.
+     * Whether the worker computes the task event loop utilization (ELU) or not.
      */
-    readonly resolve: (value: PromiseLike<Response> | Response) => void;
+    readonly elu: boolean;
     /**
-     * The worker node key executing the task.
+     * Whether the worker computes the task runtime or not.
      */
-    readonly workerNodeKey: number;
+    readonly runTime: boolean;
 }
 /**
  * Remove readonly modifier from all properties of T.
@@ -470,14 +487,6 @@ type Writable<T> = {
     -readonly [P in keyof T]: T[P];
 };
 
-/**
- * Task synchronous function that can be executed.
- * @param data - Data sent to the worker.
- * @returns Execution response.
- * @typeParam Data - Type of data sent to the worker. This can only be structured-cloneable data.
- * @typeParam Response - Type of execution response. This can only be structured-cloneable data.
- */
-type TaskSyncFunction<Data = unknown, Response = unknown> = (data?: Data) => Response;
 /**
  * Task asynchronous function that can be executed.
  * This function must return a promise.
@@ -513,6 +522,13 @@ interface TaskFunctionObject<Data = unknown, Response = unknown> {
      */
     taskFunction: TaskFunction<Data, Response>;
 }
+/**
+ * Task function operation result.
+ */
+interface TaskFunctionOperationResult {
+    error?: Error;
+    status: boolean;
+}
 /**
  * Tasks functions that can be executed.
  * The key is the name of the task function or task function object.
@@ -522,38 +538,119 @@ interface TaskFunctionObject<Data = unknown, Response = unknown> {
  */
 type TaskFunctions<Data = unknown, Response = unknown> = Record<string, TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>>;
 /**
- * Task function operation result.
+ * Task synchronous function that can be executed.
+ * @param data - Data sent to the worker.
+ * @returns Execution response.
+ * @typeParam Data - Type of data sent to the worker. This can only be structured-cloneable data.
+ * @typeParam Response - Type of execution response. This can only be structured-cloneable data.
  */
-interface TaskFunctionOperationResult {
-    error?: Error;
-    status: boolean;
-}
+type TaskSyncFunction<Data = unknown, Response = unknown> = (data?: Data) => Response;
 
 /**
- * Callback invoked when the worker has started successfully.
- * @typeParam Worker - Type of worker.
+ * Priority queue.
+ * @typeParam T - Type of priority queue data.
+ * @internal
  */
-type OnlineHandler<Worker extends IWorker> = (this: Worker) => void;
+declare class PriorityQueue<T> {
+    /** The priority queue maximum size. */
+    maxSize: number;
+    /**
+     * The number of filled prioritized buckets.
+     * @returns The number of filled prioritized buckets.
+     */
+    get buckets(): number;
+    /**
+     * Whether priority is enabled.
+     * @returns Whether priority is enabled.
+     */
+    get enablePriority(): boolean;
+    /**
+     * Enables/disables priority.
+     * @param enablePriority - Whether to enable priority.
+     */
+    set enablePriority(enablePriority: boolean);
+    /**
+     * The priority queue size.
+     * @returns The priority queue size.
+     */
+    get size(): number;
+    private readonly bucketSize;
+    private head;
+    private priorityEnabled;
+    private tail;
+    /**
+     * Constructs a priority queue.
+     * @param bucketSize - Prioritized bucket size. @defaultValue defaultBucketSize
+     * @param enablePriority - Whether to enable priority. @defaultValue false
+     * @returns PriorityQueue.
+     */
+    constructor(bucketSize?: number, enablePriority?: boolean);
+    /**
+     * Clears the priority queue.
+     */
+    clear(): void;
+    /**
+     * Deletes the given data from the priority queue.
+     * @param data - Data to delete.
+     * @returns `true` if the data was deleted, `false` otherwise.
+     */
+    delete(data: T): boolean;
+    /**
+     * Dequeue data from the priority queue.
+     * @param bucket - The prioritized bucket to dequeue from.
+     * @returns The dequeued data or `undefined` if the priority queue is empty.
+     */
+    dequeue(bucket?: number): T | undefined;
+    /**
+     * Enqueue data into the priority queue.
+     * @param data - Data to enqueue.
+     * @param priority - Priority of the data. Lower values have higher priority.
+     * @returns The new size of the priority queue.
+     */
+    enqueue(data: T, priority?: number): number;
+    /**
+     * Returns an iterator for the priority queue.
+     * @returns An iterator for the priority queue.
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
+     */
+    [Symbol.iterator](): Iterator<T>;
+    private getPriorityQueueNode;
+}
+
 /**
- * Callback invoked if the worker has received a message.
+ * Callback invoked if the worker raised an error.
  * @typeParam Worker - Type of worker.
  */
-type MessageHandler<Worker extends IWorker> = (this: Worker, message: unknown) => void;
+type ErrorHandler<Worker extends IWorker> = (this: Worker, error: Error) => void;
 /**
- * Callback invoked if the worker raised an error.
+ * Worker event handler.
  * @typeParam Worker - Type of worker.
  */
-type ErrorHandler<Worker extends IWorker> = (this: Worker, error: Error) => void;
+type EventHandler<Worker extends IWorker> = ErrorHandler<Worker> | ExitHandler<Worker> | MessageHandler<Worker> | OnlineHandler<Worker>;
 /**
  * Callback invoked when the worker exits successfully.
  * @typeParam Worker - Type of worker.
  */
 type ExitHandler<Worker extends IWorker> = (this: Worker, exitCode: number) => void;
 /**
- * Worker event handler.
+ * Callback invoked if the worker has received a message.
  * @typeParam Worker - Type of worker.
  */
-type EventHandler<Worker extends IWorker> = ErrorHandler<Worker> | ExitHandler<Worker> | MessageHandler<Worker> | OnlineHandler<Worker>;
+type MessageHandler<Worker extends IWorker> = (this: Worker, message: unknown) => void;
+/**
+ * Callback invoked when the worker has started successfully.
+ * @typeParam Worker - Type of worker.
+ */
+type OnlineHandler<Worker extends IWorker> = (this: Worker) => void;
+/**
+ * Event loop utilization measurement statistics.
+ * @internal
+ */
+interface EventLoopUtilizationMeasurementStatistics {
+    readonly active: MeasurementStatistics;
+    readonly idle: MeasurementStatistics;
+    utilization?: number;
+}
 /**
  * Measurement statistics.
  * @internal
@@ -584,15 +681,6 @@ interface MeasurementStatistics {
      */
     minimum?: number;
 }
-/**
- * Event loop utilization measurement statistics.
- * @internal
- */
-interface EventLoopUtilizationMeasurementStatistics {
-    readonly active: MeasurementStatistics;
-    readonly idle: MeasurementStatistics;
-    utilization?: number;
-}
 /**
  * Task statistics.
  * @internal
@@ -635,115 +723,31 @@ declare const WorkerTypes: Readonly<{
     thread: 'thread';
 }>;
 /**
- * Worker type.
- */
-type WorkerType = keyof typeof WorkerTypes;
-/**
- * Worker information.
- * @internal
+ * Worker interface.
  */
-interface WorkerInfo {
+interface IWorker extends EventEmitter {
     /**
-     * Back pressure flag.
-     * This flag is set to `true` when worker node tasks queue is back pressured.
+     * Cluster worker disconnect.
      */
-    backPressure: boolean;
+    readonly disconnect?: () => void;
     /**
-     * Back pressure stealing flag.
-     * This flag is set to `true` when worker node is stealing one task from another back pressured worker node.
+     * Cluster worker id.
      */
-    backPressureStealing: boolean;
+    readonly id?: number;
     /**
-     * Continuous stealing flag.
-     * This flag is set to `true` when worker node is continuously stealing tasks from other worker nodes.
+     * Cluster worker kill.
      */
-    continuousStealing: boolean;
+    readonly kill?: (signal?: string) => void;
     /**
-     * Dynamic flag.
+     * Registers an event handler.
+     * @param event - The event.
+     * @param handler - The event handler.
      */
-    dynamic: boolean;
+    readonly on: (event: string, handler: EventHandler<this>) => this;
     /**
-     * Worker id.
-     */
-    readonly id: number | undefined;
-    /**
-     * Ready flag.
-     */
-    ready: boolean;
-    /**
-     * Stealing flag.
-     * This flag is set to `true` when worker node is stealing one task from another worker node.
-     */
-    stealing: boolean;
-    /**
-     * Stolen flag.
-     * This flag is set to `true` when worker node has one task stolen from another worker node.
-     */
-    stolen: boolean;
-    /**
-     * Task functions properties.
-     */
-    taskFunctionsProperties?: TaskFunctionProperties[];
-    /**
-     * Worker type.
-     */
-    readonly type: WorkerType;
-}
-/**
- * Worker usage statistics.
- * @internal
- */
-interface WorkerUsage {
-    /**
-     * Tasks event loop utilization statistics.
-     */
-    readonly elu: EventLoopUtilizationMeasurementStatistics;
-    /**
-     * Tasks runtime statistics.
-     */
-    readonly runTime: MeasurementStatistics;
-    /**
-     * Tasks statistics.
-     */
-    readonly tasks: TaskStatistics;
-    /**
-     * Tasks wait time statistics.
-     */
-    readonly waitTime: MeasurementStatistics;
-}
-/**
- * Worker choice strategy data.
- * @internal
- */
-interface StrategyData {
-    virtualTaskEndTimestamp?: number;
-}
-/**
- * Worker interface.
- */
-interface IWorker extends EventEmitter {
-    /**
-     * Cluster worker disconnect.
-     */
-    readonly disconnect?: () => void;
-    /**
-     * Cluster worker id.
-     */
-    readonly id?: number;
-    /**
-     * Cluster worker kill.
-     */
-    readonly kill?: (signal?: string) => void;
-    /**
-     * Registers an event handler.
-     * @param event - The event.
-     * @param handler - The event handler.
-     */
-    readonly on: (event: string, handler: EventHandler<this>) => this;
-    /**
-     * Registers once an event handler.
-     * @param event - The event.
-     * @param handler - The event handler.
+     * Registers once an event handler.
+     * @param event - The event.
+     * @param handler - The event handler.
      */
     readonly once: (event: string, handler: EventHandler<this>) => this;
     /**
@@ -762,17 +766,6 @@ interface IWorker extends EventEmitter {
      */
     readonly unref?: () => void;
 }
-/**
- * Worker node options.
- * @internal
- */
-interface WorkerNodeOptions {
-    env?: Record<string, unknown>;
-    tasksQueueBackPressureSize: number | undefined;
-    tasksQueueBucketSize: number | undefined;
-    tasksQueuePriority: boolean | undefined;
-    workerOptions?: WorkerOptions$1;
-}
 /**
  * Worker node interface.
  * @typeParam Worker - Type of worker.
@@ -784,6 +777,12 @@ interface IWorkerNode<Worker extends IWorker, Data = unknown> extends EventEmitt
      * Clears tasks queue.
      */
     readonly clearTasksQueue: () => void;
+    /**
+     * Deletes a task from the tasks queue.
+     * @param task - The task to delete.
+     * @returns `true` if the task was deleted, `false` otherwise.
+     */
+    readonly deleteTask: (task: Task<Data>) => boolean;
     /**
      * Deletes task function worker usage statistics.
      * @param name - The task function name.
@@ -843,6 +842,10 @@ interface IWorkerNode<Worker extends IWorker, Data = unknown> extends EventEmitt
      * This is used to store data that are specific to the worker choice strategy.
      */
     strategyData?: StrategyData;
+    /**
+     * Tasks queue.
+     */
+    readonly tasksQueue: PriorityQueue<Task<Data>>;
     /**
      * Tasks queue back pressure size.
      * This is the number of tasks that can be enqueued before the worker node has back pressure.
@@ -866,14 +869,115 @@ interface IWorkerNode<Worker extends IWorker, Data = unknown> extends EventEmitt
      */
     readonly worker: Worker;
 }
+/**
+ * Worker choice strategy data.
+ * @internal
+ */
+interface StrategyData {
+    virtualTaskEndTimestamp?: number;
+}
+/**
+ * Worker information.
+ * @internal
+ */
+interface WorkerInfo {
+    /**
+     * Back pressure flag.
+     * This flag is set to `true` when worker node tasks queue is back pressured.
+     */
+    backPressure: boolean;
+    /**
+     * Back pressure stealing flag.
+     * This flag is set to `true` when worker node is stealing one task from another back pressured worker node.
+     */
+    backPressureStealing: boolean;
+    /**
+     * Continuous stealing flag.
+     * This flag is set to `true` when worker node is continuously stealing tasks from other worker nodes.
+     */
+    continuousStealing: boolean;
+    /**
+     * Dynamic flag.
+     */
+    dynamic: boolean;
+    /**
+     * Worker id.
+     */
+    readonly id: number | undefined;
+    /**
+     * Queued task abortion flag.
+     * This flag is set to `true` when worker node is aborting a queued task.
+     */
+    queuedTaskAbortion: boolean;
+    /**
+     * Ready flag.
+     */
+    ready: boolean;
+    /**
+     * Stealing flag.
+     * This flag is set to `true` when worker node is stealing one task from another worker node.
+     */
+    stealing: boolean;
+    /**
+     * Stolen flag.
+     * This flag is set to `true` when worker node has one task stolen from another worker node.
+     */
+    stolen: boolean;
+    /**
+     * Task functions properties.
+     */
+    taskFunctionsProperties?: TaskFunctionProperties[];
+    /**
+     * Worker type.
+     */
+    readonly type: WorkerType;
+}
 /**
  * Worker node event detail.
  * @internal
  */
 interface WorkerNodeEventDetail {
+    taskId?: `${string}-${string}-${string}-${string}-${string}`;
     workerId?: number;
     workerNodeKey?: number;
 }
+/**
+ * Worker node options.
+ * @internal
+ */
+interface WorkerNodeOptions {
+    env?: Record<string, unknown>;
+    tasksQueueBackPressureSize: number | undefined;
+    tasksQueueBucketSize: number | undefined;
+    tasksQueuePriority: boolean | undefined;
+    workerOptions?: WorkerOptions$1;
+}
+/**
+ * Worker type.
+ */
+type WorkerType = keyof typeof WorkerTypes;
+/**
+ * Worker usage statistics.
+ * @internal
+ */
+interface WorkerUsage {
+    /**
+     * Tasks event loop utilization statistics.
+     */
+    readonly elu: EventLoopUtilizationMeasurementStatistics;
+    /**
+     * Tasks runtime statistics.
+     */
+    readonly runTime: MeasurementStatistics;
+    /**
+     * Tasks statistics.
+     */
+    readonly tasks: TaskStatistics;
+    /**
+     * Tasks wait time statistics.
+     */
+    readonly waitTime: MeasurementStatistics;
+}
 
 /**
  * Enumeration of pool types.
@@ -902,6 +1006,124 @@ declare const PoolEvents: Readonly<{
     ready: 'ready';
     taskError: 'taskError';
 }>;
+/**
+ * Contract definition for a poolifier pool.
+ * @typeParam Worker - Type of worker which manages this pool.
+ * @typeParam Data - Type of data sent to the worker. This can only be structured-cloneable data.
+ * @typeParam Response - Type of execution response. This can only be structured-cloneable data.
+ */
+interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
+    /**
+     * Adds a task function to this pool.
+     * If a task function with the same name already exists, it will be overwritten.
+     * @param name - The name of the task function.
+     * @param fn - The task function.
+     * @returns `true` if the task function was added, `false` otherwise.
+     * @throws {@link https://nodejs.org/api/errors.html#class-typeerror} If the `name` parameter is not a string or an empty string.
+     * @throws {@link https://nodejs.org/api/errors.html#class-typeerror} If the `fn` parameter is not a function or task function object.
+     */
+    readonly addTaskFunction: (name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>) => Promise<boolean>;
+    /**
+     * Terminates all workers in this pool.
+     */
+    readonly destroy: () => Promise<void>;
+    /**
+     * Pool event emitter integrated with async resource.
+     * The async tracking tooling identifier is `poolifier:<PoolType>-<WorkerType>-pool`.
+     *
+     * Events that can currently be listened to:
+     *
+     * - `'ready'`: Emitted when the number of workers created in the pool has reached the minimum size expected and are ready. If the pool is dynamic with a minimum number of workers set to zero, this event is emitted when the pool is started.
+     * - `'busy'`: Emitted when the number of workers created in the pool has reached the maximum size expected and are executing concurrently their tasks quota.
+     * - `'busyEnd'`: Emitted when the number of workers created in the pool has reached the maximum size expected and are no longer executing concurrently their tasks quota.
+     * - `'full'`: Emitted when the pool is dynamic and the number of workers created has reached the maximum size expected.
+     * - `'fullEnd'`: Emitted when the pool is dynamic and the number of workers created has no longer reached the maximum size expected.
+     * - `'empty'`: Emitted when the pool is dynamic with a minimum number of workers set to zero and the number of workers has reached the minimum size expected.
+     * - `'destroy'`: Emitted when the pool is destroyed.
+     * - `'error'`: Emitted when an uncaught error occurs.
+     * - `'taskError'`: Emitted when an error occurs while executing a task.
+     * - `'backPressure'`: Emitted when the number of workers created in the pool has reached the maximum size expected and are back pressured (i.e. their tasks queue is full: queue size \>= maximum queue size).
+     * - `'backPressureEnd'`: Emitted when the number of workers created in the pool has reached the maximum size expected and are no longer back pressured (i.e. their tasks queue is no longer full: queue size \< maximum queue size).
+     */
+    readonly emitter?: EventEmitterAsyncResource;
+    /**
+     * Enables/disables the worker node tasks queue in this pool.
+     * @param enable - Whether to enable or disable the worker node tasks queue.
+     * @param tasksQueueOptions - The worker node tasks queue options.
+     */
+    readonly enableTasksQueue: (enable: boolean, tasksQueueOptions?: TasksQueueOptions) => void;
+    /**
+     * Executes the specified function in the worker constructor with the task data input parameter.
+     * @param data - The optional task input data for the specified task function. This can only be structured-cloneable data.
+     * @param name - The optional name of the task function to execute. If not specified, the default task function will be executed.
+     * @param abortSignal - The optional AbortSignal to abort the task.
+     * @param transferList - The optional array of transferable objects to transfer ownership of. Ownership of the transferred objects is given to the chosen pool's worker_threads worker and they should not be used in the main thread afterwards.
+     * @returns Promise with a task function response that will be fulfilled when the task is completed.
+     */
+    readonly execute: (data?: Data, name?: string, abortSignal?: AbortSignal, transferList?: readonly Transferable[]) => Promise<Response>;
+    /**
+     * Whether the specified task function exists in this pool.
+     * @param name - The name of the task function.
+     * @returns `true` if the task function exists, `false` otherwise.
+     */
+    readonly hasTaskFunction: (name: string) => boolean;
+    /**
+     * Pool information.
+     */
+    readonly info: PoolInfo;
+    /**
+     * Lists the properties of task functions available in this pool.
+     * @returns The properties of task functions available in this pool.
+     */
+    readonly listTaskFunctionsProperties: () => TaskFunctionProperties[];
+    /**
+     * Executes the specified function in the worker constructor with the tasks data iterable input parameter.
+     * @param data - The tasks iterable input data for the specified task function. This can only be an iterable of structured-cloneable data.
+     * @param name - The optional name of the task function to execute. If not specified, the default task function will be executed.
+     * @param abortSignals - The optional iterable of AbortSignal to abort the tasks iterable.
+     * @param transferList - The optional array of transferable objects to transfer ownership of. Ownership of the transferred objects is given to the chosen pool's worker_threads worker and they should not be used in the main thread afterwards.
+     * @returns Promise with an array of task function responses that will be fulfilled when the tasks are completed.
+     */
+    readonly mapExecute: (data: Iterable<Data>, name?: string, abortSignals?: Iterable<AbortSignal>, transferList?: readonly Transferable[]) => Promise<Response[]>;
+    /**
+     * Removes a task function from this pool.
+     * @param name - The name of the task function.
+     * @returns `true` if the task function was removed, `false` otherwise.
+     */
+    readonly removeTaskFunction: (name: string) => Promise<boolean>;
+    /**
+     * Sets the default task function in this pool.
+     * @param name - The name of the task function.
+     * @returns `true` if the default task function was set, `false` otherwise.
+     */
+    readonly setDefaultTaskFunction: (name: string) => Promise<boolean>;
+    /**
+     * Sets the worker node tasks queue options in this pool.
+     * @param tasksQueueOptions - The worker node tasks queue options.
+     */
+    readonly setTasksQueueOptions: (tasksQueueOptions: TasksQueueOptions) => void;
+    /**
+     * Sets the default worker choice strategy in this pool.
+     * @param workerChoiceStrategy - The default worker choice strategy.
+     * @param workerChoiceStrategyOptions - The worker choice strategy options.
+     */
+    readonly setWorkerChoiceStrategy: (workerChoiceStrategy: WorkerChoiceStrategy, workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions) => void;
+    /**
+     * Sets the worker choice strategy options in this pool.
+     * @param workerChoiceStrategyOptions - The worker choice strategy options.
+     * @returns `true` if the worker choice strategy options were set, `false` otherwise.
+     */
+    readonly setWorkerChoiceStrategyOptions: (workerChoiceStrategyOptions: WorkerChoiceStrategyOptions) => boolean;
+    /**
+     * Starts the minimum number of workers in this pool.
+     */
+    readonly start: () => void;
+    /**
+     * Pool worker nodes.
+     * @internal
+     */
+    readonly workerNodes: IWorkerNode<Worker, Data>[];
+}
 /**
  * Pool event.
  */
@@ -971,41 +1193,6 @@ interface PoolInfo {
     /** Pool total worker nodes. */
     readonly workerNodes: number;
 }
-/**
- * Worker node tasks queue options.
- */
-interface TasksQueueOptions {
-    /**
-     * Maximum number of tasks that can be executed concurrently on a worker node.
-     * @defaultValue 1
-     */
-    readonly concurrency?: number;
-    /**
-     * Maximum tasks queue size per worker node flagging it as back pressured.
-     * @defaultValue (pool maximum size)^2
-     */
-    readonly size?: number;
-    /**
-     * Queued tasks finished timeout in milliseconds at worker node termination.
-     * @defaultValue 2000
-     */
-    readonly tasksFinishedTimeout?: number;
-    /**
-     * Whether to enable tasks stealing under back pressure.
-     * @defaultValue true
-     */
-    readonly tasksStealingOnBackPressure?: boolean;
-    /**
-     * Ratio of worker nodes that can steal tasks from another worker node.
-     * @defaultValue 0.6
-     */
-    readonly tasksStealingRatio?: number;
-    /**
-     * Whether to enable task stealing on idle.
-     * @defaultValue true
-     */
-    readonly taskStealing?: boolean;
-}
 /**
  * Options for a poolifier pool.
  * @typeParam Worker - Type of worker.
@@ -1080,120 +1267,39 @@ interface PoolOptions<Worker extends IWorker> {
     workerOptions?: WorkerOptions$1;
 }
 /**
- * Contract definition for a poolifier pool.
- * @typeParam Worker - Type of worker which manages this pool.
- * @typeParam Data - Type of data sent to the worker. This can only be structured-cloneable data.
- * @typeParam Response - Type of execution response. This can only be structured-cloneable data.
+ * Worker node tasks queue options.
  */
-interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
-    /**
-     * Adds a task function to this pool.
-     * If a task function with the same name already exists, it will be overwritten.
-     * @param name - The name of the task function.
-     * @param fn - The task function.
-     * @returns `true` if the task function was added, `false` otherwise.
-     * @throws {@link https://nodejs.org/api/errors.html#class-typeerror} If the `name` parameter is not a string or an empty string.
-     * @throws {@link https://nodejs.org/api/errors.html#class-typeerror} If the `fn` parameter is not a function or task function object.
-     */
-    readonly addTaskFunction: (name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>) => Promise<boolean>;
-    /**
-     * Terminates all workers in this pool.
-     */
-    readonly destroy: () => Promise<void>;
-    /**
-     * Pool event emitter integrated with async resource.
-     * The async tracking tooling identifier is `poolifier:<PoolType>-<WorkerType>-pool`.
-     *
-     * Events that can currently be listened to:
-     *
-     * - `'ready'`: Emitted when the number of workers created in the pool has reached the minimum size expected and are ready. If the pool is dynamic with a minimum number of workers set to zero, this event is emitted when the pool is started.
-     * - `'busy'`: Emitted when the number of workers created in the pool has reached the maximum size expected and are executing concurrently their tasks quota.
-     * - `'busyEnd'`: Emitted when the number of workers created in the pool has reached the maximum size expected and are no longer executing concurrently their tasks quota.
-     * - `'full'`: Emitted when the pool is dynamic and the number of workers created has reached the maximum size expected.
-     * - `'fullEnd'`: Emitted when the pool is dynamic and the number of workers created has no longer reached the maximum size expected.
-     * - `'empty'`: Emitted when the pool is dynamic with a minimum number of workers set to zero and the number of workers has reached the minimum size expected.
-     * - `'destroy'`: Emitted when the pool is destroyed.
-     * - `'error'`: Emitted when an uncaught error occurs.
-     * - `'taskError'`: Emitted when an error occurs while executing a task.
-     * - `'backPressure'`: Emitted when the number of workers created in the pool has reached the maximum size expected and are back pressured (i.e. their tasks queue is full: queue size \>= maximum queue size).
-     * - `'backPressureEnd'`: Emitted when the number of workers created in the pool has reached the maximum size expected and are no longer back pressured (i.e. their tasks queue is no longer full: queue size \< maximum queue size).
-     */
-    readonly emitter?: EventEmitterAsyncResource;
-    /**
-     * Enables/disables the worker node tasks queue in this pool.
-     * @param enable - Whether to enable or disable the worker node tasks queue.
-     * @param tasksQueueOptions - The worker node tasks queue options.
-     */
-    readonly enableTasksQueue: (enable: boolean, tasksQueueOptions?: TasksQueueOptions) => void;
-    /**
-     * Executes the specified function in the worker constructor with the task data input parameter.
-     * @param data - The optional task input data for the specified task function. This can only be structured-cloneable data.
-     * @param name - The optional name of the task function to execute. If not specified, the default task function will be executed.
-     * @param transferList - An optional array of transferable objects to transfer ownership of. Ownership of the transferred objects is given to the chosen pool's worker_threads worker and they should not be used in the main thread afterwards.
-     * @returns Promise with a task function response that will be fulfilled when the task is completed.
-     */
-    readonly execute: (data?: Data, name?: string, transferList?: readonly TransferListItem[]) => Promise<Response>;
-    /**
-     * Whether the specified task function exists in this pool.
-     * @param name - The name of the task function.
-     * @returns `true` if the task function exists, `false` otherwise.
-     */
-    readonly hasTaskFunction: (name: string) => boolean;
-    /**
-     * Pool information.
-     */
-    readonly info: PoolInfo;
-    /**
-     * Lists the properties of task functions available in this pool.
-     * @returns The properties of task functions available in this pool.
-     */
-    readonly listTaskFunctionsProperties: () => TaskFunctionProperties[];
-    /**
-     * Executes the specified function in the worker constructor with the tasks data iterable input parameter.
-     * @param data - The tasks iterable input data for the specified task function. This can only be an iterable of structured-cloneable data.
-     * @param name - The optional name of the task function to execute. If not specified, the default task function will be executed.
-     * @param transferList - An optional array of transferable objects to transfer ownership of. Ownership of the transferred objects is given to the chosen pool's worker_threads worker and they should not be used in the main thread afterwards.
-     * @returns Promise with an array of task function responses that will be fulfilled when the tasks are completed.
-     */
-    readonly mapExecute: (data: Iterable<Data>, name?: string, transferList?: readonly TransferListItem[]) => Promise<Response[]>;
-    /**
-     * Removes a task function from this pool.
-     * @param name - The name of the task function.
-     * @returns `true` if the task function was removed, `false` otherwise.
-     */
-    readonly removeTaskFunction: (name: string) => Promise<boolean>;
+interface TasksQueueOptions {
     /**
-     * Sets the default task function in this pool.
-     * @param name - The name of the task function.
-     * @returns `true` if the default task function was set, `false` otherwise.
+     * Maximum number of tasks that can be executed concurrently on a worker node.
+     * @defaultValue 1
      */
-    readonly setDefaultTaskFunction: (name: string) => Promise<boolean>;
+    readonly concurrency?: number;
     /**
-     * Sets the worker node tasks queue options in this pool.
-     * @param tasksQueueOptions - The worker node tasks queue options.
+     * Maximum tasks queue size per worker node flagging it as back pressured.
+     * @defaultValue (pool maximum size)^2
      */
-    readonly setTasksQueueOptions: (tasksQueueOptions: TasksQueueOptions) => void;
+    readonly size?: number;
     /**
-     * Sets the default worker choice strategy in this pool.
-     * @param workerChoiceStrategy - The default worker choice strategy.
-     * @param workerChoiceStrategyOptions - The worker choice strategy options.
+     * Queued tasks finished timeout in milliseconds at worker node termination.
+     * @defaultValue 2000
      */
-    readonly setWorkerChoiceStrategy: (workerChoiceStrategy: WorkerChoiceStrategy, workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions) => void;
+    readonly tasksFinishedTimeout?: number;
     /**
-     * Sets the worker choice strategy options in this pool.
-     * @param workerChoiceStrategyOptions - The worker choice strategy options.
-     * @returns `true` if the worker choice strategy options were set, `false` otherwise.
+     * Whether to enable tasks stealing under back pressure.
+     * @defaultValue true
      */
-    readonly setWorkerChoiceStrategyOptions: (workerChoiceStrategyOptions: WorkerChoiceStrategyOptions) => boolean;
+    readonly tasksStealingOnBackPressure?: boolean;
     /**
-     * Starts the minimum number of workers in this pool.
+     * Ratio of worker nodes that can steal tasks from another worker node.
+     * @defaultValue 0.6
      */
-    readonly start: () => void;
+    readonly tasksStealingRatio?: number;
     /**
-     * Pool worker nodes.
-     * @internal
+     * Whether to enable task stealing on idle.
+     * @defaultValue true
      */
-    readonly workerNodes: IWorkerNode<Worker, Data>[];
+    readonly taskStealing?: boolean;
 }
 
 /**
@@ -1205,6 +1311,10 @@ interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
  */
 declare class WorkerChoiceStrategiesContext<Worker extends IWorker, Data = unknown, Response = unknown> {
     private readonly pool;
+    /**
+     * The number of worker choice strategies execution retries.
+     */
+    retriesCount: number;
     /**
      * The default worker choice strategy in the context.
      */
@@ -1225,10 +1335,6 @@ declare class WorkerChoiceStrategiesContext<Worker extends IWorker, Data = unkno
      * The active worker choice strategies in the context task statistics requirements.
      */
     private workerChoiceStrategiesTaskStatisticsRequirements;
-    /**
-     * The number of worker choice strategies execution retries.
-     */
-    retriesCount: number;
     /**
      * Worker choice strategies context constructor.
      * @param pool - The pool instance.
@@ -1236,27 +1342,6 @@ declare class WorkerChoiceStrategiesContext<Worker extends IWorker, Data = unkno
      * @param opts - The worker choice strategy options.
      */
     constructor(pool: IPool<Worker, Data, Response>, workerChoiceStrategies?: WorkerChoiceStrategy[], opts?: WorkerChoiceStrategyOptions);
-    /**
-     * Adds a worker choice strategy to the context.
-     * @param workerChoiceStrategy - The worker choice strategy to add.
-     * @param pool - The pool instance.
-     * @param opts - The worker choice strategy options.
-     * @returns The worker choice strategies.
-     */
-    private addWorkerChoiceStrategy;
-    /**
-     * Executes the given worker choice strategy.
-     * @param workerChoiceStrategy - The worker choice strategy.
-     * @returns The key of the worker node.
-     * @throws {@link https://nodejs.org/api/errors.html#class-error} If after computed retries the worker node key is null or undefined.
-     */
-    private executeStrategy;
-    /**
-     * Removes a worker choice strategy from the context.
-     * @param workerChoiceStrategy - The worker choice strategy to remove.
-     * @returns `true` if the worker choice strategy is removed, `false` otherwise.
-     */
-    private removeWorkerChoiceStrategy;
     /**
      * Executes the given worker choice strategy in the context algorithm.
      * @param workerChoiceStrategy - The worker choice strategy algorithm to execute. @defaultValue this.defaultWorkerChoiceStrategy
@@ -1303,6 +1388,27 @@ declare class WorkerChoiceStrategiesContext<Worker extends IWorker, Data = unkno
      * @returns `true` if the update is successful, `false` otherwise.
      */
     update(workerNodeKey: number): boolean;
+    /**
+     * Adds a worker choice strategy to the context.
+     * @param workerChoiceStrategy - The worker choice strategy to add.
+     * @param pool - The pool instance.
+     * @param opts - The worker choice strategy options.
+     * @returns The worker choice strategies.
+     */
+    private addWorkerChoiceStrategy;
+    /**
+     * Executes the given worker choice strategy.
+     * @param workerChoiceStrategy - The worker choice strategy.
+     * @returns The key of the worker node.
+     * @throws {@link https://nodejs.org/api/errors.html#class-error} If after computed retries the worker node key is null or undefined.
+     */
+    private executeStrategy;
+    /**
+     * Removes a worker choice strategy from the context.
+     * @param workerChoiceStrategy - The worker choice strategy to remove.
+     * @returns `true` if the worker choice strategy is removed, `false` otherwise.
+     */
+    private removeWorkerChoiceStrategy;
 }
 
 /**
@@ -1316,6 +1422,12 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
     protected readonly filePath: string;
     protected readonly opts: PoolOptions<Worker>;
     protected readonly maximumNumberOfWorkers?: number | undefined;
+    /** @inheritDoc */
+    emitter?: EventEmitterAsyncResource;
+    /** @inheritDoc */
+    readonly workerNodes: IWorkerNode<Worker, Data>[];
+    /** @inheritDoc */
+    get info(): PoolInfo;
     /**
      * The task execution response promise map:
      * - `key`: The message id of each submitted task.
@@ -1329,50 +1441,37 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      */
     protected workerChoiceStrategiesContext?: WorkerChoiceStrategiesContext<Worker, Data, Response>;
     /**
-     * This method is the message listener registered on each worker.
-     * @param message - The message received from the worker.
-     */
-    protected readonly workerMessageListener: (message: MessageValue<Response>) => void;
-    /**
-     * Whether the pool back pressure event has been emitted or not.
+     * Whether the pool is back pressured or not.
+     * @returns The pool back pressure boolean status.
      */
-    private backPressureEventEmitted;
+    protected abstract get backPressure(): boolean;
     /**
-     * Whether the pool busy event has been emitted or not.
+     * Whether the pool is busy or not.
+     * @returns The pool busyness boolean status.
      */
-    private busyEventEmitted;
+    protected abstract get busy(): boolean;
     /**
-     * Whether the pool is destroying or not.
+     * The pool type.
+     *
+     * If it is `'dynamic'`, it provides the `max` property.
      */
-    private destroying;
+    protected abstract get type(): PoolType;
     /**
-     * Gets task function worker choice strategy, if any.
-     * @param name - The task function name.
-     * @returns The task function worker choice strategy if the task function worker choice strategy is defined, `undefined` otherwise.
+     * The worker type.
      */
-    private readonly getTaskFunctionWorkerChoiceStrategy;
+    protected abstract get worker(): WorkerType;
     /**
-     * Gets the worker choice strategies registered in this pool.
-     * @returns The worker choice strategies.
+     * Whether the pool back pressure event has been emitted or not.
      */
-    private readonly getWorkerChoiceStrategies;
+    private backPressureEventEmitted;
     /**
-     * Gets worker node task function priority, if any.
-     * @param workerNodeKey - The worker node key.
-     * @param name - The task function name.
-     * @returns The worker node task function priority if the worker node task function priority is defined, `undefined` otherwise.
+     * Whether the pool busy event has been emitted or not.
      */
-    private readonly getWorkerNodeTaskFunctionPriority;
+    private busyEventEmitted;
     /**
-     * Gets worker node task function worker choice strategy, if any.
-     * @param workerNodeKey - The worker node key.
-     * @param name - The task function name.
-     * @returns The worker node task function worker choice strategy if the worker node task function worker choice strategy is defined, `undefined` otherwise.
+     * Whether the pool is destroying or not.
      */
-    private readonly getWorkerNodeTaskFunctionWorkerChoiceStrategy;
-    private readonly handleWorkerNodeBackPressureEvent;
-    private readonly handleWorkerNodeIdleEvent;
-    private readonly isStealingRatioReached;
+    private destroying;
     /**
      * Whether the pool ready event has been emitted or not.
      */
@@ -1393,18 +1492,22 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      * The start timestamp of the pool.
      */
     private startTimestamp?;
-    private readonly stealTask;
     /**
      * The task functions added at runtime map:
      * - `key`: The task function name.
      * - `value`: The task function object.
      */
     private readonly taskFunctions;
-    private readonly workerNodeStealTask;
-    /** @inheritDoc */
-    emitter?: EventEmitterAsyncResource;
-    /** @inheritDoc */
-    readonly workerNodes: IWorkerNode<Worker, Data>[];
+    /**
+     * Whether the pool is ready or not.
+     * @returns The pool readiness boolean status.
+     */
+    private get ready();
+    /**
+     * The approximate pool utilization.
+     * @returns The pool utilization.
+     */
+    private get utilization();
     /**
      * Constructs a new poolifier pool.
      * @param minimumNumberOfWorkers - Minimum number of workers that this pool manages.
@@ -1413,6 +1516,32 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      * @param maximumNumberOfWorkers - Maximum number of workers that this pool manages.
      */
     constructor(minimumNumberOfWorkers: number, filePath: string, opts: PoolOptions<Worker>, maximumNumberOfWorkers?: number | undefined);
+    /** @inheritDoc */
+    addTaskFunction(name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>): Promise<boolean>;
+    /** @inheritDoc */
+    destroy(): Promise<void>;
+    /** @inheritDoc */
+    enableTasksQueue(enable: boolean, tasksQueueOptions?: TasksQueueOptions): void;
+    /** @inheritDoc */
+    execute(data?: Data, name?: string, abortSignal?: AbortSignal, transferList?: readonly Transferable[]): Promise<Response>;
+    /** @inheritDoc */
+    hasTaskFunction(name: string): boolean;
+    /** @inheritDoc */
+    listTaskFunctionsProperties(): TaskFunctionProperties[];
+    /** @inheritDoc */
+    mapExecute(data: Iterable<Data>, name?: string, abortSignals?: Iterable<AbortSignal>, transferList?: readonly Transferable[]): Promise<Response[]>;
+    /** @inheritDoc */
+    removeTaskFunction(name: string): Promise<boolean>;
+    /** @inheritDoc */
+    setDefaultTaskFunction(name: string): Promise<boolean>;
+    /** @inheritDoc */
+    setTasksQueueOptions(tasksQueueOptions: TasksQueueOptions | undefined): void;
+    /** @inheritDoc */
+    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy, workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions): void;
+    /** @inheritDoc */
+    setWorkerChoiceStrategyOptions(workerChoiceStrategyOptions: undefined | WorkerChoiceStrategyOptions): boolean;
+    /** @inheritdoc */
+    start(): void;
     /**
      * Hook executed after the worker task execution.
      * Can be overridden.
@@ -1508,7 +1637,7 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      * @param message - The message.
      * @param transferList - The optional array of transferable objects.
      */
-    protected abstract sendToWorker(workerNodeKey: number, message: MessageValue<Data>, transferList?: readonly TransferListItem[]): void;
+    protected abstract sendToWorker(workerNodeKey: number, message: MessageValue<Data>, transferList?: readonly Transferable[]): void;
     /**
      * Setup hook to execute code before worker nodes are created in the abstract constructor.
      * Can be overridden.
@@ -1519,6 +1648,12 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      * @returns Whether to create a dynamic worker or not.
      */
     protected abstract shallCreateDynamicWorker(): boolean;
+    /**
+     * This method is the message listener registered on each worker.
+     * @param message - The message received from the worker.
+     */
+    protected readonly workerMessageListener: (message: MessageValue<Response>) => void;
+    private readonly abortTask;
     /**
      * Adds the given worker node in the pool worker nodes.
      * @param workerNode - The worker node.
@@ -1563,16 +1698,44 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      */
     private executeTask;
     private flushTasksQueues;
+    private readonly getAbortError;
+    /**
+     * Gets task function worker choice strategy, if any.
+     * @param name - The task function name.
+     * @returns The task function worker choice strategy if the task function worker choice strategy is defined, `undefined` otherwise.
+     */
+    private readonly getTaskFunctionWorkerChoiceStrategy;
     private getTasksQueuePriority;
+    /**
+     * Gets the worker choice strategies registered in this pool.
+     * @returns The worker choice strategies.
+     */
+    private readonly getWorkerChoiceStrategies;
     /**
      * Gets the worker node key given its worker id.
      * @param workerId - The worker id.
      * @returns The worker node key if the worker id is found in the pool worker nodes, `-1` otherwise.
      */
     private getWorkerNodeKeyByWorkerId;
+    /**
+     * Gets worker node task function priority, if any.
+     * @param workerNodeKey - The worker node key.
+     * @param name - The task function name.
+     * @returns The worker node task function priority if the worker node task function priority is defined, `undefined` otherwise.
+     */
+    private readonly getWorkerNodeTaskFunctionPriority;
+    /**
+     * Gets worker node task function worker choice strategy, if any.
+     * @param workerNodeKey - The worker node key.
+     * @param name - The task function name.
+     * @returns The worker node task function worker choice strategy if the worker node task function worker choice strategy is defined, `undefined` otherwise.
+     */
+    private readonly getWorkerNodeTaskFunctionWorkerChoiceStrategy;
     private handleTask;
     private handleTaskExecutionResponse;
-    private handleWorkerError;
+    private readonly handleWorkerError;
+    private readonly handleWorkerNodeBackPressureEvent;
+    private readonly handleWorkerNodeIdleEvent;
     private handleWorkerReadyResponse;
     private initEventEmitter;
     /**
@@ -1581,6 +1744,7 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      */
     private initWorkerNodeUsage;
     private internalExecute;
+    private readonly isStealingRatioReached;
     private isWorkerNodeBackPressured;
     private isWorkerNodeBusy;
     private isWorkerNodeIdle;
@@ -1616,69 +1780,13 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      * @param initWorkerNodeUsage - Whether to initialize the worker node usage or not. @defaultValue false
      */
     private startMinimumNumberOfWorkers;
+    private readonly stealTask;
     private tasksQueueSize;
     private unsetTasksStealingOnBackPressure;
     private unsetTaskStealing;
     private updateTaskSequentiallyStolenStatisticsWorkerUsage;
     private updateTaskStolenStatisticsWorkerUsage;
-    /** @inheritDoc */
-    addTaskFunction(name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>): Promise<boolean>;
-    /** @inheritDoc */
-    destroy(): Promise<void>;
-    /** @inheritDoc */
-    enableTasksQueue(enable: boolean, tasksQueueOptions?: TasksQueueOptions): void;
-    /** @inheritDoc */
-    execute(data?: Data, name?: string, transferList?: readonly TransferListItem[]): Promise<Response>;
-    /** @inheritDoc */
-    hasTaskFunction(name: string): boolean;
-    /** @inheritDoc */
-    listTaskFunctionsProperties(): TaskFunctionProperties[];
-    /** @inheritDoc */
-    mapExecute(data: Iterable<Data>, name?: string, transferList?: readonly TransferListItem[]): Promise<Response[]>;
-    /** @inheritDoc */
-    removeTaskFunction(name: string): Promise<boolean>;
-    /** @inheritDoc */
-    setDefaultTaskFunction(name: string): Promise<boolean>;
-    /** @inheritDoc */
-    setTasksQueueOptions(tasksQueueOptions: TasksQueueOptions | undefined): void;
-    /** @inheritDoc */
-    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy, workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions): void;
-    /** @inheritDoc */
-    setWorkerChoiceStrategyOptions(workerChoiceStrategyOptions: undefined | WorkerChoiceStrategyOptions): boolean;
-    /** @inheritdoc */
-    start(): void;
-    /**
-     * Whether the pool is back pressured or not.
-     * @returns The pool back pressure boolean status.
-     */
-    protected abstract get backPressure(): boolean;
-    /**
-     * Whether the pool is busy or not.
-     * @returns The pool busyness boolean status.
-     */
-    protected abstract get busy(): boolean;
-    /** @inheritDoc */
-    get info(): PoolInfo;
-    /**
-     * Whether the pool is ready or not.
-     * @returns The pool readiness boolean status.
-     */
-    private get ready();
-    /**
-     * The pool type.
-     *
-     * If it is `'dynamic'`, it provides the `max` property.
-     */
-    protected abstract get type(): PoolType;
-    /**
-     * The approximate pool utilization.
-     * @returns The pool utilization.
-     */
-    private get utilization();
-    /**
-     * The worker type.
-     */
-    protected abstract get worker(): WorkerType;
+    private readonly workerNodeStealTask;
 }
 
 /**
@@ -1693,6 +1801,14 @@ type ClusterPoolOptions = PoolOptions<Worker>;
  * @since 2.0.0
  */
 declare class FixedClusterPool<Data = unknown, Response = unknown> extends AbstractPool<Worker, Data, Response> {
+    /** @inheritDoc */
+    protected get backPressure(): boolean;
+    /** @inheritDoc */
+    protected get busy(): boolean;
+    /** @inheritDoc */
+    protected get type(): PoolType;
+    /** @inheritDoc */
+    protected get worker(): WorkerType;
     /**
      * Constructs a new poolifier fixed cluster pool.
      * @param numberOfWorkers - Number of workers for this pool.
@@ -1720,15 +1836,7 @@ declare class FixedClusterPool<Data = unknown, Response = unknown> extends Abstr
     /** @inheritDoc */
     protected setupHook(): void;
     /** @inheritDoc */
-    protected shallCreateDynamicWorker(): boolean;
-    /** @inheritDoc */
-    protected get backPressure(): boolean;
-    /** @inheritDoc */
-    protected get busy(): boolean;
-    /** @inheritDoc */
-    protected get type(): PoolType;
-    /** @inheritDoc */
-    protected get worker(): WorkerType;
+    protected shallCreateDynamicWorker(): boolean;
 }
 
 /**
@@ -1742,6 +1850,12 @@ declare class FixedClusterPool<Data = unknown, Response = unknown> extends Abstr
  * @since 2.0.0
  */
 declare class DynamicClusterPool<Data = unknown, Response = unknown> extends FixedClusterPool<Data, Response> {
+    /** @inheritDoc */
+    protected get backPressure(): boolean;
+    /** @inheritDoc */
+    protected get busy(): boolean;
+    /** @inheritDoc */
+    protected get type(): PoolType;
     /**
      * Whether the pool empty event has been emitted or not
      */
@@ -1750,6 +1864,16 @@ declare class DynamicClusterPool<Data = unknown, Response = unknown> extends Fix
      * Whether the pool full event has been emitted or not.
      */
     private fullEventEmitted;
+    /**
+     * Whether the pool is empty or not.
+     * @returns The pool emptiness boolean status.
+     */
+    private get empty();
+    /**
+     * Whether the pool is full or not.
+     * @returns The pool fullness boolean status.
+     */
+    private get full();
     /**
      * Constructs a new poolifier dynamic cluster pool.
      * @param min - Minimum number of workers which are always active.
@@ -1764,22 +1888,6 @@ declare class DynamicClusterPool<Data = unknown, Response = unknown> extends Fix
     protected checkAndEmitDynamicWorkerDestructionEvents(): void;
     /** @inheritDoc */
     protected shallCreateDynamicWorker(): boolean;
-    /** @inheritDoc */
-    protected get backPressure(): boolean;
-    /** @inheritDoc */
-    protected get busy(): boolean;
-    /**
-     * Whether the pool is empty or not.
-     * @returns The pool emptiness boolean status.
-     */
-    private get empty();
-    /**
-     * Whether the pool is full or not.
-     * @returns The pool fullness boolean status.
-     */
-    private get full();
-    /** @inheritDoc */
-    protected get type(): PoolType;
 }
 
 /**
@@ -1794,6 +1902,14 @@ type ThreadPoolOptions = PoolOptions<Worker$1>;
  * @since 0.0.1
  */
 declare class FixedThreadPool<Data = unknown, Response = unknown> extends AbstractPool<Worker$1, Data, Response> {
+    /** @inheritDoc */
+    protected get backPressure(): boolean;
+    /** @inheritDoc */
+    protected get busy(): boolean;
+    /** @inheritDoc */
+    protected get type(): PoolType;
+    /** @inheritDoc */
+    protected get worker(): WorkerType;
     /**
      * Constructs a new poolifier fixed thread pool.
      * @param numberOfThreads - Number of threads for this pool.
@@ -1817,17 +1933,9 @@ declare class FixedThreadPool<Data = unknown, Response = unknown> extends Abstra
     /** @inheritDoc */
     protected sendStartupMessageToWorker(workerNodeKey: number): void;
     /** @inheritDoc */
-    protected sendToWorker(workerNodeKey: number, message: MessageValue<Data>, transferList?: readonly TransferListItem[]): void;
+    protected sendToWorker(workerNodeKey: number, message: MessageValue<Data>, transferList?: readonly Transferable[]): void;
     /** @inheritDoc */
     protected shallCreateDynamicWorker(): boolean;
-    /** @inheritDoc */
-    protected get backPressure(): boolean;
-    /** @inheritDoc */
-    protected get busy(): boolean;
-    /** @inheritDoc */
-    protected get type(): PoolType;
-    /** @inheritDoc */
-    protected get worker(): WorkerType;
 }
 
 /**
@@ -1841,6 +1949,12 @@ declare class FixedThreadPool<Data = unknown, Response = unknown> extends Abstra
  * @since 0.0.1
  */
 declare class DynamicThreadPool<Data = unknown, Response = unknown> extends FixedThreadPool<Data, Response> {
+    /** @inheritDoc */
+    protected get backPressure(): boolean;
+    /** @inheritDoc */
+    protected get busy(): boolean;
+    /** @inheritDoc */
+    protected get type(): PoolType;
     /**
      * Whether the pool empty event has been emitted or not
      */
@@ -1849,6 +1963,16 @@ declare class DynamicThreadPool<Data = unknown, Response = unknown> extends Fixe
      * Whether the pool full event has been emitted or not.
      */
     private fullEventEmitted;
+    /**
+     * Whether the pool is empty or not.
+     * @returns The pool emptiness boolean status.
+     */
+    private get empty();
+    /**
+     * Whether the pool is full or not.
+     * @returns The pool fullness boolean status.
+     */
+    private get full();
     /**
      * Constructs a new poolifier dynamic thread pool.
      * @param min - Minimum number of threads which are always active.
@@ -1863,87 +1987,6 @@ declare class DynamicThreadPool<Data = unknown, Response = unknown> extends Fixe
     protected checkAndEmitDynamicWorkerDestructionEvents(): void;
     /** @inheritDoc */
     protected shallCreateDynamicWorker(): boolean;
-    /** @inheritDoc */
-    protected get backPressure(): boolean;
-    /** @inheritDoc */
-    protected get busy(): boolean;
-    /**
-     * Whether the pool is empty or not.
-     * @returns The pool emptiness boolean status.
-     */
-    private get empty();
-    /**
-     * Whether the pool is full or not.
-     * @returns The pool fullness boolean status.
-     */
-    private get full();
-    /** @inheritDoc */
-    protected get type(): PoolType;
-}
-
-/**
- * Priority queue.
- * @typeParam T - Type of priority queue data.
- * @internal
- */
-declare class PriorityQueue<T> {
-    private readonly bucketSize;
-    private head;
-    private priorityEnabled;
-    private tail;
-    /** The priority queue maximum size. */
-    maxSize: number;
-    /**
-     * Constructs a priority queue.
-     * @param bucketSize - Prioritized bucket size. @defaultValue defaultBucketSize
-     * @param enablePriority - Whether to enable priority. @defaultValue false
-     * @returns PriorityQueue.
-     */
-    constructor(bucketSize?: number, enablePriority?: boolean);
-    private getPriorityQueueNode;
-    /**
-     * Clears the priority queue.
-     */
-    clear(): void;
-    /**
-     * Dequeue data from the priority queue.
-     * @param bucket - The prioritized bucket to dequeue from.
-     * @returns The dequeued data or `undefined` if the priority queue is empty.
-     */
-    dequeue(bucket?: number): T | undefined;
-    /**
-     * Enqueue data into the priority queue.
-     * @param data - Data to enqueue.
-     * @param priority - Priority of the data. Lower values have higher priority.
-     * @returns The new size of the priority queue.
-     */
-    enqueue(data: T, priority?: number): number;
-    /**
-     * Returns an iterator for the priority queue.
-     * @returns An iterator for the priority queue.
-     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
-     */
-    [Symbol.iterator](): Iterator<T>;
-    /**
-     * The number of filled prioritized buckets.
-     * @returns The number of filled prioritized buckets.
-     */
-    get buckets(): number;
-    /**
-     * Whether priority is enabled.
-     * @returns Whether priority is enabled.
-     */
-    get enablePriority(): boolean;
-    /**
-     * Enables/disables priority.
-     * @param enablePriority - Whether to enable priority.
-     */
-    set enablePriority(enablePriority: boolean);
-    /**
-     * The priority queue size.
-     * @returns The priority queue size.
-     */
-    get size(): number;
 }
 
 /**
@@ -1973,6 +2016,12 @@ interface IFixedQueue<T> {
      * Clears the fixed queue.
      */
     clear: () => void;
+    /**
+     * Deletes the given data from the fixed priority queue.
+     * @param data - Data to delete.
+     * @returns `true` if the data was deleted, `false` otherwise.
+     */
+    delete: (data: T) => boolean;
     /**
      * Dequeue data from the fixed queue.
      * @returns The dequeued data or `undefined` if the fixed queue is empty.
@@ -2021,7 +2070,7 @@ declare const availableParallelism: () => number;
  * @typeParam Data - Type of data this worker receives from pool's execution. This can only be structured-cloneable data.
  * @typeParam Response - Type of response the worker sends back to the main worker. This can only be structured-cloneable data.
  */
-declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, Data = unknown, Response = unknown> {
+declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, Data = unknown, Response = unknown> extends EventEmitter {
     protected readonly isMain: boolean | undefined;
     private readonly mainWorker;
     protected opts: WorkerOptions;
@@ -2032,32 +2081,19 @@ declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, D
     /**
      * Worker id.
      */
-    protected abstract id: number;
+    protected abstract readonly id: number;
     /**
      * Timestamp of the last task processed by this worker.
      */
     protected lastTaskTimestamp: number;
-    /**
-     * Runs the given task.
-     * @param task - The task to execute.
-     */
-    protected readonly run: (task: Task<Data>) => void;
-    /**
-     * Runs the given task function asynchronously.
-     * @param fn - Task function that will be executed.
-     * @param task - Input data for the task function.
-     */
-    protected readonly runAsync: (fn: TaskAsyncFunction<Data, Response>, task: Task<Data>) => void;
-    /**
-     * Runs the given task function synchronously.
-     * @param fn - Task function that will be executed.
-     * @param task - Input data for the task function.
-     */
-    protected readonly runSync: (fn: TaskSyncFunction<Data, Response>, task: Task<Data>) => void;
     /**
      * Performance statistics computation requirements.
      */
     protected statistics?: WorkerStatistics;
+    /**
+     * Task abort functions processed by the worker when task operation 'abort' is received.
+     */
+    protected taskAbortFunctions: Map<`${string}-${string}-${string}-${string}-${string}`, () => void>;
     /**
      * Task function object(s) processed by the worker when the pool's `execute` method is invoked.
      */
@@ -2070,6 +2106,37 @@ declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, D
      * @param opts - Options for the worker.
      */
     constructor(isMain: boolean | undefined, mainWorker: MainWorker | null | undefined, taskFunctions: TaskFunction<Data, Response> | TaskFunctions<Data, Response>, opts?: WorkerOptions);
+    /**
+     * Adds a task function to the worker.
+     * If a task function with the same name already exists, it is replaced.
+     * @param name - The name of the task function to add.
+     * @param fn - The task function to add.
+     * @returns Whether the task function was added or not.
+     */
+    addTaskFunction(name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>): TaskFunctionOperationResult;
+    /**
+     * Checks if the worker has a task function with the given name.
+     * @param name - The name of the task function to check.
+     * @returns Whether the worker has a task function with the given name or not.
+     */
+    hasTaskFunction(name: string): TaskFunctionOperationResult;
+    /**
+     * Lists the properties of the worker's task functions.
+     * @returns The properties of the worker's task functions.
+     */
+    listTaskFunctionsProperties(): TaskFunctionProperties[];
+    /**
+     * Removes a task function from the worker.
+     * @param name - The name of the task function to remove.
+     * @returns Whether the task function existed and was removed or not.
+     */
+    removeTaskFunction(name: string): TaskFunctionOperationResult;
+    /**
+     * Sets the default task function to use in the worker.
+     * @param name - The name of the task function to use as default task function.
+     * @returns Whether the default task function was set or not.
+     */
+    setDefaultTaskFunction(name: string): TaskFunctionOperationResult;
     /**
      * Returns the main worker.
      * @returns Reference to the main worker.
@@ -2082,6 +2149,7 @@ declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, D
      * @returns The worker error object.
      */
     protected abstract handleError(error: Error): {
+        aborted: boolean;
         error?: Error;
         message: string;
         stack?: string;
@@ -2102,6 +2170,23 @@ declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, D
      * @param message - The received message.
      */
     protected messageListener(message: MessageValue<Data>): void;
+    /**
+     * Runs the given task.
+     * @param task - The task to execute.
+     */
+    protected readonly run: (task: Task<Data>) => void;
+    /**
+     * Runs the given task function asynchronously.
+     * @param fn - Task function that will be executed.
+     * @param task - Input data for the task function.
+     */
+    protected readonly runAsync: (fn: TaskAsyncFunction<Data, Response>, task: Task<Data>) => void;
+    /**
+     * Runs the given task function synchronously.
+     * @param fn - Task function that will be executed.
+     * @param task - Input data for the task function.
+     */
+    protected readonly runSync: (fn: TaskSyncFunction<Data, Response>, task: Task<Data>) => void;
     /**
      * Sends task functions properties to the main worker.
      */
@@ -2129,6 +2214,14 @@ declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, D
     private checkTaskFunctions;
     private checkWorkerOptions;
     private endTaskPerformance;
+    /**
+     * Gets abortable task function.
+     * An abortable promise is built to permit the task to be aborted.
+     * @param name - The name of the task.
+     * @param taskId - The task id.
+     * @returns The abortable task function.
+     */
+    private getAbortableTaskFunction;
     /**
      * Starts the worker check active interval.
      */
@@ -2138,37 +2231,6 @@ declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, D
      */
     private stopCheckActive;
     private updateLastTaskTimestamp;
-    /**
-     * Adds a task function to the worker.
-     * If a task function with the same name already exists, it is replaced.
-     * @param name - The name of the task function to add.
-     * @param fn - The task function to add.
-     * @returns Whether the task function was added or not.
-     */
-    addTaskFunction(name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>): TaskFunctionOperationResult;
-    /**
-     * Checks if the worker has a task function with the given name.
-     * @param name - The name of the task function to check.
-     * @returns Whether the worker has a task function with the given name or not.
-     */
-    hasTaskFunction(name: string): TaskFunctionOperationResult;
-    /**
-     * Lists the properties of the worker's task functions.
-     * @returns The properties of the worker's task functions.
-     */
-    listTaskFunctionsProperties(): TaskFunctionProperties[];
-    /**
-     * Removes a task function from the worker.
-     * @param name - The name of the task function to remove.
-     * @returns Whether the task function existed and was removed or not.
-     */
-    removeTaskFunction(name: string): TaskFunctionOperationResult;
-    /**
-     * Sets the default task function to use in the worker.
-     * @param name - The name of the task function to use as default task function.
-     * @returns Whether the default task function was set or not.
-     */
-    setDefaultTaskFunction(name: string): TaskFunctionOperationResult;
 }
 
 /**
@@ -2186,7 +2248,7 @@ declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, D
  */
 declare class ClusterWorker<Data = unknown, Response = unknown> extends AbstractWorker<Worker, Data, Response> {
     /** @inheritDoc */
-    protected readonly sendToMainWorker: (message: MessageValue<Response>) => void;
+    protected get id(): number;
     /**
      * Constructs a new poolifier cluster worker.
      * @param taskFunctions - Task function(s) processed by the worker when the pool's `execute` method is invoked.
@@ -2197,13 +2259,14 @@ declare class ClusterWorker<Data = unknown, Response = unknown> extends Abstract
      * @inheritDoc
      */
     protected handleError(error: Error): {
+        aborted: boolean;
         message: string;
         stack?: string;
     };
     /** @inheritDoc */
     protected handleReadyMessage(message: MessageValue<Data>): void;
     /** @inheritDoc */
-    protected get id(): number;
+    protected readonly sendToMainWorker: (message: MessageValue<Response>) => void;
 }
 
 /**
@@ -2221,7 +2284,7 @@ declare class ClusterWorker<Data = unknown, Response = unknown> extends Abstract
  */
 declare class ThreadWorker<Data = unknown, Response = unknown> extends AbstractWorker<MessagePort, Data, Response> {
     /** @inheritDoc */
-    protected readonly sendToMainWorker: (message: MessageValue<Response>) => void;
+    protected get id(): number;
     /**
      * Message port used to communicate with the main worker.
      */
@@ -2236,6 +2299,7 @@ declare class ThreadWorker<Data = unknown, Response = unknown> extends AbstractW
      * @inheritDoc
      */
     protected handleError(error: Error): {
+        aborted: boolean;
         error: Error;
         message: string;
         stack?: string;
@@ -2245,7 +2309,8 @@ declare class ThreadWorker<Data = unknown, Response = unknown> extends AbstractW
     /** @inheritDoc */
     protected handleReadyMessage(message: MessageValue<Data>): void;
     /** @inheritDoc */
-    protected get id(): number;
+    protected readonly sendToMainWorker: (message: MessageValue<Response>) => void;
 }
 
-export { AbstractPool, AbstractWorker, CircularBuffer, type ClusterPoolOptions, ClusterWorker, DynamicClusterPool, DynamicThreadPool, type ErrorHandler, type EventHandler, type EventLoopUtilizationMeasurementStatistics, type ExitHandler, FixedClusterPool, type FixedQueueNode, FixedThreadPool, type IFixedQueue, type IPool, type IWorker, type IWorkerChoiceStrategy, type IWorkerNode, type KillBehavior, KillBehaviors, type KillHandler, type Measurement, type MeasurementOptions, type MeasurementStatistics, type MeasurementStatisticsRequirements, Measurements, type MessageHandler, type MessageValue, type OnlineHandler, type PoolEvent, PoolEvents, type PoolInfo, type PoolOptions, type PoolType, PoolTypes, PriorityQueue, type PromiseResponseWrapper, type StrategyData, type StrategyPolicy, type Task, type TaskAsyncFunction, type TaskFunction, type TaskFunctionObject, type TaskFunctionOperationResult, type TaskFunctionProperties, type TaskFunctions, type TaskPerformance, type TaskStatistics, type TaskStatisticsRequirements, type TaskSyncFunction, type TasksQueueOptions, type ThreadPoolOptions, ThreadWorker, WorkerChoiceStrategies, WorkerChoiceStrategiesContext, type WorkerChoiceStrategy, type WorkerChoiceStrategyOptions, type WorkerError, type WorkerInfo, type WorkerNodeEventDetail, type WorkerNodeOptions, type WorkerOptions, type WorkerStatistics, type WorkerType, WorkerTypes, type WorkerUsage, type Writable, availableParallelism };
+export { AbstractPool, AbstractWorker, CircularBuffer, ClusterWorker, DynamicClusterPool, DynamicThreadPool, FixedClusterPool, FixedThreadPool, KillBehaviors, Measurements, PoolEvents, PoolTypes, PriorityQueue, ThreadWorker, WorkerChoiceStrategies, WorkerChoiceStrategiesContext, WorkerTypes, availableParallelism };
+export type { ClusterPoolOptions, ErrorHandler, EventHandler, EventLoopUtilizationMeasurementStatistics, ExitHandler, FixedQueueNode, IFixedQueue, IPool, IWorker, IWorkerChoiceStrategy, IWorkerNode, KillBehavior, KillHandler, Measurement, MeasurementOptions, MeasurementStatistics, MeasurementStatisticsRequirements, MessageHandler, MessageValue, OnlineHandler, PoolEvent, PoolInfo, PoolOptions, PoolType, PromiseResponseWrapper, StrategyData, StrategyPolicy, Task, TaskAsyncFunction, TaskFunction, TaskFunctionObject, TaskFunctionOperationResult, TaskFunctionProperties, TaskFunctions, TaskPerformance, TaskStatistics, TaskStatisticsRequirements, TaskSyncFunction, TasksQueueOptions, ThreadPoolOptions, WorkerChoiceStrategy, WorkerChoiceStrategyOptions, WorkerError, WorkerInfo, WorkerNodeEventDetail, WorkerNodeOptions, WorkerOptions, WorkerStatistics, WorkerType, WorkerUsage, Writable };