@travetto/runtime 8.0.0-alpha.2 → 8.0.0-alpha.21

package/src/env.ts

@@ -3,11 +3,13 @@ import { castKey, castTo } from './types.ts';
 const IS_TRUE = /^(true|yes|on|1)$/i;
 const IS_FALSE = /^(false|no|off|0)$/i;
 
-export interface EnvData { }
+export interface EnvData {}
 
 export class EnvProp<T> {
   readonly key: string;
-  constructor(key: string) { this.key = key; }
+  constructor(key: string) {
+    this.key = key;
+  }
 
   /** Set value according to type */
   set(value: T | undefined | null): void {
@@ -26,14 +28,18 @@ export class EnvProp<T> {
   /** Export value */
   export(value?: T | undefined | null): Record<string, string> {
     let out: string;
-    if (arguments.length === 0) { // If nothing passed in
+    // biome-ignore lint/complexity/noArguments: We want to use arguments here to detect if nothing was truly passed
+    if (arguments.length === 0) {
+      // If nothing passed in
       out = `${this.value}`;
     } else if (value === undefined || value === null) {
       out = '';
     } else if (Array.isArray(value)) {
       out = value.join(',');
     } else if (typeof value === 'object') {
-      out = Object.entries(value).map(([key, keyValue]) => `${key}=${keyValue}`).join(',');
+      out = Object.entries(value)
+        .map(([key, keyValue]) => `${key}=${keyValue}`)
+        .join(',');
     } else {
       out = `${value}`;
     }
@@ -41,13 +47,19 @@ export class EnvProp<T> {
   }
 
   /** Read value as string */
-  get value(): string | undefined { return process.env[this.key] || undefined; }
+  get value(): string | undefined {
+    return process.env[this.key] || undefined;
+  }
 
   /** Read value as list */
   get list(): string[] | undefined {
     const value = this.value;
-    return (value === undefined || value === '') ?
-      undefined : value.split(/[, ]+/g).map(item => item.trim()).filter(item => !!item);
+    return value === undefined || value === ''
+      ? undefined
+      : value
+          .split(/[, ]+/g)
+          .map(item => item.trim())
+          .filter(item => !!item);
   }
 
   /** Read value as object */
@@ -58,7 +70,7 @@ export class EnvProp<T> {
 
   /** Add values to list */
   add(...items: string[]): void {
-    process.env[this.key] = [... new Set([...this.list ?? [], ...items])].join(',');
+    process.env[this.key] = [...new Set([...(this.list ?? []), ...items])].join(',');
   }
 
   /** Read value as int  */
@@ -70,7 +82,7 @@ export class EnvProp<T> {
   /** Read value as boolean */
   get bool(): boolean | undefined {
     const value = this.value;
-    return (value === undefined || value === '') ? undefined : IS_TRUE.test(value);
+    return value === undefined || value === '' ? undefined : IS_TRUE.test(value);
   }
 
   /** Determine if the underlying value is truthy */
@@ -90,25 +102,33 @@ export class EnvProp<T> {
   }
 }
 
-type AllType = {
-  [K in keyof EnvData]: Pick<EnvProp<EnvData[K]>, 'key' | 'export' | 'value' | 'set' | 'clear' | 'isSet' |
-    (EnvData[K] extends unknown[] ? 'list' | 'add' : never) |
-    (Extract<EnvData[K], object> extends never ? never : 'object') |
-    (Extract<EnvData[K], number> extends never ? never : 'int') |
-    (Extract<EnvData[K], boolean> extends never ? never : 'bool' | 'isTrue' | 'isFalse')
-  >
+type EnvDataCombinedType = {
+  [K in keyof EnvData]: Pick<
+    EnvProp<EnvData[K]>,
+    | 'key'
+    | 'export'
+    | 'value'
+    | 'set'
+    | 'clear'
+    | 'isSet'
+    | (EnvData[K] extends unknown[] ? 'list' | 'add' : never)
+    | (Extract<EnvData[K], object> extends never ? never : 'object')
+    | (Extract<EnvData[K], number> extends never ? never : 'int')
+    | (Extract<EnvData[K], boolean> extends never ? never : 'bool' | 'isTrue' | 'isFalse')
+  >;
 };
 
-function delegate<T extends object>(base: T): AllType & T {
+function delegate<T extends object>(base: T): EnvDataCombinedType & T {
   return new Proxy(castTo(base), {
     get(target, property): unknown {
-      return typeof property !== 'string' ? undefined :
-        (property in base ? base[castKey(property)] :
-          target[castKey<typeof target>(property)] ??= castTo(new EnvProp(property))
-        );
+      return typeof property !== 'string'
+        ? undefined
+        : property in base
+          ? base[castKey(property)]
+          : (target[castKey<typeof target>(property)] ??= castTo(new EnvProp(property)));
     }
   });
 }
 
 /** Basic utils for reading known environment variables */
-export const Env = delegate({});
+export const Env = delegate({});

package/src/error.ts

@@ -1,13 +1,6 @@
 import { castTo } from './types.ts';
 
-export type ErrorCategory =
-  'general' |
-  'notfound' |
-  'data' |
-  'permissions' |
-  'authentication' |
-  'timeout' |
-  'unavailable';
+export type ErrorCategory = 'general' | 'notfound' | 'data' | 'permissions' | 'authentication' | 'timeout' | 'unavailable';
 
 export type RuntimeErrorOptions<T> = Omit<Partial<RuntimeError>, 'details'> & (T extends undefined ? { details?: T } : { details: T });
 
@@ -15,7 +8,6 @@ export type RuntimeErrorOptions<T> = Omit<Partial<RuntimeError>, 'details'> & (T
  * Framework error class, with the aim of being extensible
  */
 export class RuntimeError<T = Record<string, unknown> | undefined> extends Error {
-
   static defaultCategory: ErrorCategory = 'general';
 
   type: string;
@@ -28,14 +20,11 @@ export class RuntimeError<T = Record<string, unknown> | undefined> extends Error
    *
    * @param message The error message
    */
-  constructor(
-    ...[message, options]:
-      T extends undefined ? ([string] | [string, RuntimeErrorOptions<T>]) : [string, RuntimeErrorOptions<T>]
-  ) {
+  constructor(...[message, options]: T extends undefined ? [string] | [string, RuntimeErrorOptions<T>] : [string, RuntimeErrorOptions<T>]) {
     super(message, options?.cause ? { cause: options.cause } : undefined);
     this.type = options?.type ?? this.constructor.name;
-    this.details = options?.details!;
+    this.details = options?.details ?? undefined!;
     this.category = options?.category ?? castTo<typeof RuntimeError>(this.constructor).defaultCategory ?? 'general';
     this.at = new Date(options?.at ?? Date.now());
   }
-}
+}

package/src/exec.ts

@@ -1,9 +1,9 @@
-import { type ChildProcess, spawn, type SpawnOptions } from 'node:child_process';
+import { type ChildProcess, type SpawnOptions, spawn } from 'node:child_process';
 
-import { castTo } from './types.ts';
-import { RuntimeIndex } from './manifest-index.ts';
-import { BinaryUtil, type BinaryArray } from './binary.ts';
+import { type BinaryArray, BinaryUtil } from './binary.ts';
 import { CodecUtil } from './codec.ts';
+import { RuntimeIndex } from './manifest-index.ts';
+import { castTo } from './types.ts';
 
 const ResultSymbol = Symbol();
 
@@ -39,6 +39,17 @@ type ExecutionBaseResult = Omit<ExecutionResult, 'stdout' | 'stderr'>;
  * Standard utilities for managing executions
  */
 export class ExecUtil {
+  /** Read stream as string from a result */
+  static toString(result: ExecutionResult<BinaryArray | string>, stream: 'stdout' | 'stderr' | 'any'): string {
+    if (stream === 'any') {
+      return this.toString(result, 'stderr') || this.toString(result, 'stdout');
+    }
+    const value = result[stream];
+    if (typeof value === 'string') {
+      return value.trim();
+    }
+    return CodecUtil.toUTF8String(value).trim();
+  }
 
   /**
    * Take a child process, and some additional options, and produce a promise that
@@ -49,11 +60,14 @@ export class ExecUtil {
    * @param options The options to use to enhance the process
    */
   static getResult(subProcess: ChildProcess): Promise<ExecutionResult<string>>;
-  static getResult(subProcess: ChildProcess, options: { catch?: boolean, binary?: false }): Promise<ExecutionResult<string>>;
-  static getResult(subProcess: ChildProcess, options: { catch?: boolean, binary: true }): Promise<ExecutionResult<BinaryArray>>;
-  static getResult<T extends string | BinaryArray>(subProcess: ChildProcess, options: { catch?: boolean, binary?: boolean } = {}): Promise<ExecutionResult<T>> {
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean; binary?: false }): Promise<ExecutionResult<string>>;
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean; binary: true }): Promise<ExecutionResult<BinaryArray>>;
+  static getResult<T extends string | BinaryArray>(
+    subProcess: ChildProcess,
+    options: { catch?: boolean; binary?: boolean } = {}
+  ): Promise<ExecutionResult<T>> {
     const typed: ChildProcess & { [ResultSymbol]?: Promise<ExecutionResult> } = subProcess;
-    const result = typed[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
+    const result = (typed[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
       const stdout: BinaryArray[] = [];
       const stderr: BinaryArray[] = [];
       let done = false;
@@ -65,7 +79,7 @@ export class ExecUtil {
 
         const buffers = {
           stdout: BinaryUtil.combineBinaryArrays(stdout),
-          stderr: BinaryUtil.combineBinaryArrays(stderr),
+          stderr: BinaryUtil.combineBinaryArrays(stderr)
         };
 
         const final = {
@@ -74,37 +88,37 @@ export class ExecUtil {
           ...finalResult
         };
 
-        resolve(!final.valid ?
-          { ...final, message: `${final.message || final.stderr || final.stdout || 'failed'}` } :
-          final
-        );
+        resolve(!final.valid ? { ...final, message: `${final.message || final.stderr || final.stdout || 'failed'}` } : final);
       };
 
       subProcess.stdout?.on('data', data => stdout.push(CodecUtil.readChunk(data, subProcess.stdout?.readableEncoding)));
       subProcess.stderr?.on('data', data => stderr.push(CodecUtil.readChunk(data, subProcess.stderr?.readableEncoding)));
 
-      subProcess.on('error', (error: Error) =>
-        finish({ code: 1, message: error.message, valid: false }));
+      subProcess.on('error', (error: Error) => finish({ code: 1, message: error.message, valid: false }));
 
-      subProcess.on('close', (code: number) =>
-        finish({ code, valid: code === null || code === 0 }));
+      subProcess.on('close', (code: number) => finish({ code, valid: code === null || code === 0 }));
 
-      if (subProcess.exitCode !== null) { // We are already done
+      if (subProcess.exitCode !== null) {
+        // We are already done
         finish({ code: subProcess.exitCode, valid: subProcess.exitCode === 0 });
       }
-    });
-
-    return castTo(options.catch ? result : result.then(executionResult => {
-      if (executionResult.valid) {
-        return executionResult;
-      } else {
-        throw new Error(executionResult.message);
-      }
     }));
+
+    return castTo(
+      options.catch
+        ? result
+        : result.then(executionResult => {
+            if (executionResult.valid) {
+              return executionResult;
+            } else {
+              throw new Error(executionResult.message);
+            }
+          })
+    );
   }
 
   /** Spawn a package command */
   static spawnPackageCommand(cmd: string, args: string[], config: SpawnOptions = {}): ChildProcess {
     return spawn(process.argv0, [RuntimeIndex.resolvePackageCommand(cmd), ...args], config);
   }
-}
+}

package/src/file-loader.ts

@@ -2,14 +2,13 @@ import { createReadStream } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
+import { type BinaryArray, type BinaryStream, BinaryUtil } from './binary.ts';
 import { RuntimeError } from './error.ts';
-import { BinaryUtil, type BinaryArray, type BinaryStream } from './binary.ts';
 
 /**
  * File loader that will search for files across the provided search paths
  */
 export class FileLoader {
-
   #searchPaths: readonly string[];
 
   constructor(paths: string[]) {
@@ -30,7 +29,7 @@ export class FileLoader {
   async resolve(relativePath: string): Promise<string> {
     for (const sub of this.searchPaths) {
       const resolved = path.join(sub, relativePath);
-      if (await fs.stat(resolved).catch(() => false)) {
+      if (await fs.stat(resolved, { throwIfNoEntry: false })) {
         return resolved;
       }
     }
@@ -41,7 +40,7 @@ export class FileLoader {
    * Read a file as utf8 text, after resolving the path
    * @param relativePath The path to read
    */
-  async readText(relativePath: string): Promise<string> {
+  async readUTF8(relativePath: string): Promise<string> {
     const file = await this.resolve(relativePath);
     return fs.readFile(file, 'utf8');
   }
@@ -72,4 +71,4 @@ export class FileLoader {
     const buffer = BinaryUtil.binaryArrayToBuffer(await this.readBinaryArray(relativePath));
     return new File([buffer], path.basename(relativePath));
   }
-}
+}

package/src/function.ts

@@ -1,6 +1,6 @@
 import { ManifestModuleUtil } from '@travetto/manifest';
 
-export type FunctionMetadataTag = { hash: number, lines: [start: number, end: number, bodyStart?: number] };
+export type FunctionMetadataTag = { hash: number; lines: [start: number, end: number, bodyStart?: number] };
 export type FunctionMetadata = FunctionMetadataTag & {
   id: string;
   import: string;
@@ -26,13 +26,16 @@ const pending = new Set<Function>([]);
  * @private
  */
 export function registerFunction(
-  input: Function, [module, relativePath]: [string, string], tag: FunctionMetadataTag,
-  methods?: Record<string, FunctionMetadataTag>, abstract?: boolean,
+  input: Function,
+  [module, relativePath]: [string, string],
+  tag: FunctionMetadataTag,
+  methods?: Record<string, FunctionMetadataTag>,
+  abstract?: boolean
 ): void {
   const modulePath = ManifestModuleUtil.withoutSourceExtension(relativePath);
 
   const metadata: FunctionMetadata = {
-    id: (input.name ? `${module}:${modulePath}#${input.name}` : `${module}:${modulePath}`),
+    id: input.name ? `${module}:${modulePath}#${input.name}` : `${module}:${modulePath}`,
     import: `${module}/${relativePath}`,
     module,
     modulePath,
@@ -65,5 +68,10 @@ export function describeFunction(input?: Function): FunctionMetadata | undefined
 
 const foreignTypeRegistry = new Map<string, Function>();
 export function foreignType(id: string): Function {
-  return foreignTypeRegistry.getOrInsert(id, class { static Ⲑid = id; });
-}
+  return foreignTypeRegistry.getOrInsert(
+    id,
+    class {
+      static Ⲑid = id;
+    }
+  );
+}

package/src/global.d.ts

@@ -1,6 +1,7 @@
 import './types';
 
 declare const write: unique symbol;
+
 declare global {
   // https://github.com/microsoft/TypeScript/issues/59012
   interface WritableStreamDefaultWriter<W = any> {
@@ -52,6 +53,18 @@ declare module 'buffer' {
   interface File { }
 }
 
+declare module 'node:buffer' {
+  /**
+   * @concrete node:buffer#Blob
+   */
+  interface Blob { }
+
+  /**
+   * @concrete node:buffer#File
+   */
+  interface File { }
+}
+
 declare module 'stream' {
   /**
    * @concrete node:stream#Readable
@@ -64,4 +77,11 @@ declare module 'stream/web' {
    * @concrete node:stream/web#ReadableStream
    */
   interface ReadableStream { }
+}
+
+// Remove once node 26 types are released
+declare module 'node:fs' {
+  interface StatOptions {
+    throwIfNoEntry?: boolean;
+  }
 }

package/src/json.ts

@@ -1,27 +1,35 @@
+import { AssertionError } from 'node:assert';
+
 import type { BinaryArray } from './binary.ts';
 import { CodecUtil } from './codec.ts';
 import { RuntimeError, type RuntimeErrorOptions } from './error.ts';
-import { castTo } from './types.ts';
+import { type Any, castTo } from './types.ts';
+
+const VALID_JSON_ERROR_TYPES = ['runtime', 'plain', 'assert'] as const;
+const VALID_JSON_ERROR_TYPE_SET = new Set<unknown>(VALID_JSON_ERROR_TYPES);
 
 type JSONTransformer = (this: unknown, key: string, value: unknown) => unknown;
-type JSONOutputConfig = { indent?: number, replacer?: JSONTransformer };
+type JSONOutputConfig = { indent?: number; replacer?: JSONTransformer };
 type JSONInputConfig = { reviver?: JSONTransformer };
 type JSONCloneConfig = JSONOutputConfig & JSONInputConfig;
-type ErrorShape<T extends string, V> = { $trv: T, message: string, stack?: string } & V;
-type JSONError =
-  ErrorShape<'runtime', RuntimeErrorOptions<Record<string, unknown>>> |
-  ErrorShape<'plain', { name: string }>;
+type JSONError = { $trv: (typeof VALID_JSON_ERROR_TYPES)[number]; name?: string } & Partial<RuntimeErrorOptions<Record<string, unknown>>>;
 
 Object.defineProperty(BigInt.prototype, 'toJSON', {
-  value() { return `${this}n`; },
+  value() {
+    return `${this}n`;
+  }
 });
 
 Object.defineProperty(Error.prototype, 'toJSON', {
-  value() { return JSONUtil.errorToJSONError(this); },
+  value() {
+    return JSONUtil.errorToJSONError(this);
+  }
 });
 
 Object.defineProperty(RuntimeError.prototype, 'toJSON', {
-  value() { return JSONUtil.errorToJSONError(this); },
+  value() {
+    return JSONUtil.errorToJSONError(this);
+  }
 });
 
 const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
@@ -29,7 +37,6 @@ const BIGINT_REGEX = /^-?\d+n$/;
 
 /** Utilities for JSON  */
 export class JSONUtil {
-
   static includeStackTraces = false;
 
   static TRANSMIT_REVIVER: JSONTransformer = function (this: unknown, key: string, value: unknown): unknown {
@@ -45,55 +52,63 @@ export class JSONUtil {
     return value;
   };
 
-
   static isJSONError(value: unknown): value is JSONError {
-    return typeof value === 'object' && value !== null && '$trv' in value && (
-      value.$trv === 'runtime' || value.$trv === 'plain'
-    );
+    return typeof value === 'object' && value !== null && '$trv' in value && VALID_JSON_ERROR_TYPE_SET.has(value.$trv);
   }
 
   /** Convert from JSON object */
-  static jsonErrorToError(error: JSONError): Error | RuntimeError {
-    switch (error.$trv) {
-      case 'runtime': {
-        const { $trv: _, ...rest } = error;
-        const result = new RuntimeError(error.message, castTo<RuntimeErrorOptions<Record<string, unknown>>>(rest));
-        result.stack = error.stack;
-        return result;
-      }
-      case 'plain': {
-        const result = new Error(error.message);
-        result.name = error.name;
-        result.stack = error.stack ?? result.stack;
-        return result;
-      }
+  static jsonErrorToError(error: JSONError): Error {
+    const { $trv, message, stack, name, ...rest } = error;
+    let response: Error;
+    switch ($trv) {
+      case 'runtime':
+        response = new RuntimeError(message!, castTo<Any>(rest));
+        break;
+      case 'assert':
+        response = new AssertionError({ message, ...rest });
+        break;
+      case 'plain':
+        response = new Error(message!);
+        break;
+    }
+    response.stack = stack;
+    if (name) {
+      response.name = name;
     }
+    return response;
   }
 
   /**
    * Serializes an error to a basic object
    */
-  static errorToJSONError(error: RuntimeError | Error, includeStack?: boolean): JSONError | undefined {
+  static errorToJSONError(error: Error, includeStack?: boolean): JSONError | undefined {
     includeStack ??= JSONUtil.includeStackTraces;
-    if (error instanceof RuntimeError) {
-      return {
-        $trv: 'runtime',
-        message: error.message,
-        category: error.category,
-        ...(error.cause ? { cause: `${error.cause}` } : undefined),
-        type: error.type,
-        at: error.at,
-        ...(error.details ? { details: error.details } : undefined!),
-        ...(includeStack ? { stack: error.stack } : undefined)
-      };
-    } else {
-      return {
-        $trv: 'plain',
-        message: error.message,
-        name: error.name,
-        ...(includeStack ? { stack: error.stack } : undefined)
-      };
+    let $trv: JSONError['$trv'];
+    switch (true) {
+      case error instanceof RuntimeError:
+        $trv = 'runtime';
+        break;
+      case error instanceof AssertionError:
+        $trv = 'assert';
+        break;
+      default:
+        $trv = 'plain';
+        break;
     }
+    return {
+      $trv,
+      message: error.message,
+      ...(error.cause ? { cause: `${error.cause}` } : undefined),
+      ...(includeStack ? { stack: error.stack } : undefined),
+      ...(error instanceof RuntimeError
+        ? {
+            category: error.category,
+            type: error.type,
+            at: error.at,
+            ...(error.details ? { details: error.details } : undefined!)
+          }
+        : {})
+    };
   }
 
   /** UTF8 string to JSON */
@@ -152,4 +167,4 @@ export class JSONUtil {
   static cloneFromTransmit<T, R = T>(input: T): R {
     return JSONUtil.clone<T, R>(input, { reviver: JSONUtil.TRANSMIT_REVIVER });
   }
-}
+}

package/src/manifest-index.ts

@@ -1,4 +1,4 @@
 import { ManifestIndex } from '@travetto/manifest';
 
 /** Runtime manifest index */
-export const RuntimeIndex = new ManifestIndex();
+export const RuntimeIndex = new ManifestIndex();

package/src/queue.ts

@@ -2,7 +2,6 @@
  * An asynchronous queue
  */
 export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
-
   #buffer: X[] = [];
   #done = false;
   #ready = Promise.withResolvers<void>();
@@ -59,4 +58,4 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
     this.#ready.reject(error);
     return { value: undefined, done: this.#done };
   }
-}
+}

package/src/resources.ts

@@ -25,4 +25,4 @@ class $RuntimeResources extends FileLoader {
 }
 
 /** Runtime resources */
-export const RuntimeResources = new $RuntimeResources();
+export const RuntimeResources = new $RuntimeResources();

package/src/shutdown.ts

@@ -1,17 +1,21 @@
 import type { ChildProcess } from 'node:child_process';
 
 import { Env } from './env.ts';
-import { Util } from './util.ts';
 import { TimeUtil } from './time.ts';
+import { Util } from './util.ts';
 
-const MAPPING = [['restart', 200], ['error', 1], ['quit', 0]] as const;
-export type ShutdownReason = typeof MAPPING[number][0];
+const MAPPING = [
+  ['restart', 200],
+  ['error', 1],
+  ['quit', 0]
+] as const;
+export type ShutdownReason = (typeof MAPPING)[number][0];
 
 const REASON_TO_CODE = new Map<ShutdownReason, number>(MAPPING);
 const CODE_TO_REASON = new Map<number, ShutdownReason>(MAPPING.map(([k, v]) => [v, k]));
 
 type Handler = (event: Event) => unknown;
-type ShutdownEvent = { reason?: ShutdownReason, mode?: 'exit' | 'interrupt' };
+type ShutdownEvent = { reason?: ShutdownReason; mode?: 'exit' | 'interrupt' };
 
 const isShutdownEvent = (event: unknown): event is ShutdownEvent =>
   typeof event === 'object' && event !== null && 'type' in event && event.type === 'shutdown';
@@ -33,14 +37,20 @@ export class ShutdownManager {
   static #controller = new AbortController();
 
   static {
-    this.#controller.signal.addEventListener = (_: 'abort', listener: Handler): void => { this.#registered.add(listener); };
-    this.#controller.signal.removeEventListener = (_: 'abort', listener: Handler): void => { this.#registered.delete(listener); };
+    this.#controller.signal.addEventListener = (_: 'abort', listener: Handler): void => {
+      this.#registered.add(listener);
+    };
+    this.#controller.signal.removeEventListener = (_: 'abort', listener: Handler): void => {
+      this.#registered.delete(listener);
+    };
     try {
       process
-        .on('message', event => { isShutdownEvent(event) && this.shutdown(event); })
+        .on('message', event => {
+          isShutdownEvent(event) && this.shutdown(event);
+        })
         .on('SIGINT', () => this.shutdown({ mode: 'interrupt' }))
         .on('SIGTERM', () => this.shutdown());
-    } catch { }
+    } catch {}
   }
 
   static get signal(): AbortSignal {
@@ -60,7 +70,7 @@ export class ShutdownManager {
 
   /** Trigger a watch signal signal to a subprocess */
   static async shutdownChild(subprocess: ChildProcess, config?: ShutdownEvent): Promise<void> {
-    subprocess?.send!({ type: 'shutdown', ...config });
+    subprocess?.send?.({ type: 'shutdown', ...config });
   }
 
   /**
@@ -87,10 +97,7 @@ export class ShutdownManager {
     this.#controller.abort('Shutdown started');
     console.debug('Shutdown started', context);
 
-    const winner = await Promise.race([
-      Util.nonBlockingTimeout(timeout).then(() => this),
-      Promise.all([...this.#registered].map(wrapped))
-    ]);
+    const winner = await Promise.race([Util.nonBlockingTimeout(timeout).then(() => this), Promise.all([...this.#registered].map(wrapped))]);
 
     if (winner !== this) {
       console.debug('Shutdown completed', context);
@@ -102,4 +109,4 @@ export class ShutdownManager {
       process.exit();
     }
   }
-}
+}