@travetto/worker 3.4.2 → 4.0.0-rc.1

package/README.md

@@ -16,162 +16,7 @@ yarn add @travetto/worker
 This module provides the necessary primitives for handling dependent workers.  A worker can be an individual actor or could be a pool of workers. Node provides ipc (inter-process communication) functionality out of the box. This module builds upon that by providing enhanced event management, richer process management, as well as constructs for orchestrating a conversation between two processes.
 
 ## Execution Pools
-With respect to managing multiple executions, [WorkPool](https://github.com/travetto/travetto/tree/main/module/worker/src/pool.ts#L31) is provided to allow for concurrent operation, and processing of jobs concurrently.  To manage the flow of jobs, there are various [WorkSet](https://github.com/travetto/travetto/tree/main/module/worker/src/input/types.ts#L4) implementation that allow for a wide range of use cases. 
-
-The only provided [WorkSet](https://github.com/travetto/travetto/tree/main/module/worker/src/input/types.ts#L4) is the [IterableWorkSet](https://github.com/travetto/travetto/tree/main/module/worker/src/input/iterable.ts#L11) which supports all `Iterable` and `Iterator` sources.  Additionally, the module provides [ManualAsyncIterator](https://github.com/travetto/travetto/tree/main/module/worker/src/input/async-iterator.ts#L6) which allows for manual control of iteration, which is useful for event driven work loads. 
-
-Below is a pool that will convert images on demand, while queuing as needed.
-
-**Code: Image processing queue, with a fixed batch/pool size**
-```typescript
-import { ExecUtil, ExecutionState } from '@travetto/base';
-import { Worker, WorkPool, IterableWorkSet, ManualAsyncIterator } from '@travetto/worker';
-
-class ImageProcessor implements Worker<string> {
-  active = false;
-  proc: ExecutionState;
-
-  get id(): number | undefined {
-    return this.proc.process.pid;
-  }
-
-  async destroy(): Promise<void> {
-    this.proc.process.kill();
-  }
-
-  async execute(path: string): Promise<void> {
-    this.active = true;
-    try {
-      this.proc = ExecUtil.spawn('convert images', [path]);
-      await this.proc;
-    } catch {
-      // Do nothing
-    }
-    this.active = false;
-  }
-}
-
-export class ImageCompressor extends WorkPool<string> {
-
-  pendingImages = new ManualAsyncIterator<string>();
-
-  constructor() {
-    super(async () => new ImageProcessor());
-  }
-
-  begin(): void {
-    this.process(new IterableWorkSet(this.pendingImages));
-  }
-
-  convert(...images: string[]): void {
-    this.pendingImages.add(images);
-  }
-}
-```
-
-Once a pool is constructed, it can be shutdown by calling the `.shutdown()` method, and awaiting the result.
+With respect to managing multiple executions, [WorkPool](https://github.com/travetto/travetto/tree/main/module/worker/src/pool.ts#L35) is provided to allow for concurrent operation, and processing of jobs concurrently.  To manage the flow of jobs, [WorkQueue](https://github.com/travetto/travetto/tree/main/module/worker/src/queue.ts#L6) is provided to support a wide range of use cases. [WorkQueue](https://github.com/travetto/travetto/tree/main/module/worker/src/queue.ts#L6) allows for manual control of iteration, which is useful for event driven work loads. 
 
 ## IPC Support
 Within the `comm` package, there is support for two primary communication elements: [ChildCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/child.ts#L6) and [ParentCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/parent.ts#L10).  Usually [ParentCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/parent.ts#L10) indicates it is the owner of the sub process. [ChildCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/child.ts#L6) indicates that it has been created/spawned/forked by the parent and will communicate back to it's parent. This generally means that a [ParentCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/parent.ts#L10) can be destroyed (i.e. killing the subprocess) where a [ChildCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/child.ts#L6) can only exit the process, but the channel cannot be destroyed.
-
-### IPC as a Worker
-A common pattern is to want to model a sub process as a worker, to be a valid candidate in a [WorkPool](https://github.com/travetto/travetto/tree/main/module/worker/src/pool.ts#L31).  The [WorkUtil](https://github.com/travetto/travetto/tree/main/module/worker/src/util.ts#L14) class provides a utility to facilitate this desire.
-
-**Code: Spawned Worker**
-```typescript
-import { ExecutionState } from '@travetto/base';
-
-import { ParentCommChannel } from './comm/parent';
-import { Worker } from './pool';
-
-type Simple<V> = (ch: ParentCommChannel<V>) => Promise<unknown | void>;
-type Param<V, X> = (ch: ParentCommChannel<V>, input: X) => Promise<unknown | void>;
-
-const empty = async (): Promise<void> => { };
-
-/**
- * Spawned worker
- */
-export class WorkUtil {
-  /**
-   * Create a process channel worker from a given spawn config
-   */
-  static spawnedWorker<V, X>(
-    worker: () => ExecutionState,
-    init: Simple<V>,
-    execute: Param<V, X>,
-    destroy: Simple<V> = empty): Worker<X> {
-    const channel = new ParentCommChannel<V>(worker());
-    return {
-      get id(): number | undefined { return channel.id; },
-      get active(): boolean { return channel.active; },
-      init: () => init(channel),
-      execute: inp => execute(channel, inp),
-      async destroy(): Promise<void> {
-        await destroy(channel);
-        await channel.destroy();
-      },
-    };
-  }
-}
-```
-
-When creating your work, via process spawning, you will need to provide the script (and any other features you would like in `SpawnConfig`).   Additionally you must, at a minimum, provide functionality to run whenever an input element is up for grabs in the input source.  This method will be provided the communication channel ([ParentCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/parent.ts#L10)) and the input value.  A simple example could look like:
-
-**Code: Spawning Pool**
-```typescript
-import { ExecUtil } from '@travetto/base';
-import { WorkPool, WorkUtil, IterableWorkSet } from '@travetto/worker';
-
-export async function main(): Promise<void> {
-  const pool = new WorkPool(() =>
-    WorkUtil.spawnedWorker<{ data: number }, number>(
-      () => ExecUtil.spawn('trv', ['main', '@travetto/worker/doc/spawned.ts']),
-      ch => ch.once('ready'), // Wait for child to indicate it is ready
-      async (channel, inp) => {
-        const res = channel.once('response'); //  Register response listener
-        channel.send('request', { data: inp }); // Send request
-
-        const { data } = await res; // Get answer
-        console.log('Request complete', { input: inp, output: data });
-
-        if (!(inp + inp === data)) {
-          // Ensure the answer is double the input
-          throw new Error(`Did not get the double: inp=${inp}, data=${data}`);
-        }
-      }
-    )
-  );
-  await pool.process(new IterableWorkSet([1, 2, 3, 4, 5]));
-}
-```
-
-**Code: Spawned Worker**
-```typescript
-import timers from 'timers/promises';
-import { ChildCommChannel } from '@travetto/worker';
-
-export async function main(): Promise<void> {
-  const exec = new ChildCommChannel<{ data: string }>();
-
-  exec.on('request', data =>
-    exec.send('response', { data: (data.data + data.data) })); // When data is received, return double
-
-  exec.send('ready'); // Indicate the child is ready to receive requests
-
-  for await (const _ of timers.setInterval(5000)) {
-    // Keep-alive
-  }
-}
-```
-
-**Terminal: Output**
-```bash
-$ trv main doc/spawner.ts
-
-Request complete { input: 1, output: 2 }
-Request complete { input: 2, output: 4 }
-Request complete { input: 3, output: 6 }
-Request complete { input: 4, output: 8 }
-Request complete { input: 5, output: 10 }
-```

package/__index__.ts

@@ -2,11 +2,8 @@ export * from './src/comm/channel';
 export * from './src/comm/child';
 export * from './src/comm/parent';
 export * from './src/comm/types';
-export * from './src/input/iterable';
-export * from './src/input/async-iterator';
-export * from './src/input/types';
 export * from './src/support/barrier';
 export * from './src/support/timeout';
 export * from './src/support/error';
+export * from './src/queue';
 export * from './src/pool';
-export * from './src/util';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/worker",
-  "version": "3.4.2",
+  "version": "4.0.0-rc.1",
   "description": "Process management utilities, with a focus on inter-process communication",
   "keywords": [
     "exec",
@@ -25,7 +25,7 @@
     "directory": "module/worker"
   },
   "dependencies": {
-    "@travetto/base": "^3.4.2",
+    "@travetto/base": "^4.0.0-rc.1",
     "generic-pool": "^3.9.0"
   },
   "travetto": {

package/src/comm/channel.ts

@@ -1,7 +1,5 @@
-import { ChildProcess } from 'child_process';
-import { EventEmitter } from 'events';
-
-import { ExecUtil } from '@travetto/base';
+import { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
 
 /**
  * Channel that represents communication between parent/child
@@ -56,8 +54,8 @@ export class ProcessCommChannel<T extends NodeJS.Process | ChildProcess, V = unk
     console.debug('Sending', { pid: this.#parentId, id: this.id, eventType });
     if (!this.#proc) {
       throw new Error('this.proc was not defined');
-    } else if (this.#proc.send) {
-      this.#proc.send({ ...(data ?? {}), type: eventType });
+    } else if (this.#proc.send && this.#proc.connected) {
+      this.#proc.send({ ...(data ?? {}), type: eventType }, (err) => err && console.error(err));
     } else {
       throw new Error('this.proc.send was not defined');
     }
@@ -92,7 +90,8 @@ export class ProcessCommChannel<T extends NodeJS.Process | ChildProcess, V = unk
     if (this.#proc) {
       console.debug('Killing', { pid: this.#parentId, id: this.id });
       if (this.#proc !== process) {
-        ExecUtil.kill(this.#proc);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        (this.#proc as ChildProcess).kill();
       }
       this.#proc = undefined;
     }

package/src/comm/parent.ts

@@ -1,6 +1,6 @@
-import { ChildProcess } from 'child_process';
+import { ChildProcess } from 'node:child_process';
 
-import { ShutdownManager, ExecutionState } from '@travetto/base';
+import { ShutdownManager } from '@travetto/base';
 
 import { ProcessCommChannel } from './channel';
 
@@ -9,13 +9,12 @@ import { ProcessCommChannel } from './channel';
  */
 export class ParentCommChannel<U = unknown> extends ProcessCommChannel<ChildProcess, U> {
 
-  #complete: ExecutionState['result'];
+  #complete: Promise<void>;
 
-  constructor(state: ExecutionState) {
-    super(state.process);
-    ShutdownManager.onShutdown(this, { close: () => this.destroy() });
-    this.#complete = state.result
-      .finally(() => { this.proc = undefined; });
+  constructor(proc: ChildProcess) {
+    super(proc);
+    ShutdownManager.onGracefulShutdown(() => this.destroy(), this);
+    this.#complete = new Promise<void>(r => proc.on('close', r)).finally(() => { this.proc = undefined; });
   }
 
   /**

package/src/pool.ts

@@ -1,211 +1,178 @@
-import os from 'os';
 import gp from 'generic-pool';
+import os from 'node:os';
+import timers from 'node:timers/promises';
 
-import { GlobalEnv, ShutdownManager, TimeUtil } from '@travetto/base';
+import { Env, Util } from '@travetto/base';
 
-import { WorkSet } from './input/types';
-import { ManualAsyncIterator } from '../src/input/async-iterator';
+import { WorkQueue } from './queue';
+
+type ItrSource<I> = Iterable<I> | AsyncIterable<I>;
 
 /**
  * Worker definition
  */
-export interface Worker<X> {
-  active: boolean;
-  id: unknown;
+export interface Worker<I, O = unknown> {
+  active?: boolean;
+  id?: unknown;
   init?(): Promise<unknown>;
-  execute(input: X): Promise<unknown>;
-  destroy(): Promise<void>;
+  execute(input: I, idx: number): Promise<O>;
+  destroy?(): Promise<void>;
   release?(): unknown;
 }
 
-type WorkPoolProcessConfig<X> = {
-  shutdownOnComplete?: boolean;
-  onComplete?: (ev: WorkCompletionEvent<X>) => (void | Promise<void>);
+type WorkerInput<I, O> = (() => Worker<I, O>) | ((input: I, inputIdx: number) => Promise<O>);
+type WorkPoolConfig<I, O> = gp.Options & {
+  onComplete?: (output: O, input: I, finishIdx: number) => void;
+  onError?(ev: Error, input: I, finishIdx: number): (unknown | Promise<unknown>);
+  shutdown?: AbortSignal;
 };
 
-type WorkCompletionEvent<X> = { idx: number, total?: number, value: X };
+const isWorkerFactory = <I, O>(o: WorkerInput<I, O>): o is (() => Worker<I, O>) => o.length === 0;
 
 /**
  * Work pool support
  */
-export class WorkPool<X> {
+export class WorkPool {
 
-  static MAX_SIZE = os.cpus().length - 1;
+  static MAX_SIZE = os.availableParallelism();
   static DEFAULT_SIZE = Math.min(WorkPool.MAX_SIZE, 4);
 
-  /**
-   * Generic-pool pool
-   */
-  #pool: gp.Pool<Worker<X>>;
-  /**
-   * Number of acquisitions in process
-   */
-  #pendingAcquires = 0;
-  /**
-   * List of errors during processing
-   */
-  #errors: Error[] = [];
-
-  /**
-   * Error count during creation
-   */
-  #createErrors = 0;
+  /** Build worker pool */
+  static #buildPool<I, O>(worker: WorkerInput<I, O>, opts?: WorkPoolConfig<I, O>): gp.Pool<Worker<I, O>> {
+    let pendingAcquires = 0;
 
-  /**
-   * Are we tracing
-   */
-  #trace: boolean;
+    const trace = /@travetto\/worker/.test(Env.DEBUG.val ?? '');
 
-  /**
-   * Cleanup for shutdown
-   */
-  #shutdownCleanup?: () => void;
-
-  /**
-   *
-   * @param getWorker Produces a new worker for the pool
-   * @param opts Pool options
-   */
-  constructor(getWorker: () => Promise<Worker<X>> | Worker<X>, opts?: gp.Options) {
-    const args = {
+    // Create the pool
+    const pool = gp.createPool({
+      async create() {
+        try {
+          pendingAcquires += 1;
+          const res = isWorkerFactory(worker) ? await worker() : { execute: worker };
+          res.id ??= Util.shortHash(`${Math.random()}`);
+
+          if (res.init) {
+            await res.init();
+          }
+
+          return res;
+        } finally {
+          pendingAcquires -= 1;
+        }
+      },
+      async destroy(x) {
+        if (trace) {
+          console.debug('Destroying', { pid: process.pid, worker: x.id });
+        }
+        return x.destroy?.();
+      },
+      validate: async (x: Worker<I, O>) => x.active ?? true
+    }, {
       max: WorkPool.DEFAULT_SIZE,
       min: 1,
       evictionRunIntervalMillis: 5000,
       ...(opts ?? {}),
-    };
-
-    // Create the pool
-    this.#pool = gp.createPool({
-      create: () => this.#createAndTrack(getWorker, args),
-      destroy: x => this.destroy(x),
-      validate: async (x: Worker<X>) => x.active
-    }, args);
-
-    this.#shutdownCleanup = ShutdownManager.onShutdown(`worker.pool.${this.constructor.name}`, () => {
-      this.#shutdownCleanup = undefined;
-      this.shutdown();
     });
 
-    this.#trace = !!GlobalEnv.debug?.includes('@travetto/worker');
-  }
-
-  /**
-   * Creates and tracks new worker
-   */
-  async #createAndTrack(getWorker: () => Promise<Worker<X>> | Worker<X>, opts: gp.Options): Promise<Worker<X>> {
-    try {
-      this.#pendingAcquires += 1;
-      const res = await getWorker();
-
-      if (res.init) {
-        await res.init();
-      }
-
-      this.#createErrors = 0; // Reset errors on success
 
-      return res;
-    } catch (err) {
-      if (this.#createErrors++ > opts.max!) { // If error count is bigger than pool size, we broke
-        console.error('Failed in creating pool', { error: err });
-        await ShutdownManager.exit(1);
+    // Listen for shutdown
+    opts?.shutdown?.addEventListener('abort', async () => {
+      while (pendingAcquires) {
+        await timers.setTimeout(10);
       }
-      throw err;
-    } finally {
-      this.#pendingAcquires -= 1;
-    }
-  }
+      await pool.drain();
+      await pool.clear();
+    });
 
-  /**
-   * Destroy the worker
-   */
-  async destroy(worker: Worker<X>): Promise<void> {
-    if (this.#trace) {
-      console.debug('Destroying', { pid: process.pid, worker: worker.id });
-    }
-    return worker.destroy();
+    return pool;
   }
 
   /**
-   * Free worker on completion
+   * Process a given input source and worker, and fire on completion
    */
-  async release(worker: Worker<X>): Promise<void> {
-    if (this.#trace) {
-      console.debug('Releasing', { pid: process.pid, worker: worker.id });
-    }
-    try {
-      if (worker.active) {
-        try {
-          await worker.release?.();
-        } catch { }
-        await this.#pool.release(worker);
-      } else {
-        await this.#pool.destroy(worker);
-      }
-    } catch { }
-  }
+  static async run<I, O>(workerFactory: WorkerInput<I, O>, src: ItrSource<I>, opts: WorkPoolConfig<I, O> = {}): Promise<void> {
 
-  /**
-   * Process a given input source
-   */
-  async process(src: WorkSet<X>, cfg: WorkPoolProcessConfig<X> = {}): Promise<void> {
+    const trace = /@travetto\/worker/.test(Env.DEBUG.val ?? '');
     const pending = new Set<Promise<unknown>>();
-    let count = 0;
+    const errors: Error[] = [];
+    let inputIdx = 0;
+    let finishIdx = 0;
 
-    if (src.size && cfg.onComplete) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      cfg.onComplete({ value: undefined as X, idx: 0, total: src.size });
-    }
+    const pool = this.#buildPool(workerFactory, opts);
 
-    while (await src.hasNext()) {
-      const worker = (await this.#pool.acquire())!;
-      if (this.#trace) {
+    for await (const nextInput of src) {
+      const worker = await pool.acquire()!;
+
+      if (trace) {
         console.debug('Acquired', { pid: process.pid, worker: worker.id });
       }
-      const nextInput = await src.next();
 
-      const completion = worker.execute(nextInput)
-        .catch(err => this.#errors.push(err)) // Catch error
-        .finally(() => this.release(worker))
-        .finally(() => cfg.onComplete?.({ value: nextInput, idx: count += 1, total: src.size }));
+      const completion = worker.execute(nextInput, inputIdx += 1)
+        .then(v => opts.onComplete?.(v, nextInput, finishIdx += 1))
+        .catch(err => {
+          errors.push(err);
+          opts?.onError?.(err, nextInput, finishIdx += 1);
+        }) // Catch error
+        .finally(async () => {
+          if (trace) {
+            console.debug('Releasing', { pid: process.pid, worker: worker.id });
+          }
+          try {
+            if (worker.active ?? true) {
+              try {
+                await worker.release?.();
+              } catch { }
+              await pool.release(worker);
+            } else {
+              await pool.destroy(worker);
+            }
+          } catch { }
+        });
 
       completion.finally(() => pending.delete(completion));
-
       pending.add(completion);
     }
 
-    try {
-      await Promise.all(Array.from(pending));
+    await Promise.all(Array.from(pending));
 
-      if (this.#errors.length) {
-        throw this.#errors[0];
-      }
-    } finally {
-      if (cfg.shutdownOnComplete !== false) {
-        await this.shutdown();
-      }
+    if (errors.length) {
+      throw errors[0];
     }
   }
 
   /**
-   * Process a given input source as an async iterable, emitting on completion
+   * Process a given input source as an async iterable
    */
-  iterateProcess(src: WorkSet<X>, shutdownOnComplete?: boolean): AsyncIterable<WorkCompletionEvent<X>> {
-    const itr = new ManualAsyncIterator<WorkCompletionEvent<X>>();
-    const res = this.process(src, { onComplete: ev => itr.add(ev), shutdownOnComplete });
+  static runStream<I, O>(worker: WorkerInput<I, O>, input: ItrSource<I>, opts?: WorkPoolConfig<I, O>): AsyncIterable<O> {
+    const itr = new WorkQueue<O>();
+    const res = this.run(worker, input, {
+      ...opts,
+      onComplete: (ev, inp, finishIdx) => {
+        itr.add(ev);
+        opts?.onComplete?.(ev, inp, finishIdx);
+      }
+    });
     res.finally(() => itr.close());
     return itr;
   }
 
   /**
-   * Shutdown pool
+   * Process a given input source as an async iterable with progress information
    */
-  async shutdown(): Promise<void> {
-    this.#shutdownCleanup?.();
-
-    while (this.#pendingAcquires) {
-      await TimeUtil.wait(10);
-    }
-    await this.#pool.drain();
-    await this.#pool.clear();
+  static runStreamProgress<I, O>(worker: WorkerInput<I, O>, input: ItrSource<I>, total: number, opts?: WorkPoolConfig<I, O>): AsyncIterable<{
+    idx: number;
+    value: O;
+    total: number;
+  }> {
+    const itr = new WorkQueue<{ idx: number, value: O, total: number }>();
+    const res = this.run(worker, input, {
+      ...opts,
+      onComplete: (ev, inp, finishIdx) => {
+        itr.add({ value: ev, idx: finishIdx, total });
+        opts?.onComplete?.(ev, inp, finishIdx);
+      }
+    });
+    res.finally(() => itr.close());
+    return itr;
   }
-}
+}

package/src/{input/async-iterator.ts → queue.ts}

@@ -1,9 +1,9 @@
 import { Util } from '@travetto/base';
 
 /**
- * Manual async iterator.  Items are added manually, and consumed asynchronously
+ * WorkQueue, a manual async iterator.  Items are added manually, and consumed asynchronously
  */
-export class ManualAsyncIterator<X> implements AsyncIterator<X>, AsyncIterable<X> {
+export class WorkQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
 
   #queue: X[] = [];
   #done = false;
@@ -17,6 +17,9 @@ export class ManualAsyncIterator<X> implements AsyncIterator<X>, AsyncIterable<X
     this.#queue.push(...initial);
     this.#size = this.#queue.length;
     signal?.addEventListener('abort', () => this.close());
+    if (signal?.aborted) {
+      this.close();
+    }
   }
 
   // Allow for iteration
@@ -39,14 +42,20 @@ export class ManualAsyncIterator<X> implements AsyncIterator<X>, AsyncIterable<X
    * Queue next event to fire
    * @param {boolean} immediate Determines if item(s) should be append or prepended to the queue
    */
-  add(item: X | X[], immediate = false): void {
-    item = Array.isArray(item) ? item : [item];
-    if (!immediate) {
-      this.#queue.push(...item);
-    } else {
-      this.#queue.unshift(...item);
-    }
-    this.#size += item.length;
+  add(item: X, immediate = false): void {
+    this.#queue[immediate ? 'unshift' : 'push'](item);
+    this.#size += 1;
+    this.#ready.resolve();
+  }
+
+  /**
+   * Queue a list of data to stream
+   * @param {boolean} immediate Determines if item(s) should be append or prepended to the queue
+   */
+  addAll(items: Iterable<X>): void {
+    const copy = [...items];
+    this.#queue.push(...copy);
+    this.#size += copy.length;
     this.#ready.resolve();
   }
 
@@ -58,6 +67,15 @@ export class ManualAsyncIterator<X> implements AsyncIterator<X>, AsyncIterable<X
     this.#ready.resolve();
   }
 
+  /**
+   * Throw an error from the queue, rejecting and terminating immediately
+   */
+  async throw(e?: Error): Promise<IteratorResult<X>> {
+    this.#done = true;
+    this.#ready.reject(e);
+    return { value: undefined, done: this.#done };
+  }
+
   /**
    * Get size, will change as items are added
    */

package/src/support/barrier.ts

@@ -1,6 +1,6 @@
-import { setTimeout } from 'timers/promises';
+import { setTimeout } from 'node:timers/promises';
 
-import { ShutdownManager, TimeSpan, Util } from '@travetto/base';
+import { TimeSpan, Util } from '@travetto/base';
 
 import { Timeout } from './timeout';
 
@@ -19,7 +19,11 @@ export class Barrier {
   static listenForUnhandled(): Promise<never> & { cancel: () => void } {
     const uncaught = Util.resolvablePromise<never>();
     const uncaughtWithCancel: typeof uncaught & { cancel?: () => void } = uncaught;
-    const cancel = ShutdownManager.onUnhandled(err => { setTimeout(1).then(() => uncaught.reject(err)); return true; }, 0);
+    const onError = (err: Error): void => { setTimeout(1).then(() => uncaught.reject(err)); };
+    process.on('unhandledRejection', onError).on('uncaughtException', onError);
+    const cancel = (): void => {
+      process.off('unhandledRejection', onError).off('unhandledException', onError);
+    };
     uncaughtWithCancel.cancel = (): void => {
       cancel(); // Remove the handler
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions

package/src/support/timeout.ts

@@ -1,3 +1,4 @@
+import { clearTimeout } from 'node:timers';
 import { TimeSpan, TimeUtil, Util } from '@travetto/base';
 import { ExecutionError } from './error';
 
@@ -6,7 +7,7 @@ import { ExecutionError } from './error';
  */
 export class Timeout extends ExecutionError {
 
-  #id: NodeJS.Timer | undefined;
+  #id: ReturnType<typeof setTimeout> | undefined;
   #promise = Util.resolvablePromise();
   #duration: number;
 

package/src/input/iterable.ts

@@ -1,73 +0,0 @@
-import { WorkSet } from './types';
-
-type Itr<T> = Iterator<T> | AsyncIterator<T>;
-
-const hasAsyncItr = (o: unknown): o is AsyncIterable<unknown> => !!o && typeof o === 'object' && Symbol.asyncIterator in o;
-const hasItr = (o: unknown): o is Iterable<unknown> => !!o && typeof o === 'object' && Symbol.iterator in o;
-
-/**
- * Basic input source given an iterable input
- */
-export class IterableWorkSet<X> implements WorkSet<X> {
-
-  #src: Itr<X>;
-  #ondeck?: X;
-  #done = false;
-  #size?: number;
-
-  constructor(src: Iterable<X> | AsyncIterable<X> | (() => Generator<X>) | (() => AsyncGenerator<X>) | Itr<X>) {
-    if ('next' in src) {
-      this.#src = src;
-    } else {
-      if (hasAsyncItr(src)) {
-        this.#src = src[Symbol.asyncIterator]();
-      } else if (hasItr(src)) {
-        this.#src = src[Symbol.iterator]();
-      } else {
-        this.#src = src();
-      }
-    }
-    if (Array.isArray(src)) {
-      this.#size = src.length;
-    } else if (src instanceof Set) {
-      this.#size = src.size;
-    }
-  }
-
-  /**
-   * Fetch next item from the iterable
-   */
-  async #primeNext(): Promise<void> {
-    const res = await this.#src.next();
-    this.#done = !!res.done;
-    this.#ondeck = res.value;
-  }
-
-  /**
-   * Determine if the iterable has more data
-   */
-  async hasNext(): Promise<boolean> {
-    if (this.#ondeck === undefined) {
-      await this.#primeNext();
-    }
-    return !this.#done;
-  }
-
-  /**
-   * Fetch next item
-   */
-  async next(): Promise<X> {
-    await this.hasNext();
-
-    const out = this.#ondeck!;
-    this.#ondeck = undefined;
-    return out;
-  }
-
-  /**
-   * Get size, if defined
-   */
-  get size(): number | undefined {
-    return this.#size;
-  }
-}

package/src/input/types.ts

@@ -1,17 +0,0 @@
-/**
- * Definition for an work set
- */
-export interface WorkSet<X> {
-  /**
-   * Determines if there is more work to do
-   */
-  hasNext(): boolean | Promise<boolean>;
-  /**
-   * Get next item
-   */
-  next(): X | Promise<X>;
-  /**
-   * Total size of work set
-   */
-  size?: number;
-}

package/src/util.ts

@@ -1,35 +0,0 @@
-import { ExecutionState } from '@travetto/base';
-
-import { ParentCommChannel } from './comm/parent';
-import { Worker } from './pool';
-
-type Simple<V> = (ch: ParentCommChannel<V>) => Promise<unknown | void>;
-type Param<V, X> = (ch: ParentCommChannel<V>, input: X) => Promise<unknown | void>;
-
-const empty = async (): Promise<void> => { };
-
-/**
- * Spawned worker
- */
-export class WorkUtil {
-  /**
-   * Create a process channel worker from a given spawn config
-   */
-  static spawnedWorker<V, X>(
-    worker: () => ExecutionState,
-    init: Simple<V>,
-    execute: Param<V, X>,
-    destroy: Simple<V> = empty): Worker<X> {
-    const channel = new ParentCommChannel<V>(worker());
-    return {
-      get id(): number | undefined { return channel.id; },
-      get active(): boolean { return channel.active; },
-      init: () => init(channel),
-      execute: inp => execute(channel, inp),
-      async destroy(): Promise<void> {
-        await destroy(channel);
-        await channel.destroy();
-      },
-    };
-  }
-}