nestworker 1.1.20 → 2.0.4

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Vahe Hakobyan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,143 +1,334 @@
-![](https://img.shields.io/badge/dependencies-none-brightgreen.svg)
-![](https://img.shields.io/npm/dt/nestworker.svg)
-![](https://img.shields.io/npm/v/nestworker.svg)
-![](https://img.shields.io/npm/l/nestworker.svg)
-![](https://img.shields.io/github/issues/VaheHak/nestworker.svg)
-![](https://img.shields.io/github/contributors/VaheHak/nestworker.svg)
-![](https://img.shields.io/github/last-commit/VaheHak/nestworker.svg)
-![](https://img.shields.io/github/forks/VaheHak/nestworker.svg)
-![](https://img.shields.io/github/stars/VaheHak/nestworker.svg)
-![](https://img.shields.io/github/watchers/VaheHak/nestworker.svg)
-
-
-# nestworker
-A simple library that provides an abstraction for the Node.js `worker_threads` module. You can run your function in a dedicated thread by working with Promises.
-
-### Example
-```ts
-import { executeInThread } from 'nestworker';
-
-async function calculate(): Promise<void> {
-  const values = await Promise.all([
-    executeInThread(() => 2 ** 10), // this doesn't block the main thread
-    executeInThread(() => 3 ** 10),
-  ]);
-
-  console.log(values); // [1024, 59049]
-}
-
-calculate();
-```
-
-This example demonstrates the optimization of two resource-intensive calculations through parallel execution in distinct threads.
-By distributing the tasks across separate threads, significant time savings are achieved.
-
-Nestworker's takes a task function as its parameter, orchestrates its execution in a new thread, and subsequently delivers a Promise.
-
-**Surprisingly simple, isn't it?**
-
-## Installation
-
-```shell
-$ npm i nestworker
-```
-
-## All examples:
-- [Basic example](https://github.com/VaheHak/nestworker/tree/master/examples/basic.ts)
-- [Parameters for the thread task](https://github.com/VaheHak/nestworker/blob/master/examples/multi-params.ts)
-- [Async function inside the thread](https://github.com/VaheHak/nestworker/blob/master/examples/async-task.ts)
-- [Error handling](https://github.com/VaheHak/nestworker/blob/master/examples/error-handling.ts)
-- [Use modules inside the thread](https://github.com/VaheHak/nestworker/blob/master/examples/modules-in-thread.ts)
-
-## API
-
-### `executeInThread(task, { args: any[] }`
-Runs the specified function in a separate thread.
-
-#### Parameters
-- `Task (Function)`: The function to be executed in a thread.
-    - This can also be a async function (promise).
-- `...params (Any)`: Additional arguments to be passed to the Task function.
-    - Parameter cann't be a function.
-
-```ts
-const task = function(a: number, b: object, c: boolean) { ... };
-executeInThread(task, { args: [1, {}, true] })
-```
-
-The `executeInThread` function allows you to execute a given task function in a dedicated thread, similar to the behavior of `setTimeout` or `setInterval`. You provide the main function to be executed, along with any additional arguments (...args) that should be passed to the given function.
-
-#### Returns
-`Promise<any>`: A Promise that resolves with the return value of the callback.
-
-Inside the provided function, you have the flexibility to return any value, including a Promise. The returned value, whether it's a standard value or a Promise, will be passed back to you as the resolved result of the `Promise` returned by the `executeInThread` function.
-
-```ts
-const number = await executeInThread(() => 123); // 123
-const name = await executeInThread(() => Promise.resolve('John')); // John
-```
-
-#### Important (limitation)
-
-Access to data outside of the task function is restricted. If you require the use of a module, it should be required within the task function. The sole method for accessing data within a task function from external sources is through the utilization of the parameters. Closures do not function in this context.
-
-In this example, we're reading a file in a separate thread and returning the data in string format. We start by defining a task function that will run within the thread, and then we prepare the necessary parameters to be passed as inputs to that function.
-
-```ts
-import { executeInThread } from 'nestworker';
-
-async function task(filename: string) {
-// Closure doesn't work here
-  const { readFile } = await import('fs/promises');
-  const content = await readFile(filename);
-  return content.toString();
-}
-
-async function read() {
-  const content = await executeInThread(task, { args: [filename] });
-  console.log(content);
-}
-
-read();
-```
-
-There is also another option if you don't want to use `import` inside the function.
-
-```ts
-import { executeInThread } from 'nestworker';
-
-// this will be executed in a dedicated thread
-async function task(modules: { 'fs/promises': typeof import('fs/promises') }) {
-  // Closure doesn't work here
-  const { readFile } = modules['fs/promises'];
-
-  const content = await readFile(__filename);
-
-  return content.toString();
-}
-
-async function read() {
-  const content = await executeInThread(task, {
-    threadModules: ['fs/promises'],
-  });
-
-  console.log(content);
-}
-
-read();
-```
-
-The `threadModules` parameter is an array of strings that represent the `modules` you want to use in the thread.
-The `modules` will be imported and passed to the task function `first argument` as an object.
-
-## Contributing
-
-See the [contributing guide](https://github.com/VaheHak/nestworker/blob/master/CONTRIBUTING.md) for detailed instructions on how to get started with our project.
-
-## Author
-
-Vahe Hakobyan: [Telegram](https://t.me/vahe_hak)
-
-## License
-
-Licensed under [MIT](https://github.com/VaheHak/nestworker/blob/master/LICENSE).
+![](https://img.shields.io/badge/dependencies-none-brightgreen.svg)
+![](https://img.shields.io/npm/dt/nestworker.svg)
+![](https://img.shields.io/npm/v/nestworker.svg)
+![](https://img.shields.io/npm/l/nestworker.svg)
+![](https://img.shields.io/github/issues/VaheHak/nestworker.svg)
+![](https://img.shields.io/github/contributors/VaheHak/nestworker.svg)
+![](https://img.shields.io/github/last-commit/VaheHak/nestworker.svg)
+![](https://img.shields.io/github/forks/VaheHak/nestworker.svg)
+![](https://img.shields.io/github/stars/VaheHak/nestworker.svg)
+![](https://img.shields.io/github/watchers/VaheHak/nestworker.svg)
+
+<p align="center">
+  <img src="icon.svg" width="120" alt="nestworker" />
+</p>
+
+# nestworker
+
+Enterprise-grade worker thread module for NestJS. Offload CPU-bound work to a managed pool of Node.js worker threads without blocking the event loop — with decorator-driven auto-discovery, priority queuing, and transparent NestJS dependency injection inside workers.
+
+---
+
+## Features
+
+- **Worker pool** — pre-spawned threads with backpressure queue; no jobs are ever dropped
+- **Priority queue** — `HIGH / NORMAL / LOW`, binary-search sorted
+- **Decorator discovery** — `@WorkerClass` + `@WorkerTask` replace all manual registration
+- **DI in workers** — declared deps are snapshotted and reconstructed in each thread
+- **Dynamic imports** — use `await import('node:os')` inside task methods
+- **Per-task timeout** — configurable via decorator or overridden per call
+- **Safe shutdown** — drains queue, terminates workers with a 2-second deadline
+
+---
+
+## Requirements
+
+| Package | Version |
+|---|---|
+| Node.js | ≥ 16 (worker_threads) |
+| `@nestjs/common` | `^10` or `^11` |
+| `@nestjs/core` | `^10` or `^11` |
+| `reflect-metadata` | `^0.1` or `^0.2` |
+| TypeScript `target` | `ES2022` or higher |
+
+`tsconfig.json` must have:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}
+```
+
+---
+
+## Installation
+
+```bash
+npm install nestworker
+```
+---
+
+## Quick Start
+
+### 1. Import `WorkerModule` in your root module
+
+```ts
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { WorkerModule } from 'nestworker';
+import { ConfigService } from './config.service';
+import { ImageService } from './image.service';
+
+@Module({
+  imports: [WorkerModule.forRoot()],
+  providers: [ConfigService, ImageService],  // register your @WorkerClass providers here
+})
+export class AppModule {}
+```
+
+### 2. Decorate your service
+
+```ts
+// image.service.ts
+import { Injectable } from '@nestjs/common';
+import { WorkerClass, WorkerTask } from 'nestworker';
+import { ConfigService } from './config.service';
+
+@Injectable()
+@WorkerClass({ deps: [ConfigService] })   // deps are injected into the worker
+export class ImageService {
+  constructor(private readonly configService: ConfigService) {}
+
+  @WorkerTask({ priority: 'HIGH' })
+  resizeImage(value: number): number {
+    // runs in a worker thread — configService works normally here
+    const multiplier = this.configService.getNumber('MULTIPLIER');
+    let total = 0;
+    for (let i = 0; i < 10_000_000; i++) total += i * value * multiplier;
+    return total;
+  }
+
+  @WorkerTask({ priority: 'NORMAL', timeout: 5000 })
+  generateThumbnail(width: number, height: number): string {
+    let hash = 0;
+    for (let i = 0; i < 5_000_000; i++) hash ^= (i * width * height) | 0;
+    return `thumb_${hash.toString(16)}_${width}x${height}.webp`;
+  }
+}
+```
+
+### 3. Inject `WorkerService` and call `run()`
+
+```ts
+// image.controller.ts
+import { Controller, Get } from '@nestjs/common';
+import { WorkerService } from 'nestworker';
+
+@Controller('images')
+export class ImageController {
+  constructor(private readonly workerService: WorkerService) {}
+
+  @Get('resize')
+  async resize() {
+    return this.workerService.run<number>('ImageService', 'resizeImage', [5]);
+  }
+
+  @Get('thumbnail')
+  async thumbnail() {
+    return this.workerService.run<string>(
+      'ImageService', 'generateThumbnail', [1920, 1080]
+    );
+  }
+}
+```
+---
+
+## Using Modules Inside Task Methods
+
+Worker tasks are reconstructed from class source via `eval()`. Top-level `import` statements from your file are **not available** inside the worker. Use one of these two patterns instead.
+
+### Dynamic import — preferred
+
+`import()` is a language keyword, not a variable. It works natively inside `eval()`'d code with no setup, and is compatible with both ESM and CommonJS projects.
+
+```ts
+@WorkerTask()
+async moduleImport(): Promise<string> {
+  const os = await import('node:os');
+  return `Import os size ${os.cpus().length}`
+}
+```
+
+### Inline `require()` — CJS projects only
+
+`require` is injected into the eval scope by `WorkerContainer`, so it works in CommonJS projects.
+
+```ts
+@WorkerTask()
+async moduleRequire(): Promise<string> {
+  const os = require('node:os');
+  return `Require os size ${os.cpus().length}`
+}
+```
+
+### What is safe to import inside a worker
+
+| ✅ Safe | ❌ Not safe |
+|---|---|
+| Node built-ins: `os`, `path`, `crypto`, `zlib`, `fs` | HTTP clients (`axios`, `fetch`) |
+| Pure computation libraries | Database drivers |
+| `Buffer`, `Math`, `Date` | `Socket`, `Stream` |
+
+---
+
+## API
+
+### `WorkerModule.forRoot(options?)`
+
+Registers the module globally. Call once at the application root.
+
+```ts
+WorkerModule.forRoot({
+  poolSize: 4,  // default: os.cpus().length
+})
+```
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `poolSize` | `number` | `os.cpus().length` | Number of worker threads to spawn |
+
+---
+
+### `@WorkerClass(options?)`
+
+Class decorator. Marks a NestJS provider as a container of worker tasks.
+
+```ts
+@WorkerClass({ deps: [ConfigService, LoggerService] })
+export class MyService { ... }
+```
+
+| Option | Type | Description |
+|---|---|---|
+| `deps` | `Type[]` | Injectable dependencies to reconstruct inside workers |
+
+---
+
+### `@WorkerTask(options?)`
+
+Method decorator. Marks a method to be offloaded to a worker thread.
+
+```ts
+@WorkerTask({ priority: 'HIGH', timeout: 3000 })
+heavyComputation(input: number): number { ... }
+```
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `priority` | `'HIGH' \| 'NORMAL' \| 'LOW'` | `'NORMAL'` | Queue priority — `HIGH` jobs run first |
+| `timeout` | `number` | `undefined` | Reject the job after this many ms |
+
+---
+
+### `WorkerService.run<T>(serviceName, methodName, args, overrides?)`
+
+Executes a `@WorkerTask` method in a worker thread.
+
+```ts
+// Uses priority/timeout from the @WorkerTask decorator
+const result = await workerService.run<number>('ImageService', 'resizeImage', [5]);
+
+// Override priority or timeout for a specific call
+const result = await workerService.run<number>(
+  'ImageService', 'resizeImage', [5],
+  { priority: 'LOW', timeout: 10_000 }
+);
+```
+
+| Parameter | Type | Description |
+|---|---|---|
+| `serviceName` | `string` | Class name of the `@WorkerClass` provider |
+| `methodName` | `string` | Method name decorated with `@WorkerTask` |
+| `args` | `unknown[]` | Arguments to pass — must be structuredClone-compatible |
+| `overrides` | `object` | Optional `priority` / `timeout` override for this call |
+
+Returns a `Promise<T>` that resolves with the method's return value.
+
+---
+
+## How DI in Workers Works
+
+Worker threads run in an isolated V8 context — they share no heap with the main thread. Passing live NestJS services across the boundary is impossible.
+
+This module solves it in three steps:
+
+**1. Main thread — `serializeForWorker()`**
+
+`Class.toString()` extracts each class as a plain JS source string (no imports, no decorators). Each dep's data properties are snapshotted via `structuredClone`. Both are sent to workers via `workerData`.
+
+**2. Worker thread — `WorkerContainer`**
+
+The class source strings are `eval()`'d back into constructors. Each dep is reconstructed as `Object.create(DepClass.prototype) + Object.assign(snapshot)` — restoring prototype methods AND runtime state. The service class is then `new ServiceClass(...depInstances)`.
+
+**3. Result**
+
+`this.configService.get('KEY')` inside a worker task works exactly as on the main thread — as long as the dep reads from plain data (no DB connections, no HTTP clients).
+
+```
+MAIN THREAD                         WORKER THREAD
+────────────────────────────────    ────────────────────────────────────
+WorkerService.run()
+  → discovery.scan()                
+  → ConfigService live instance     
+  → snapshot: { config: {...} }  →  Object.create(ConfigService.prototype)
+  → classSource: "class Cfg..."  →  eval("class ConfigService { get()... }")
+                                    Object.assign(inst, snapshot)
+  → ImageService classSource     →  eval("class ImageService {...}")
+                                    new ImageService(configInst)
+                                    this.configService.get() ✓
+```
+
+### What deps can be passed to workers
+
+✅ Services holding plain config data (`Record`, `Map`, arrays, primitives)  
+✅ Services whose methods only read from their own properties  
+❌ Services that hold DB connections, HTTP clients, or open streams  
+❌ Services with `Socket`, `Stream`, or non-cloneable properties
+
+---
+
+## Priority Queue
+
+Jobs queue when all threads are busy. The queue is sorted by priority — `HIGH` always runs before `NORMAL` which runs before `LOW`. Within the same priority, jobs are FIFO.
+
+```ts
+// These four tasks are dispatched to the pool concurrently.
+// HIGH tasks run first regardless of arrival order.
+await Promise.all([
+  workerService.run('Svc', 'lowPriorityTask',    [], { priority: 'LOW'    }),
+  workerService.run('Svc', 'highPriorityTask',   [], { priority: 'HIGH'   }),
+  workerService.run('Svc', 'normalPriorityTask', [], { priority: 'NORMAL' }),
+  workerService.run('Svc', 'highPriorityTask2',  [], { priority: 'HIGH'   }),
+]);
+```
+---
+
+## Constraints
+
+### Arguments and Return Values
+
+Task arguments and return values cross a thread boundary via `postMessage()` and must be [structuredClone](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm) compatible.
+
+| ✅ Supported | ❌ Not supported |
+|---|---|
+| Primitives, plain objects, arrays | Class instances |
+| `Map`, `Set`, `ArrayBuffer` | Functions |
+| `TypedArray`, `DataView` | `Promise`, `WeakMap` |
+
+### Circular deps
+
+Circular dependencies between `@WorkerClass({ deps })` entries are not supported.
+
+---
+
+## Contributing
+
+See the [contributing guide](https://github.com/VaheHak/nestworker/blob/master/CONTRIBUTING.md) for detailed instructions on how to get started with our project.
+
+## License
+
+Licensed under [MIT](https://github.com/VaheHak/nestworker/blob/master/LICENSE).

package/dist/core/worker.interfaces.d.ts

@@ -0,0 +1,36 @@
+export type TaskPriority = 'HIGH' | 'NORMAL' | 'LOW';
+export interface WorkerJob {
+    serviceName: string;
+    methodName: string;
+    args: unknown[];
+    /** Sourced from @WorkerTask({ priority }) — used by WorkerPool to sort the queue */
+    priority: TaskPriority;
+    /** Sourced from @WorkerTask({ timeout }) — rejects the job after this many ms */
+    timeout?: number;
+}
+export interface WorkerResult<T = unknown> {
+    ok: boolean;
+    data?: T;
+    error?: {
+        message: string;
+        stack?: string;
+    };
+}
+export interface DiscoveredTask {
+    serviceName: string;
+    methodName: string;
+    priority: TaskPriority;
+    timeout?: number;
+    /** Bound method on the live main-thread instance */
+    fn: (...args: unknown[]) => unknown;
+    /** Class constructor — used to locate the compiled file and read metadata */
+    metatype: new (...args: unknown[]) => unknown;
+    /** Live main-thread service instance — used to locate dep property keys */
+    instance: unknown;
+    /** Resolved dep instances from the NestJS container, in declaration order */
+    deps: unknown[];
+}
+export interface WorkerModuleOptions {
+    /** Number of worker threads. Defaults to os.cpus().length */
+    poolSize?: number;
+}

package/dist/{models/task.js → core/worker.interfaces.js}

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

package/dist/core/worker.interfaces.js.map

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

package/dist/core/worker.module.d.ts

@@ -0,0 +1,15 @@
+import { DynamicModule } from '@nestjs/common';
+import type { WorkerModuleOptions } from './worker.interfaces';
+/**
+ * WorkerModule – import once at the root of your application.
+ *
+ * @example
+ *   @Module({
+ *     imports: [WorkerModule.forRoot()],
+ *     providers: [ConfigService, ImageService],
+ *   })
+ *   export class AppModule {}
+ */
+export declare class WorkerModule {
+    static forRoot(options?: WorkerModuleOptions): DynamicModule;
+}

package/dist/core/worker.module.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var WorkerModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const worker_service_1 = require("./worker.service");
+const discovery_service_1 = require("../discovery/discovery.service");
+/**
+ * WorkerModule – import once at the root of your application.
+ *
+ * @example
+ *   @Module({
+ *     imports: [WorkerModule.forRoot()],
+ *     providers: [ConfigService, ImageService],
+ *   })
+ *   export class AppModule {}
+ */
+let WorkerModule = WorkerModule_1 = class WorkerModule {
+    static forRoot(options = {}) {
+        return {
+            module: WorkerModule_1,
+            imports: [core_1.DiscoveryModule],
+            providers: [
+                { provide: 'WORKER_OPTIONS', useValue: options },
+                discovery_service_1.WorkerDiscoveryService,
+                worker_service_1.WorkerService,
+            ],
+            exports: [worker_service_1.WorkerService],
+        };
+    }
+};
+exports.WorkerModule = WorkerModule;
+exports.WorkerModule = WorkerModule = WorkerModule_1 = __decorate([
+    (0, common_1.Module)({})
+], WorkerModule);
+//# sourceMappingURL=worker.module.js.map

package/dist/core/worker.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.module.js","sourceRoot":"","sources":["../../src/core/worker.module.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAAuD;AACvD,uCAA+C;AAC/C,qDAAiD;AACjD,sEAAwE;AAGxE;;;;;;;;;GASG;AAEI,IAAM,YAAY,oBAAlB,MAAM,YAAY;IACvB,MAAM,CAAC,OAAO,CAAC,UAA+B,EAAE;QAC9C,OAAO;YACL,MAAM,EAAE,cAAY;YACpB,OAAO,EAAE,CAAC,sBAAe,CAAC;YAC1B,SAAS,EAAE;gBACT,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE;gBAChD,0CAAsB;gBACtB,8BAAa;aACd;YACD,OAAO,EAAE,CAAC,8BAAa,CAAC;SACzB,CAAC;IACJ,CAAC;CACF,CAAA;AAbY,oCAAY;uBAAZ,YAAY;IADxB,IAAA,eAAM,EAAC,EAAE,CAAC;GACE,YAAY,CAaxB"}

package/dist/core/worker.pool.d.ts

@@ -0,0 +1,20 @@
+import type { WorkerJob } from './worker.interfaces';
+import type { SerializedService } from '../di/worker-container';
+export declare class WorkerPool {
+    private readonly services;
+    private readonly size;
+    private readonly workers;
+    private readonly idle;
+    private readonly queue;
+    private destroyed;
+    private readonly active;
+    constructor(services: SerializedService[], size?: number);
+    execute<T = unknown>(job: WorkerJob): Promise<T>;
+    private preemptIfNeeded;
+    private enqueue;
+    private schedule;
+    private dispatch;
+    private spawnWorker;
+    private replaceWorker;
+    destroy(): Promise<void>;
+}