@travetto/runtime 8.0.0-alpha.9 → 8.0.1

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();
     }
   }
-}
+}

package/src/time.ts

@@ -2,16 +2,32 @@ import { RuntimeError } from './error.ts';
 import { castTo } from './types.ts';
 
 const TIME_UNIT_TO_TEMPORAL_UNIT = {
-  y: 'years', year: 'years', years: 'years',
-  M: 'months', month: 'months', months: 'months',
-  w: 'weeks', week: 'weeks', weeks: 'weeks',
-  d: 'days', day: 'days', days: 'days',
-  h: 'hours', hour: 'hours', hours: 'hours',
-  m: 'minutes', minute: 'minutes', minutes: 'minutes',
-  s: 'seconds', second: 'seconds', seconds: 'seconds',
-  ms: 'milliseconds', millisecond: 'milliseconds', milliseconds: 'milliseconds'
+  y: 'years',
+  year: 'years',
+  years: 'years',
+  M: 'months',
+  month: 'months',
+  months: 'months',
+  w: 'weeks',
+  week: 'weeks',
+  weeks: 'weeks',
+  d: 'days',
+  day: 'days',
+  days: 'days',
+  h: 'hours',
+  hour: 'hours',
+  hours: 'hours',
+  m: 'minutes',
+  minute: 'minutes',
+  minutes: 'minutes',
+  s: 'seconds',
+  second: 'seconds',
+  seconds: 'seconds',
+  ms: 'milliseconds',
+  millisecond: 'milliseconds',
+  milliseconds: 'milliseconds'
 } as const;
-type TemporalUnit = typeof TIME_UNIT_TO_TEMPORAL_UNIT[keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT];
+type TemporalUnit = (typeof TIME_UNIT_TO_TEMPORAL_UNIT)[keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT];
 
 export type TimeSpan = `${number}${keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT}`;
 export type TimeUnit = keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT;
@@ -19,7 +35,6 @@ export type TimeUnit = keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT;
 const TIME_PATTERN = /^(?<amount>-?[0-9]+)(?<unit>(?:year|month|week|day|hour|minute|second|millisecond)s?|y|M|w|d|h|m|s|ms)$/;
 
 export class TimeUtil {
-
   /**
    * Test to see if a string is valid for relative time
    */
@@ -50,20 +65,40 @@ export class TimeUtil {
     }
 
     switch (unit) {
-      case 'years': { unit = 'hours'; value = value * 365 * 24; break; }
-      case 'months': { value = value * 30 * 24; unit = 'hours'; break; }
-      case 'weeks': { value = value * 7 * 24; unit = 'hours'; break; }
-      case 'days': { value = value * 24; unit = 'hours'; break; }
+      case 'years': {
+        unit = 'hours';
+        value = value * 365 * 24;
+        break;
+      }
+      case 'months': {
+        value = value * 30 * 24;
+        unit = 'hours';
+        break;
+      }
+      case 'weeks': {
+        value = value * 7 * 24;
+        unit = 'hours';
+        break;
+      }
+      case 'days': {
+        value = value * 24;
+        unit = 'hours';
+        break;
+      }
     }
 
     const duration = Temporal.Duration.from({ [unit]: value });
     if (outputUnit) {
       const resolved = TIME_UNIT_TO_TEMPORAL_UNIT[outputUnit];
       switch (resolved) {
-        case 'years': return Math.trunc(duration.total('hours') / (365 * 24));
-        case 'months': return Math.trunc(duration.total('hours') / (30 * 24));
-        case 'weeks': return Math.trunc(duration.total('hours') / (7 * 24));
-        default: return Math.trunc(duration.total(resolved));
+        case 'years':
+          return Math.trunc(duration.total('hours') / (365 * 24));
+        case 'months':
+          return Math.trunc(duration.total('hours') / (30 * 24));
+        case 'weeks':
+          return Math.trunc(duration.total('hours') / (7 * 24));
+        default:
+          return Math.trunc(duration.total(resolved));
       }
     } else {
       return duration;
@@ -94,4 +129,4 @@ export class TimeUtil {
       return `${toFixed(seconds)}s`;
     }
   }
-}
+}

package/src/trv.d.ts

@@ -1,38 +1,39 @@
 import { type ManifestModuleRole } from '@travetto/manifest';
+
 import { type TimeSpan } from './time.ts';
 type Role = Exclude<ManifestModuleRole, 'compile'>;
 
 declare module '@travetto/runtime' {
   interface EnvData {
-    /** 
+    /**
      * The node environment we are running in
      * @default development
      */
     NODE_ENV: 'development' | 'production';
-    /** 
+    /**
      * Outputs all console.debug messages, defaults to off
      */
     DEBUG: boolean | string;
-    /** 
+    /**
      * The role we are running as, allows access to additional files from the manifest during runtime.
      */
     TRV_ROLE: Role;
-    /** 
+    /**
      * The folders to use for resource lookup
      */
     TRV_RESOURCES: string[];
-    /** 
+    /**
      * Resource path overrides
      * @private
      */
     TRV_RESOURCE_OVERRIDES: Record<string, string>;
-    /** 
-     * The max time to wait for shutdown to finish after initial SIGINT, 
+    /**
+     * The max time to wait for shutdown to finish after initial SIGINT,
      * @default 2s
      */
     TRV_SHUTDOWN_WAIT: TimeSpan | number;
     /**
-     * The desired runtime module 
+     * The desired runtime module
      */
     TRV_MODULE: string;
     /**
@@ -50,4 +51,4 @@ declare module '@travetto/runtime' {
      */
     TRV_DEBUG_BREAK: boolean;
   }
-}
+}

package/src/types.ts

@@ -1,6 +1,6 @@
 import type { Readable } from 'node:stream';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// biome-ignore lint/suspicious/noExplicitAny: This is the any reference we use explicitly
 export type Any = any;
 
 export type AnyMap = { [key: string]: Any };
@@ -12,7 +12,6 @@ export type TypedFunction<R = Any, V = unknown> = (this: V, ...args: Any[]) => R
 export type MethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<R, V>>;
 export type AsyncMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<Promise<R>, V>>;
 export type AsyncIterableMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<AsyncIterable<R>, V>>;
-export type ClassTDecorator<T extends Class = Class> = (target: T) => T | void;
 
 export type NumericPrimitive = number | bigint;
 export type Primitive = NumericPrimitive | boolean | string;
@@ -21,19 +20,35 @@ export type NumericLikeIntrinsic = Date | NumericPrimitive;
 export type IntrinsicType = Primitive | Date | ArrayBuffer | Uint8Array | Uint16Array | Uint32Array | Readable | Buffer | Blob | File;
 
 export type DeepPartial<T> = {
-  [P in keyof T]?: (T[P] extends (IntrinsicType | undefined) ? (T[P] | undefined) :
-    (T[P] extends Any[] ? (DeepPartial<T[P][number]> | null | undefined)[] : DeepPartial<T[P]>));
+  [P in keyof T]?: T[P] extends IntrinsicType | undefined
+    ? T[P] | undefined
+    : T[P] extends Any[]
+      ? (DeepPartial<T[P][number]> | null | undefined)[]
+      : DeepPartial<T[P]>;
 };
 
 export type ValidFields<T, I> = {
-  [K in keyof T]:
-  (T[K] extends (Primitive | I | undefined) ? K :
-    (T[K] extends (Function | undefined) ? never :
-      K))
+  [K in keyof T]: T[K] extends Primitive | I | undefined ? K : T[K] extends Function | undefined ? never : K;
 }[keyof T];
 
 export type RetainIntrinsicFields<T> = Pick<T, ValidFields<T, IntrinsicType>>;
 
+type KeyPathsInner<T, PrimitiveType = IntrinsicType | IntrinsicType[], PREFIX extends string = '', SEP extends string = '.'> = {
+  [K in keyof T]: K extends string
+    ? T[K] extends IntrinsicType[] | IntrinsicType | undefined
+      ? T[K] extends PrimitiveType
+        ? `${PREFIX}${K}`
+        : never
+      : T[K] extends Any[]
+        ? KeyPathsInner<T[K][number], PrimitiveType, `${K}${SEP}`, SEP>
+        : T[K] extends object
+          ? KeyPathsInner<T[K], PrimitiveType, `${K}${SEP}`, SEP>
+          : never
+    : never;
+}[keyof T];
+
+export type KeyPaths<T, PrimitiveType = IntrinsicType | IntrinsicType[]> = KeyPathsInner<Required<T>, PrimitiveType>;
+
 export const TypedObject: {
   keys<T = unknown, K extends keyof T = keyof T & string>(value: T): K[];
   fromEntries<K extends string | symbol, V>(items: ([K, V] | readonly [K, V])[]): Record<K, V>;
@@ -41,11 +56,9 @@ export const TypedObject: {
   assign<T extends {}, U extends T>(target: T, ...sources: U[]): U;
 } & ObjectConstructor = Object;
 
-export const safeAssign = <T extends {}, U extends {}>(target: T, ...sources: U[]): T & U =>
-  Object.assign(target, ...sources);
+export const safeAssign = <T extends {}, U extends {}>(target: T, ...sources: U[]): T & U => Object.assign(target, ...sources);
 
 export function castTo<T>(input: unknown): T {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return input as T;
 }
 
@@ -55,16 +68,20 @@ export const asFull = <T>(input: Partial<T>): T => castTo(input);
 export const asConstructable = <Z = unknown>(input: Class | unknown): { constructor: Class<Z> } => castTo(input);
 
 export function classConstruct<T>(cls: Class<T>, args: unknown[] = []): ClassInstance<T> {
-  const cons: { new(..._args: Any[]): T } = castTo(cls);
+  const cons: { new (..._args: Any[]): T } = castTo(cls);
   return castTo(new cons(...args));
 }
 
-export const hasFunction = <T>(key: keyof T) => (value: unknown): value is T =>
-  typeof value === 'object' && value !== null && typeof value[castKey(key)] === 'function';
+export const hasFunction =
+  <T>(key: keyof T) =>
+  (value: unknown): value is T =>
+    typeof value === 'object' && value !== null && typeof value[castKey(key)] === 'function';
 
 export const hasToJSON = hasFunction<{ toJSON(): object }>('toJSON');
 
+// biome-ignore lint/complexity/noUselessTypeConstraint: Unknown behaves slightly differently when being used for an inferred type
 export function toConcrete<T extends unknown>(): Class<T> {
+  // biome-ignore lint/complexity/noArguments: We want to use arguments here
   return arguments[0];
 }
 
@@ -80,4 +97,4 @@ export function getParentClass(cls: Class): Class | undefined {
  * Get the class from an instance or class
  */
 export const getClass = <T = unknown>(value: ClassInstance | Class): Class<T> =>
-  'Ⲑid' in value ? castTo(value) : asConstructable<T>(value).constructor;
+  'Ⲑid' in value ? castTo(value) : asConstructable<T>(value).constructor;

package/src/util.ts

@@ -1,20 +1,21 @@
 import timers from 'node:timers/promises';
+
 import { path } from '@travetto/manifest';
 
 import { castTo } from './types.ts';
 
 type MapFn<T, U> = (value: T, i: number) => U | Promise<U>;
-type StackFrame = { message: string, filename: string, line: number, column: number };
+type StackFrame = { message: string; filename: string; line: number; column: number };
 
-const STACK_POSITION_PATTERN = /[(]\s{0,5}(?<filename>[^()]{1,1000}[.]([cm]?[jt]s))([:](?<line>\d{1,10}))?([:](?<column>\d{1,10}))?\s{0,5}[)]/;
+const STACK_POSITION_PATTERN =
+  /[(]\s{0,5}(?<filename>[^()]{1,1000}[.]([cm]?[jt]s))([:](?<line>\d{1,10}))?([:](?<column>\d{1,10}))?\s{0,5}[)]/;
 
 /**
  * Grab bag of common utilities
  */
 export class Util {
-
   static #match<T, K extends unknown[]>(
-    rules: { value: T, positive: boolean }[],
+    rules: { value: T; positive: boolean }[],
     compare: (rule: T, ...compareInput: K) => boolean,
     unmatchedValue: boolean,
     ...input: K
@@ -28,14 +29,14 @@ export class Util {
   }
 
   static #allowDenyRuleInput<T>(
-    rule: (string | T | [value: T, positive: boolean] | [value: T]),
+    rule: string | T | [value: T, positive: boolean] | [value: T],
     convert: (inputRule: string) => T
-  ): { value: T, positive: boolean } {
-    return typeof rule === 'string' ?
-      { value: convert(rule.replace(/^!/, '')), positive: !rule.startsWith('!') } :
-      Array.isArray(rule) ?
-        { value: rule[0], positive: rule[1] ?? true } :
-        { value: rule, positive: true };
+  ): { value: T; positive: boolean } {
+    return typeof rule === 'string'
+      ? { value: convert(rule.replace(/^!/, '')), positive: !rule.startsWith('!') }
+      : Array.isArray(rule)
+        ? { value: rule[0], positive: rule[1] ?? true }
+        : { value: rule, positive: true };
   }
 
   /**
@@ -44,10 +45,9 @@ export class Util {
    */
   static uuid(length: number = 32): string {
     const bytes = crypto.getRandomValues(new Uint8Array(Math.ceil(length / 2)));
-    if (length === 32) { // Make valid uuid-v4
-      // eslint-disable-next-line no-bitwise
+    if (length === 32) {
+      // Make valid uuid-v4
       bytes[6] = (bytes[6] & 0x0f) | 0x40;
-      // eslint-disable-next-line no-bitwise
       bytes[8] = (bytes[8] & 0x3f) | 0x80;
     }
     return bytes.toHex().substring(0, length);
@@ -59,7 +59,7 @@ export class Util {
   static mapAsyncIterable<T, U, V, W>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>, fn3: MapFn<V, W>): AsyncIterable<W>;
   static mapAsyncIterable<T, U, V>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>): AsyncIterable<V>;
   static mapAsyncIterable<T, U>(source: AsyncIterable<T>, fn: MapFn<T, U>): AsyncIterable<U>;
-  static async * mapAsyncIterable<T>(input: AsyncIterable<T>, ...fns: MapFn<unknown, unknown>[]): AsyncIterable<unknown> {
+  static async *mapAsyncIterable<T>(input: AsyncIterable<T>, ...fns: MapFn<unknown, unknown>[]): AsyncIterable<unknown> {
     let idx = -1;
     for await (const item of input) {
       if (item !== undefined) {
@@ -77,14 +77,14 @@ export class Util {
    * Non-blocking timeout
    */
   static nonBlockingTimeout(time: number): Promise<void> {
-    return timers.setTimeout(time, undefined, { ref: false }).catch(() => { });
+    return timers.setTimeout(time, undefined, { ref: false }).catch(() => {});
   }
 
   /**
    * Blocking timeout
    */
   static blockingTimeout(time: number): Promise<void> {
-    return timers.setTimeout(time, undefined, { ref: true }).catch(() => { });
+    return timers.setTimeout(time, undefined, { ref: true }).catch(() => {});
   }
 
   /**
@@ -104,16 +104,14 @@ export class Util {
     compare: (rule: T, ...compareInput: K) => boolean,
     cacheKey?: (...keyInput: K) => string
   ): (...input: K) => boolean {
-
-    const rawRules = (Array.isArray(rules) ? rules : rules.split(/,/g).map(rule => rule.trim()));
+    const rawRules = Array.isArray(rules) ? rules : rules.split(/,/g).map(rule => rule.trim());
     const convertedRules = rawRules.map(rule => this.#allowDenyRuleInput(rule, convert));
     const unmatchedValue = !convertedRules.some(rule => rule.positive);
 
     if (convertedRules.length) {
       if (cacheKey) {
         const cache: Record<string, boolean> = {};
-        return (...input: K) =>
-          cache[cacheKey(...input)] ??= this.#match(convertedRules, compare, unmatchedValue, ...input);
+        return (...input: K) => (cache[cacheKey(...input)] ??= this.#match(convertedRules, compare, unmatchedValue, ...input));
       } else {
         return (...input: K) => this.#match(convertedRules, compare, unmatchedValue, ...input);
       }
@@ -133,7 +131,7 @@ export class Util {
       .split('\n')
       .map(frameText => {
         const match = STACK_POSITION_PATTERN.exec(frameText);
-        if (!match || !match.groups) {
+        if (!match?.groups) {
           return undefined;
         }
         const { filename, line, column } = match.groups;

package/src/watch.ts

@@ -1,10 +1,10 @@
 import type { CompilerEventPayload, CompilerEventType } from '@travetto/compiler';
 
 import { RuntimeError } from './error.ts';
-import { Util } from './util.ts';
 import { RuntimeIndex } from './manifest-index.ts';
 import { ShutdownManager, type ShutdownReason } from './shutdown.ts';
 import { castTo } from './types.ts';
+import { Util } from './util.ts';
 
 type RetryRunState = {
   iteration: number;
@@ -17,25 +17,25 @@ type RetryRunConfig = {
   maxRetries: number;
   maxRetryWindow: number;
   signal?: AbortSignal;
-  onRetry: (state: RetryRunState, config: RetryRunConfig) => (unknown | Promise<unknown>);
+  onRetry: (state: RetryRunState, config: RetryRunConfig) => unknown | Promise<unknown>;
 };
 
 /**
  * Utilities for watching resources
  */
 export class WatchUtil {
-
   /** Compute the delay before restarting */
   static computeRestartDelay(state: RetryRunState, config: RetryRunConfig): number {
-    return state.result === 'error'
-      ? config.maxRetryWindow / (config.maxRetries + 1)
-      : 10;
+    return state.result === 'error' ? config.maxRetryWindow / (config.maxRetries + 1) : 10;
   }
 
   /**
    * Run with restart capability
    */
-  static async runWithRetry(run: (state: RetryRunState & { signal: AbortSignal }) => Promise<ShutdownReason>, options?: Partial<RetryRunConfig>): Promise<void> {
+  static async runWithRetry(
+    run: (state: RetryRunState & { signal: AbortSignal }) => Promise<ShutdownReason>,
+    options?: Partial<RetryRunConfig>
+  ): Promise<void> {
     let retryExhausted = false;
 
     const state: RetryRunState = {
@@ -48,10 +48,9 @@ export class WatchUtil {
       maxRetryWindow: 10 * 1000,
       maxRetries: 10,
       onRetry: () => Util.nonBlockingTimeout(this.computeRestartDelay(state, config)),
-      ...options,
+      ...options
     };
 
-
     outer: while (!ShutdownManager.signal.aborted && !retryExhausted) {
       if (state.iteration > 0) {
         await config.onRetry(state, config);
@@ -59,15 +58,18 @@ export class WatchUtil {
 
       state.result = await run({ ...state, signal: ShutdownManager.signal }).catch(() => 'error' as const);
       switch (state.result) {
-        case 'quit': break outer;
-        case 'error': state.errorIterations += 1; break;
+        case 'quit':
+          break outer;
+        case 'error':
+          state.errorIterations += 1;
+          break;
         case 'restart': {
           state.startTime = Date.now();
           state.errorIterations = 0;
         }
       }
 
-      retryExhausted = (state.errorIterations >= config.maxRetries) || (Date.now() - state.startTime >= config.maxRetryWindow);
+      retryExhausted = state.errorIterations >= config.maxRetries || Date.now() - state.startTime >= config.maxRetryWindow;
       state.iteration += 1;
     }
 
@@ -81,25 +83,27 @@ export class WatchUtil {
     type: K,
     onChange: (input: T) => unknown,
     filter?: (input: T) => boolean,
-    options?: Partial<RetryRunConfig>,
+    options?: Partial<RetryRunConfig>
   ): Promise<void> {
     const { CompilerClient } = await import('@travetto/compiler/src/server/client.ts');
     const client = new CompilerClient(RuntimeIndex.manifest, {
       debug: (...args: unknown[]): void => console.debug(...args),
       info: (...args: unknown[]): void => console.info(...args),
       warn: (...args: unknown[]): void => console.warn(...args),
-      error: (...args: unknown[]): void => console.error(...args),
+      error: (...args: unknown[]): void => console.error(...args)
     });
 
     // pre-check
-    if (!await client.isWatching()) { // If we get here, without a watch
+    if (!(await client.isWatching())) {
+      // If we get here, without a watch
       throw new RuntimeError('Compile Server is not running');
     }
 
     void this.runWithRetry(async ({ signal }) => {
       await client.waitForState(['watch-start'], undefined, signal);
 
-      if (!await client.isWatching()) { // If we get here, without a watch
+      if (!(await client.isWatching())) {
+        // If we get here, without a watch
         return 'error';
       } else {
         for await (const event of client.fetchEvents(type, { signal, enforceIteration: true })) {
@@ -111,4 +115,4 @@ export class WatchUtil {
       }
     }, options);
   }
-}
+}

package/support/patch.js

@@ -1,47 +1,42 @@
-import 'temporal-polyfill-lite/global';
 import fs from 'node:fs/promises';
 
 if (process.env.NODE_ENV !== 'production') {
   process.setSourceMapsEnabled(true); // Ensure source map during compilation/development
   process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps`; // Ensure it passes to children
   Error.stackTraceLimit = 50;
-
-  const ogEmitWarning = process.emitWarning;
-  const exclusions = global.devProcessWarningExclusions = [];
-  process.emitWarning = (message, category, ...other) => {
-    if (exclusions.length === 0 || !exclusions.some(filter => filter(message, category))) {
-      return ogEmitWarning(message, category, ...other);
-    }
-  };
 }
 
-const isError = Error.isError.bind(Error);
-Object.defineProperty(Error, 'isError', {
-  value: (input) => isError(input) || (input instanceof Error)
-});
-
 // polyfills
-
-const [majorVersion, minorVersion] = process.version.replace(/^v/, '').split('.').map(text => parseInt(text, 10));
+if (!globalThis.Temporal) {
+  // For anyone that doesn't have it
+  void import('temporal-polyfill-lite/global');
+}
 
 Map.prototype.getOrInsert ??= function (key, value) {
-  return (this.has(key) || this.set(key, value), this.get(key));
+  if (!this.has(key)) {
+    this.set(key, value);
+  }
+  return this.get(key);
 };
 
 Map.prototype.getOrInsertComputed ??= function (key, compute) {
-  return (this.has(key) || this.set(key, compute()), this.get(key));
+  if (!this.has(key)) {
+    this.set(key, compute());
+  }
+  return this.get(key);
 };
 
 // Allow for the throwIfNoEntry if on a version of node that is less than 25.7
+const [majorVersion, minorVersion] = process.version.match(/\d+/g).map(text => parseInt(text, 10));
 if (majorVersion < 25 || (majorVersion === 25 && minorVersion < 7)) {
   const og = fs.stat;
   Object.defineProperty(fs, 'stat', {
     value: (...args) => {
       const out = og.call(fs, ...args);
       if (typeof args[1] === 'object' && args[1].throwIfNoEntry === false) {
-        return out.catch(() => { });
+        return out.catch(() => {});
       }
       return out;
     }
   });
-}
+}