@xylabs/threads 3.0.4

package/dist/master/implementation.node.js

@@ -0,0 +1,255 @@
+"use strict";
+/* eslint-disable unicorn/prefer-logical-operator-over-ternary */
+/* eslint-disable unicorn/prefer-regexp-test */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable unicorn/prefer-add-event-listener */
+/* eslint-disable unicorn/prefer-event-target */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable unicorn/text-encoding-identifier-case */
+/* eslint-disable unicorn/no-process-exit */
+/// <reference lib="dom" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerRuntime = exports.getWorkerImplementation = exports.defaultPoolSize = void 0;
+const node_events_1 = require("node:events");
+const node_os_1 = require("node:os");
+const path = __importStar(require("node:path"));
+const node_url_1 = require("node:url");
+const callsites_1 = __importDefault(require("callsites"));
+let tsNodeAvailable;
+exports.defaultPoolSize = (0, node_os_1.cpus)().length;
+function detectTsNode() {
+    if (typeof __non_webpack_require__ === 'function') {
+        // Webpack build: => No ts-node required or possible
+        return false;
+    }
+    if (tsNodeAvailable) {
+        return tsNodeAvailable;
+    }
+    try {
+        eval('require').resolve('ts-node');
+        tsNodeAvailable = true;
+    }
+    catch (error) {
+        if (error && error.code === 'MODULE_NOT_FOUND') {
+            tsNodeAvailable = false;
+        }
+        else {
+            // Re-throw
+            throw error;
+        }
+    }
+    return tsNodeAvailable;
+}
+function createTsNodeModule(scriptPath) {
+    const content = `
+    require("ts-node/register/transpile-only");
+    require(${JSON.stringify(scriptPath)});
+  `;
+    return content;
+}
+function rebaseScriptPath(scriptPath, ignoreRegex) {
+    const parentCallSite = (0, callsites_1.default)().find((callsite) => {
+        const filename = callsite.getFileName();
+        return Boolean(filename && !filename.match(ignoreRegex) && !/[/\\]master[/\\]implementation/.test(filename) && !/^internal\/process/.test(filename));
+    });
+    const rawCallerPath = parentCallSite ? parentCallSite.getFileName() : null;
+    let callerPath = rawCallerPath ? rawCallerPath : null;
+    if (callerPath && callerPath.startsWith('file:')) {
+        callerPath = (0, node_url_1.fileURLToPath)(callerPath);
+    }
+    const rebasedScriptPath = callerPath ? path.join(path.dirname(callerPath), scriptPath) : scriptPath;
+    return rebasedScriptPath;
+}
+function resolveScriptPath(scriptPath, baseURL) {
+    const makeRelative = (filePath) => {
+        // eval() hack is also webpack-related
+        return path.isAbsolute(filePath) ? filePath : path.join(baseURL || eval('__dirname'), filePath);
+    };
+    const workerFilePath = typeof __non_webpack_require__ === 'function' ?
+        __non_webpack_require__.resolve(makeRelative(scriptPath))
+        : eval('require').resolve(makeRelative(rebaseScriptPath(scriptPath, /[/\\]worker_threads[/\\]/)));
+    return workerFilePath;
+}
+function initWorkerThreadsWorker() {
+    // Webpack hack
+    const NativeWorker = typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads').Worker : eval('require')('worker_threads').Worker;
+    let allWorkers = [];
+    class Worker extends NativeWorker {
+        mappedEventListeners;
+        constructor(scriptPath, options) {
+            const resolvedScriptPath = options && options.fromSource ? null : resolveScriptPath(scriptPath, (options || {})._baseURL);
+            if (!resolvedScriptPath) {
+                // `options.fromSource` is true
+                const sourceCode = scriptPath;
+                super(sourceCode, { ...options, eval: true });
+            }
+            else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
+                super(createTsNodeModule(resolvedScriptPath), { ...options, eval: true });
+            }
+            else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
+                // See <https://github.com/andywer/threads-plugin/issues/17>
+                super(resolvedScriptPath.replace(/\.asar([/\\])/, '.asar.unpacked$1'), options);
+            }
+            else {
+                super(resolvedScriptPath, options);
+            }
+            this.mappedEventListeners = new WeakMap();
+            allWorkers.push(this);
+        }
+        addEventListener(eventName, rawListener) {
+            const listener = (message) => {
+                rawListener({ data: message });
+            };
+            this.mappedEventListeners.set(rawListener, listener);
+            this.on(eventName, listener);
+        }
+        removeEventListener(eventName, rawListener) {
+            const listener = this.mappedEventListeners.get(rawListener) || rawListener;
+            this.off(eventName, listener);
+        }
+    }
+    const terminateWorkersAndMaster = () => {
+        // we should terminate all workers and then gracefully shutdown self process
+        Promise.all(allWorkers.map((worker) => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        allWorkers = [];
+    };
+    // Take care to not leave orphaned processes behind. See #147.
+    process.on('SIGINT', () => terminateWorkersAndMaster());
+    process.on('SIGTERM', () => terminateWorkersAndMaster());
+    class BlobWorker extends Worker {
+        constructor(blob, options) {
+            super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true });
+        }
+        static fromText(source, options) {
+            return new Worker(source, { ...options, fromSource: true });
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: Worker,
+    };
+}
+function initTinyWorker() {
+    const TinyWorker = require('tiny-worker');
+    let allWorkers = [];
+    class Worker extends TinyWorker {
+        emitter;
+        constructor(scriptPath, options) {
+            // Need to apply a work-around for Windows or it will choke upon the absolute path
+            // (`Error [ERR_INVALID_PROTOCOL]: Protocol 'c:' not supported`)
+            const resolvedScriptPath = options && options.fromSource ? null
+                : process.platform === 'win32' ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
+                    : resolveScriptPath(scriptPath);
+            if (!resolvedScriptPath) {
+                // `options.fromSource` is true
+                const sourceCode = scriptPath;
+                super(new Function(sourceCode), [], { esm: true });
+            }
+            else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
+                super(new Function(createTsNodeModule(resolveScriptPath(scriptPath))), [], { esm: true });
+            }
+            else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
+                // See <https://github.com/andywer/threads-plugin/issues/17>
+                super(resolvedScriptPath.replace(/\.asar([/\\])/, '.asar.unpacked$1'), [], { esm: true });
+            }
+            else {
+                super(resolvedScriptPath, [], { esm: true });
+            }
+            allWorkers.push(this);
+            this.emitter = new node_events_1.EventEmitter();
+            this.onerror = (error) => this.emitter.emit('error', error);
+            this.onmessage = (message) => this.emitter.emit('message', message);
+        }
+        addEventListener(eventName, listener) {
+            this.emitter.addListener(eventName, listener);
+        }
+        removeEventListener(eventName, listener) {
+            this.emitter.removeListener(eventName, listener);
+        }
+        terminate() {
+            allWorkers = allWorkers.filter((worker) => worker !== this);
+            return super.terminate();
+        }
+    }
+    const terminateWorkersAndMaster = () => {
+        // we should terminate all workers and then gracefully shutdown self process
+        Promise.all(allWorkers.map((worker) => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        allWorkers = [];
+    };
+    // Take care to not leave orphaned processes behind
+    // See <https://github.com/avoidwork/tiny-worker#faq>
+    process.on('SIGINT', () => terminateWorkersAndMaster());
+    process.on('SIGTERM', () => terminateWorkersAndMaster());
+    class BlobWorker extends Worker {
+        constructor(blob, options) {
+            super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true });
+        }
+        static fromText(source, options) {
+            return new Worker(source, { ...options, fromSource: true });
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: Worker,
+    };
+}
+let implementation;
+let isTinyWorker;
+function selectWorkerImplementation() {
+    try {
+        isTinyWorker = false;
+        return initWorkerThreadsWorker();
+    }
+    catch {
+        // tslint:disable-next-line no-console
+        console.debug('Node worker_threads not available. Trying to fall back to tiny-worker polyfill...');
+        isTinyWorker = true;
+        return initTinyWorker();
+    }
+}
+function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+exports.getWorkerImplementation = getWorkerImplementation;
+function isWorkerRuntime() {
+    if (isTinyWorker) {
+        return self !== undefined && self['postMessage'] ? true : false;
+    }
+    else {
+        // Webpack hack
+        const isMainThread = typeof __non_webpack_require__ === 'function' ?
+            __non_webpack_require__('worker_threads').isMainThread
+            : eval('require')('worker_threads').isMainThread;
+        return !isMainThread;
+    }
+}
+exports.isWorkerRuntime = isWorkerRuntime;

package/dist/master/index.d.ts

@@ -0,0 +1,13 @@
+import type { BlobWorker as BlobWorkerClass } from '../types/master';
+import { Worker as WorkerType } from '../types/master';
+export { FunctionThread, ModuleThread } from '../types/master';
+export { Pool } from './pool';
+export { spawn } from './spawn';
+export { Thread } from './thread';
+export type BlobWorker = typeof BlobWorkerClass;
+export type Worker = WorkerType;
+/** Separate class to spawn workers from source code blobs or strings. */
+export declare const BlobWorker: typeof BlobWorkerClass;
+/** Worker implementation. Either web worker or a node.js Worker class. */
+export declare const Worker: typeof import("../types/master").WorkerImplementation;
+export { isWorkerRuntime } from './implementation';

package/dist/master/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerRuntime = exports.Worker = exports.BlobWorker = exports.Thread = exports.spawn = exports.Pool = void 0;
+const implementation_1 = require("./implementation");
+var pool_1 = require("./pool");
+Object.defineProperty(exports, "Pool", { enumerable: true, get: function () { return pool_1.Pool; } });
+var spawn_1 = require("./spawn");
+Object.defineProperty(exports, "spawn", { enumerable: true, get: function () { return spawn_1.spawn; } });
+var thread_1 = require("./thread");
+Object.defineProperty(exports, "Thread", { enumerable: true, get: function () { return thread_1.Thread; } });
+/** Separate class to spawn workers from source code blobs or strings. */
+exports.BlobWorker = (0, implementation_1.getWorkerImplementation)().blob;
+/** Worker implementation. Either web worker or a node.js Worker class. */
+exports.Worker = (0, implementation_1.getWorkerImplementation)().default;
+var implementation_2 = require("./implementation");
+Object.defineProperty(exports, "isWorkerRuntime", { enumerable: true, get: function () { return implementation_2.isWorkerRuntime; } });

package/dist/master/invocation-proxy.d.ts

@@ -0,0 +1,3 @@
+import { ModuleMethods, ModuleProxy, ProxyableFunction, Worker as WorkerType } from '../types/master';
+export declare function createProxyFunction<Args extends any[], ReturnType>(worker: WorkerType, method?: string): ProxyableFunction<Args, ReturnType>;
+export declare function createProxyModule<Methods extends ModuleMethods>(worker: WorkerType, methodNames: string[]): ModuleProxy<Methods>;

package/dist/master/invocation-proxy.js

@@ -0,0 +1,130 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/*
+ * This source file contains the code for proxying calls in the master thread to calls in the workers
+ * by `.postMessage()`-ing.
+ *
+ * Keep in mind that this code can make or break the program's performance! Need to optimize more…
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProxyModule = exports.createProxyFunction = void 0;
+const debug_1 = __importDefault(require("debug"));
+const observable_fns_1 = require("observable-fns");
+const common_1 = require("../common");
+const observable_promise_1 = require("../observable-promise");
+const transferable_1 = require("../transferable");
+const messages_1 = require("../types/messages");
+const debugMessages = (0, debug_1.default)('threads:master:messages');
+let nextJobUID = 1;
+const dedupe = (array) => [...new Set(array)];
+const isJobErrorMessage = (data) => data && data.type === messages_1.WorkerMessageType.error;
+const isJobResultMessage = (data) => data && data.type === messages_1.WorkerMessageType.result;
+const isJobStartMessage = (data) => data && data.type === messages_1.WorkerMessageType.running;
+function createObservableForJob(worker, jobUID) {
+    return new observable_fns_1.Observable((observer) => {
+        let asyncType;
+        const messageHandler = ((event) => {
+            debugMessages('Message from worker:', event.data);
+            if (!event.data || event.data.uid !== jobUID)
+                return;
+            if (isJobStartMessage(event.data)) {
+                asyncType = event.data.resultType;
+            }
+            else if (isJobResultMessage(event.data)) {
+                if (asyncType === 'promise') {
+                    if (event.data.payload !== undefined) {
+                        observer.next((0, common_1.deserialize)(event.data.payload));
+                    }
+                    observer.complete();
+                    worker.removeEventListener('message', messageHandler);
+                }
+                else {
+                    if (event.data.payload) {
+                        observer.next((0, common_1.deserialize)(event.data.payload));
+                    }
+                    if (event.data.complete) {
+                        observer.complete();
+                        worker.removeEventListener('message', messageHandler);
+                    }
+                }
+            }
+            else if (isJobErrorMessage(event.data)) {
+                const error = (0, common_1.deserialize)(event.data.error);
+                if (asyncType === 'promise' || !asyncType) {
+                    observer.error(error);
+                }
+                else {
+                    observer.error(error);
+                }
+                worker.removeEventListener('message', messageHandler);
+            }
+        });
+        worker.addEventListener('message', messageHandler);
+        return () => {
+            if (asyncType === 'observable' || !asyncType) {
+                const cancelMessage = {
+                    type: messages_1.MasterMessageType.cancel,
+                    uid: jobUID,
+                };
+                worker.postMessage(cancelMessage);
+            }
+            worker.removeEventListener('message', messageHandler);
+        };
+    });
+}
+function prepareArguments(rawArgs) {
+    if (rawArgs.length === 0) {
+        // Exit early if possible
+        return {
+            args: [],
+            transferables: [],
+        };
+    }
+    const args = [];
+    const transferables = [];
+    for (const arg of rawArgs) {
+        if ((0, transferable_1.isTransferDescriptor)(arg)) {
+            args.push((0, common_1.serialize)(arg.send));
+            transferables.push(...arg.transferables);
+        }
+        else {
+            args.push((0, common_1.serialize)(arg));
+        }
+    }
+    return {
+        args,
+        transferables: transferables.length === 0 ? transferables : dedupe(transferables),
+    };
+}
+function createProxyFunction(worker, method) {
+    return ((...rawArgs) => {
+        const uid = nextJobUID++;
+        const { args, transferables } = prepareArguments(rawArgs);
+        const runMessage = {
+            args,
+            method,
+            type: messages_1.MasterMessageType.run,
+            uid,
+        };
+        debugMessages('Sending command to run function to worker:', runMessage);
+        try {
+            worker.postMessage(runMessage, transferables);
+        }
+        catch (error) {
+            return observable_promise_1.ObservablePromise.from(Promise.reject(error));
+        }
+        return observable_promise_1.ObservablePromise.from((0, observable_fns_1.multicast)(createObservableForJob(worker, uid)));
+    });
+}
+exports.createProxyFunction = createProxyFunction;
+function createProxyModule(worker, methodNames) {
+    const proxy = {};
+    for (const methodName of methodNames) {
+        proxy[methodName] = createProxyFunction(worker, methodName);
+    }
+    return proxy;
+}
+exports.createProxyModule = createProxyModule;

package/dist/master/pool-types.d.ts

@@ -0,0 +1,65 @@
+import { Thread } from './thread';
+/** Pool event type. Specifies the type of each `PoolEvent`. */
+export declare enum PoolEventType {
+    initialized = "initialized",
+    taskCanceled = "taskCanceled",
+    taskCompleted = "taskCompleted",
+    taskFailed = "taskFailed",
+    taskQueued = "taskQueued",
+    taskQueueDrained = "taskQueueDrained",
+    taskStart = "taskStart",
+    terminated = "terminated"
+}
+export type TaskRunFunction<ThreadType extends Thread, Return> = (worker: ThreadType) => Promise<Return>;
+/** Pool event. Subscribe to those events using `pool.events()`. Useful for debugging. */
+export type PoolEvent<ThreadType extends Thread> = {
+    type: PoolEventType.initialized;
+    size: number;
+} | {
+    type: PoolEventType.taskQueued;
+    taskID: number;
+} | {
+    type: PoolEventType.taskQueueDrained;
+} | {
+    type: PoolEventType.taskStart;
+    taskID: number;
+    workerID: number;
+} | {
+    type: PoolEventType.taskCompleted;
+    returnValue: any;
+    taskID: number;
+    workerID: number;
+} | {
+    type: PoolEventType.taskFailed;
+    error: Error;
+    taskID: number;
+    workerID: number;
+} | {
+    type: PoolEventType.taskCanceled;
+    taskID: number;
+} | {
+    type: PoolEventType.terminated;
+    remainingQueue: Array<QueuedTask<ThreadType, any>>;
+};
+export interface WorkerDescriptor<ThreadType extends Thread> {
+    init: Promise<ThreadType>;
+    runningTasks: Array<Promise<any>>;
+}
+/**
+ * Task that has been `pool.queued()`-ed.
+ */
+export interface QueuedTask<ThreadType extends Thread, Return> {
+    /** @private */
+    id: number;
+    /** @private */
+    run: TaskRunFunction<ThreadType, Return>;
+    /**
+     * Queued tasks can be cancelled until the pool starts running them on a worker thread.
+     */
+    cancel(): void;
+    /**
+     * `QueuedTask` is thenable, so you can `await` it.
+     * Resolves when the task has successfully been executed. Rejects if the task fails.
+     */
+    then: Promise<Return>['then'];
+}

package/dist/master/pool-types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolEventType = void 0;
+/** Pool event type. Specifies the type of each `PoolEvent`. */
+var PoolEventType;
+(function (PoolEventType) {
+    PoolEventType["initialized"] = "initialized";
+    PoolEventType["taskCanceled"] = "taskCanceled";
+    PoolEventType["taskCompleted"] = "taskCompleted";
+    PoolEventType["taskFailed"] = "taskFailed";
+    PoolEventType["taskQueued"] = "taskQueued";
+    PoolEventType["taskQueueDrained"] = "taskQueueDrained";
+    PoolEventType["taskStart"] = "taskStart";
+    PoolEventType["terminated"] = "terminated";
+})(PoolEventType || (exports.PoolEventType = PoolEventType = {}));

package/dist/master/pool.d.ts

@@ -0,0 +1,90 @@
+import { Observable } from 'observable-fns';
+import { PoolEvent, PoolEventType, QueuedTask, TaskRunFunction } from './pool-types';
+import { Thread } from './thread';
+export declare namespace Pool {
+    type Event<ThreadType extends Thread = any> = PoolEvent<ThreadType>;
+    type EventType = PoolEventType;
+}
+/**
+ * Thread pool managing a set of worker threads.
+ * Use it to queue tasks that are run on those threads with limited
+ * concurrency.
+ */
+export interface Pool<ThreadType extends Thread> {
+    /**
+     * Returns a promise that resolves once the task queue is emptied.
+     * Promise will be rejected if any task fails.
+     *
+     * @param allowResolvingImmediately Set to `true` to resolve immediately if task queue is currently empty.
+     */
+    completed(allowResolvingImmediately?: boolean): Promise<any>;
+    /**
+     * Returns a promise that resolves once the task queue is emptied.
+     * Failing tasks will not cause the promise to be rejected.
+     *
+     * @param allowResolvingImmediately Set to `true` to resolve immediately if task queue is currently empty.
+     */
+    settled(allowResolvingImmediately?: boolean): Promise<Error[]>;
+    /**
+     * Returns an observable that yields pool events.
+     */
+    events(): Observable<PoolEvent<ThreadType>>;
+    /**
+     * Queue a task and return a promise that resolves once the task has been dequeued,
+     * started and finished.
+     *
+     * @param task An async function that takes a thread instance and invokes it.
+     */
+    queue<Return>(task: TaskRunFunction<ThreadType, Return>): QueuedTask<ThreadType, Return>;
+    /**
+     * Terminate all pool threads.
+     *
+     * @param force Set to `true` to kill the thread even if it cannot be stopped gracefully.
+     */
+    terminate(force?: boolean): Promise<void>;
+}
+export interface PoolOptions {
+    /** Maximum no. of tasks to run on one worker thread at a time. Defaults to one. */
+    concurrency?: number;
+    /** Maximum no. of jobs to be queued for execution before throwing an error. */
+    maxQueuedJobs?: number;
+    /** Gives that pool a name to be used for debug logging, letting you distinguish between log output of different pools. */
+    name?: string;
+    /** No. of worker threads to spawn and to be managed by the pool. */
+    size?: number;
+}
+declare class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
+    static EventType: typeof PoolEventType;
+    private readonly debug;
+    private readonly eventObservable;
+    private readonly options;
+    private readonly workers;
+    private readonly eventSubject;
+    private initErrors;
+    private isClosing;
+    private nextTaskID;
+    private taskQueue;
+    constructor(spawnWorker: () => Promise<ThreadType>, optionsOrSize?: number | PoolOptions);
+    private findIdlingWorker;
+    private runPoolTask;
+    private run;
+    private scheduleWork;
+    private taskCompletion;
+    settled(allowResolvingImmediately?: boolean): Promise<Error[]>;
+    completed(allowResolvingImmediately?: boolean): Promise<void>;
+    events(): Observable<PoolEvent<ThreadType>>;
+    queue(taskFunction: TaskRunFunction<ThreadType, any>): QueuedTask<ThreadType, any>;
+    terminate(force?: boolean): Promise<void>;
+}
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+declare function PoolConstructor<ThreadType extends Thread>(spawnWorker: () => Promise<ThreadType>, optionsOrSize?: number | PoolOptions): WorkerPool<ThreadType>;
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+export declare const Pool: typeof PoolConstructor & {
+    EventType: typeof PoolEventType;
+};
+export { PoolEvent, PoolEventType, QueuedTask } from './pool-types';
+export { Thread } from './thread';