@travetto/compiler 8.0.0-alpha.20 → 8.0.0-alpha.21

package/README.md

@@ -17,12 +17,12 @@ This module expands upon the [Typescript](https://typescriptlang.org) compiler,
    *  Integration with the [Transformation](https://github.com/travetto/travetto/tree/main/module/transformer#readme "Functionality for AST transformations, with transformer registration, and general utils") module, allowing for rich, type-aware transformations
    *  Automatic conversion to either [Ecmascript Module](https://nodejs.org/api/esm.html) or [CommonJS](https://nodejs.org/api/modules.html) based on the [Package JSON](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) `type` value
    *  Removal of type only imports which can break [Ecmascript Module](https://nodejs.org/api/esm.html)-style output
-   *  Automatic addition of `.js` extension to imports to also support  [Ecmascript Module](https://nodejs.org/api/esm.html)-style output
+   *  Automatic addition of `.js` extension to imports to also support [Ecmascript Module](https://nodejs.org/api/esm.html)-style output
 
 Beyond the [Typescript](https://typescriptlang.org) compiler functionality, the module provides the primary entry point into the development process.
 
 ## CLI
-The compiler cli, [trvc](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trvc.js) is the entry point for compilation-related operations. It has the ability to check for active builds, and ongoing watch operations to ensure only one process is building at a time.  Within the framework, regardless of mono-repo or not, the compilation always targets the entire project.  With the efficient caching behavior, this leads to generally a minimal overhead but allows for centralization of all operations. 
+The compiler cli, [trvc](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trvc.js) is the entry point for compilation-related operations. It has the ability to check for active builds, and ongoing watch operations to ensure only one process is building at a time. Within the framework, regardless of mono-repo or not, the compilation always targets the entire project. With the efficient caching behavior, this leads to generally a minimal overhead but allows for centralization of all operations. 
 
 The compiler cli supports the following operations:
    *  `start` - Run the compiler in watch mode
@@ -36,7 +36,7 @@ The compiler cli supports the following operations:
    *  `manifest [output]` - Generate the project manifest
    *  `manifest:production [output]` - Generate the production project manifest
 
-In addition to the normal output, the compiler supports an environment variable `TRV_BUILD` that supports the following values: `debug`, `info`, `warn` or `none`.  This provides different level of logging during the build process which is helpful to diagnose any odd behaviors.  When invoking an unknown command (e.g. `<other>` from above), the default level is `warn`.  Otherwise the default logging level is `info`.
+In addition to the normal output, the compiler supports an environment variable `TRV_BUILD` that supports the following values: `debug`, `info`, `warn` or `none`. This provides different level of logging during the build process which is helpful to diagnose any odd behaviors. When invoking an unknown command (e.g. `<other>` from above), the default level is `warn`. Otherwise the default logging level is `info`.
 
 **Terminal: Sample trv output with debug logging**
 ```bash

package/__index__.ts

@@ -2,11 +2,11 @@ export * from './src/common.ts';
 export * from './src/compiler.ts';
 export * from './src/event.ts';
 export * from './src/log.ts';
+export * from './src/server/client.ts';
+export * from './src/server/manager.ts';
+export * from './src/server/process-handle.ts';
+export * from './src/server/server.ts';
 export * from './src/state.ts';
 export * from './src/types.ts';
 export * from './src/util.ts';
 export * from './src/watch.ts';
-export * from './src/server/client.ts';
-export * from './src/server/server.ts';
-export * from './src/server/manager.ts';
-export * from './src/server/process-handle.ts';

package/bin/hook.js

@@ -1,6 +1,7 @@
 // @ts-check
-import module from 'node:module';
+
 import { readFileSync } from 'node:fs';
+import module from 'node:module';
 import { fileURLToPath } from 'node:url';
 
 const ogEmitWarning = process.emitWarning.bind(process);
@@ -10,7 +11,7 @@ module.registerHooks({
     if (/[.]tsx?$/.test(url)) {
       const source = readFileSync(fileURLToPath(url), 'utf8');
       try {
-        process.emitWarning = () => { };
+        process.emitWarning = () => {};
         return { format: 'module', source: module.stripTypeScriptTypes(source), shortCircuit: true };
       } finally {
         process.emitWarning = ogEmitWarning;
@@ -19,4 +20,4 @@ module.registerHooks({
       return nextLoad(url, context);
     }
   }
-});
+});

package/bin/trvc-target.js

@@ -1,5 +1,6 @@
 // @ts-check
 import '@travetto/runtime/support/patch.js';
 import './hook.js';
+
 const { Compiler } = await import('../src/compiler.ts');
-await Compiler.main();
+await Compiler.main();

package/bin/trvc.js

@@ -2,5 +2,6 @@
 // @ts-check
 import '@travetto/runtime/support/patch.js';
 import './hook.js';
+
 const { invoke } = await import('@travetto/compiler/support/invoke.ts');
-await invoke(...process.argv.slice(2));
+await invoke(...process.argv.slice(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "8.0.0-alpha.20",
+  "version": "8.0.0-alpha.21",
   "type": "module",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
@@ -31,11 +31,11 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.5.6",
-    "@travetto/manifest": "^8.0.0-alpha.10",
-    "@travetto/transformer": "^8.0.0-alpha.13"
+    "@travetto/manifest": "^8.0.0-alpha.11",
+    "@travetto/transformer": "^8.0.0-alpha.14"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.26"
+    "@travetto/cli": "^8.0.0-alpha.28"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/common.ts

@@ -6,11 +6,14 @@ import { type ManifestContext, path } from '@travetto/manifest';
 import { Log } from './log.ts';
 
 export class CommonUtil {
-
   /**
    * Restartable Event Stream
    */
-  static async * restartableEvents<T>(input: (signal: AbortSignal) => AsyncIterable<T>, parent: AbortSignal, shouldRestart: (item: T) => boolean): AsyncIterable<T> {
+  static async *restartableEvents<T>(
+    input: (signal: AbortSignal) => AsyncIterable<T>,
+    parent: AbortSignal,
+    shouldRestart: (item: T) => boolean
+  ): AsyncIterable<T> {
     const log = Log.scoped('event-stream');
     outer: while (!parent.aborted) {
       const controller = new AbortController();
@@ -37,7 +40,8 @@ export class CommonUtil {
       log.debug('Finished event stream');
 
       // Natural exit, we done
-      if (!controller.signal.aborted) { // Shutdown source if still running
+      if (!controller.signal.aborted) {
+        // Shutdown source if still running
         controller.abort();
       }
       return;
@@ -48,14 +52,14 @@ export class CommonUtil {
    * 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(() => {});
   }
 
   /**
@@ -76,8 +80,10 @@ export class CommonUtil {
    * Write to stdout with backpressure handling
    */
   static async writeStdout(level: number, data: unknown): Promise<void> {
-    if (data === undefined) { return; }
+    if (data === undefined) {
+      return;
+    }
     process.stdout.write(`${JSON.stringify(data, undefined, level)}\n`) ||
-      await new Promise(resolve => process.stdout.once('drain', resolve));
-  };
-}
+      (await new Promise(resolve => process.stdout.once('drain', resolve)));
+  }
+}

package/src/compiler.ts

@@ -1,15 +1,14 @@
-import fs from 'node:fs/promises';
 import { setMaxListeners } from 'node:events';
+import fs from 'node:fs/promises';
 
-import { getManifestContext, ManifestDeltaUtil, ManifestIndex, ManifestUtil, type DeltaEvent } from '@travetto/manifest';
+import { type DeltaEvent, getManifestContext, ManifestDeltaUtil, ManifestIndex, ManifestUtil } from '@travetto/manifest';
 
-import { CompilerState } from './state.ts';
-import { CompilerWatcher } from './watch.ts';
-import { type CompileEmitEvent, CompilerReset } from './types.ts';
+import { CommonUtil } from './common.ts';
 import { EventUtil } from './event.ts';
-
 import { IpcLogger } from './log.ts';
-import { CommonUtil } from './common.ts';
+import { CompilerState } from './state.ts';
+import { type CompileEmitEvent, CompilerReset } from './types.ts';
+import { CompilerWatcher } from './watch.ts';
 
 const log = new IpcLogger({ level: 'debug' });
 
@@ -17,7 +16,6 @@ const log = new IpcLogger({ level: 'debug' });
  * Compilation support
  */
 export class Compiler {
-
   /**
    * Run compiler as a main entry point
    */
@@ -44,9 +42,7 @@ export class Compiler {
     this.#shutdownController = new AbortController();
     this.#shutdownSignal = this.#shutdownController.signal;
     setMaxListeners(1000, this.#shutdownSignal);
-    process
-      .once('disconnect', () => this.#shutdown('manual'))
-      .on('message', event => (event === 'shutdown') && this.#shutdown('manual'));
+    process.once('disconnect', () => this.#shutdown('manual')).on('message', event => event === 'shutdown' && this.#shutdown('manual'));
   }
 
   #shutdown(mode: 'error' | 'manual' | 'complete' | 'reset', errorMessage?: string): void {
@@ -111,7 +107,7 @@ export class Compiler {
   /**
    * Emit all files as a stream
    */
-  async * emit(files: string[]): AsyncIterable<CompileEmitEvent> {
+  async *emit(files: string[]): AsyncIterable<CompileEmitEvent> {
     let i = 0;
     let lastSent = Date.now();
 
@@ -122,8 +118,9 @@ export class Compiler {
       const nodeModSeparator = 'node_modules/';
       const nodeModIdx = file.lastIndexOf(nodeModSeparator);
       const imp = nodeModIdx >= 0 ? file.substring(nodeModIdx + nodeModSeparator.length) : file;
-      yield { file: imp, i: i += 1, errors, total: files.length, duration };
-      if ((Date.now() - lastSent) > 50) { // Limit to 1 every 50ms
+      yield { file: imp, i: (i += 1), errors, total: files.length, duration };
+      if (Date.now() - lastSent > 50) {
+        // Limit to 1 every 50ms
         lastSent = Date.now();
         EventUtil.sendEvent('progress', { total: files.length, idx: i, message: imp, operation: 'compile' });
       }
@@ -154,7 +151,7 @@ export class Compiler {
 
     const metrics: CompileEmitEvent[] = [];
     const isCompilerChanged = this.#deltaEvents.some(event => this.#state.isCompilerFile(event.sourceFile));
-    const changedFiles = (isCompilerChanged ? this.#state.getAllFiles() : this.#deltaEvents.map(event => event.sourceFile));
+    const changedFiles = isCompilerChanged ? this.#state.getAllFiles() : this.#deltaEvents.map(event => event.sourceFile);
 
     if (changedFiles.length) {
       for await (const event of this.emit(changedFiles)) {
@@ -174,9 +171,9 @@ export class Compiler {
         log.debug('Compilation aborted');
       } else if (failures.size) {
         const sortedFailures = [...failures.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-        log.error('Compilation failed',
-          ['', sortedFailures.flatMap(([file, count]) => `- ${file}: ${count} errors found`)]
-            .flat(3).join('\n')
+        log.error(
+          'Compilation failed',
+          ['', sortedFailures.flatMap(([file, count]) => `- ${file}: ${count} errors found`)].flat(3).join('\n')
         );
       } else {
         log.debug('Compilation succeeded');
@@ -249,4 +246,4 @@ export class Compiler {
 
     this.#shutdown('complete');
   }
-}
+}

package/src/event.ts

@@ -3,14 +3,16 @@ import type { CompilerEvent, CompilerEventPayload, CompilerEventType } from './t
 const VALID_EVENT_TYPES = new Set<CompilerEventType>(['change', 'log', 'progress', 'state', 'all', 'file']);
 
 export class EventUtil {
-
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   static isComplilerEventType = (value: string): value is CompilerEventType => VALID_EVENT_TYPES.has(value as CompilerEventType);
 
   static isCompilerEvent = (value: unknown): value is CompilerEvent =>
-    typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string' && EventUtil.isComplilerEventType(value.type);
+    typeof value === 'object' &&
+    value !== null &&
+    'type' in value &&
+    typeof value.type === 'string' &&
+    EventUtil.isComplilerEventType(value.type);
 
   static sendEvent<K extends CompilerEventType, T extends CompilerEventPayload<K>>(type: K, payload: T): void {
-    process.connected && process.send!({ type, payload }, undefined, undefined, () => { });
+    process.connected && process.send!({ type, payload }, undefined, undefined, () => {});
   }
-}
+}

package/src/log.ts

@@ -15,7 +15,6 @@ export type LogShape = Record<'info' | 'debug' | 'warn' | 'error', (message: str
 const ESC = '\x1b[';
 
 export class Logger implements LogConfig, LogShape {
-
   static #linePartial: boolean | undefined;
 
   /** Rewrite text line, tracking cleanup as necessary */
@@ -23,7 +22,8 @@ export class Logger implements LogConfig, LogShape {
     if ((!text && !this.#linePartial) || !process.stdout.isTTY) {
       return;
     }
-    if (this.#linePartial === undefined) { // First time
+    if (this.#linePartial === undefined) {
+      // First time
       process.stdout.write(`${ESC}?25l`); // Hide cursor
       process.on('exit', () => this.reset());
     }
@@ -35,7 +35,9 @@ export class Logger implements LogConfig, LogShape {
     }
   }
 
-  static reset(): void { process.stdout.write(`${ESC}!p${ESC}?25h`); }
+  static reset(): void {
+    process.stdout.write(`${ESC}!p${ESC}?25h`);
+  }
 
   level?: CompilerLogLevel | 'none';
   root: string = process.cwd();
@@ -47,28 +49,38 @@ export class Logger implements LogConfig, LogShape {
   }
 
   valid(event: CompilerLogEvent): boolean {
-    return LEVEL_TO_PRIORITY[this.level ?? this.parent?.level!] <= LEVEL_TO_PRIORITY[event.level];
+    return LEVEL_TO_PRIORITY[this.level ?? this.parent?.level ?? 'none'] <= LEVEL_TO_PRIORITY[event.level];
   }
 
   /** Log event with filtering by level */
   render(event: CompilerLogEvent): void {
-    if (!this.valid(event)) { return; }
-    const params = [event.message, ...event.args ?? []]
-      .map(arg => typeof arg === 'string' ? arg.replaceAll(this.root ?? this.parent?.root!, '.') : arg);
+    if (!this.valid(event)) {
+      return;
+    }
+    const params = [event.message, ...(event.args ?? [])].map(arg =>
+      typeof arg === 'string' ? arg.replaceAll(this.root ?? this.parent?.root, '.') : arg
+    );
 
     if (event.scope ?? this.scope) {
       params.unshift(`[${(event.scope ?? this.scope!).padEnd(SCOPE_MAX, ' ')}]`);
     }
     params.unshift(new Date().toISOString(), `${event.level.padEnd(5)}`);
     Logger.rewriteLine(''); // Clear out progress line, if active
-    // eslint-disable-next-line no-console
     console[event.level]!(...params);
   }
 
-  info(message: string, ...args: unknown[]): void { return this.render({ level: 'info', message, args }); }
-  debug(message: string, ...args: unknown[]): void { return this.render({ level: 'debug', message, args }); }
-  warn(message: string, ...args: unknown[]): void { return this.render({ level: 'warn', message, args }); }
-  error(message: string, ...args: unknown[]): void { return this.render({ level: 'error', message, args }); }
+  info(message: string, ...args: unknown[]): void {
+    this.render({ level: 'info', message, args });
+  }
+  debug(message: string, ...args: unknown[]): void {
+    this.render({ level: 'debug', message, args });
+  }
+  warn(message: string, ...args: unknown[]): void {
+    this.render({ level: 'warn', message, args });
+  }
+  error(message: string, ...args: unknown[]): void {
+    this.render({ level: 'error', message, args });
+  }
 }
 
 class $RootLogger extends Logger {
@@ -86,9 +98,17 @@ class $RootLogger extends Logger {
   initLevel(defaultLevel: CompilerLogLevel | 'none'): void {
     const value = process.env.TRV_QUIET !== 'true' ? process.env.TRV_BUILD : 'none';
     switch (value) {
-      case 'debug': case 'warn': case 'error': case 'info': this.level = value; break;
-      case undefined: this.level = defaultLevel; break;
-      case 'none': default: this.level = 'none';
+      case 'debug':
+      case 'warn':
+      case 'error':
+      case 'info':
+        this.level = value;
+        break;
+      case undefined:
+        this.level = defaultLevel;
+        break;
+      default:
+        this.level = 'none';
     }
   }
 
@@ -100,21 +120,34 @@ class $RootLogger extends Logger {
   /** Scope and provide a callback pattern for access to a logger */
   wrap<T = unknown>(scope: string, operation: (log: Logger) => Promise<T>, basic = true): Promise<T> {
     const logger = this.scoped(scope);
-    return basic ? (logger.debug('Started'), operation(logger).finally(() => logger.debug('Completed'))) : operation(logger);
+    if (basic) {
+      logger.debug('Started');
+      return operation(logger).finally(() => logger.debug('Completed'));
+    } else {
+      return operation(logger);
+    }
   }
 
   /** Write progress event, if active */
   onProgressEvent(event: CompilerProgressEvent): void | Promise<void> {
-    if (!(this.logProgress)) { return; }
-    const progress = Math.trunc(event.idx * 100 / event.total);
-    const text = event.complete ? '' : `Compiling [${'#'.repeat(Math.trunc(progress / 10)).padEnd(10, ' ')}] [${event.idx}/${event.total}] ${event.message}`;
+    if (!this.logProgress) {
+      return;
+    }
+    const progress = Math.trunc((event.idx * 100) / event.total);
+    const text = event.complete
+      ? ''
+      : `Compiling [${'#'.repeat(Math.trunc(progress / 10)).padEnd(10, ' ')}] [${event.idx}/${event.total}] ${event.message}`;
     return Logger.rewriteLine(text);
   }
 
   /** Write all progress events if active */
   async consumeProgressEvents(input: () => AsyncIterable<CompilerProgressEvent>): Promise<void> {
-    if (!(this.logProgress)) { return; }
-    for await (const event of input()) { this.onProgressEvent(event); }
+    if (!this.logProgress) {
+      return;
+    }
+    for await (const event of input()) {
+      this.onProgressEvent(event);
+    }
     Logger.reset();
   }
 }
@@ -123,7 +156,9 @@ export const Log = new $RootLogger();
 
 export class IpcLogger extends Logger {
   render(event: CompilerLogEvent): void {
-    if (!this.valid(event)) { return; }
+    if (!this.valid(event)) {
+      return;
+    }
     if (process.connected && process.send) {
       process.send({ type: 'log', payload: event });
     }

package/src/queue.ts

@@ -10,7 +10,9 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
     }
   }
 
-  [Symbol.asyncIterator](): AsyncIterator<X> { return this; }
+  [Symbol.asyncIterator](): AsyncIterator<X> {
+    return this;
+  }
 
   async next(): Promise<IteratorResult<X>> {
     while (!this.#done && !this.#queue.length) {
@@ -35,4 +37,4 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
     this.#done = true;
     this.#ready.resolve();
   }
-}
+}

package/src/server/client.ts

@@ -1,13 +1,13 @@
-import rl from 'node:readline/promises';
-import timers from 'node:timers/promises';
 import fs from 'node:fs/promises';
 import http, { Agent } from 'node:http';
+import rl from 'node:readline/promises';
+import timers from 'node:timers/promises';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerEventPayload, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types.ts';
-import type { LogShape } from '../log.ts';
 import { CommonUtil } from '../common.ts';
+import type { LogShape } from '../log.ts';
+import type { CompilerEventPayload, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types.ts';
 import { ProcessHandle } from './process-handle.ts';
 
 type FetchEventsConfig<T> = {
@@ -26,7 +26,6 @@ const streamAgent = new Agent({
  * Compiler Client Operations
  */
 export class CompilerClient {
-
   #url: string;
   #log: LogShape;
   #handle: Record<'compiler' | 'server', ProcessHandle>;
@@ -47,17 +46,18 @@ export class CompilerClient {
     return this.#url;
   }
 
-  async #fetch(urlPath: string, options?: RequestInit & { timeout?: number }, logTimeout = true): Promise<{ ok: boolean, text: string }> {
+  async #fetch(urlPath: string, options?: RequestInit & { timeout?: number }, logTimeout = true): Promise<{ ok: boolean; text: string }> {
     const controller = new AbortController();
     const timeoutController = new AbortController();
 
     options?.signal?.addEventListener('abort', () => controller.abort());
-    timers.setTimeout(options?.timeout ?? 100, undefined, { ref: false, signal: timeoutController.signal })
+    timers
+      .setTimeout(options?.timeout ?? 100, undefined, { ref: false, signal: timeoutController.signal })
       .then(() => {
         logTimeout && this.#log.error(`Timeout on request to ${this.#url}${urlPath}`);
         controller.abort('TIMEOUT');
       })
-      .catch(() => { });
+      .catch(() => {});
     const response = await fetch(`${this.#url}${urlPath}`, { ...options, signal: controller.signal });
     const out = { ok: response.ok, text: await response.text() };
     timeoutController.abort();
@@ -66,7 +66,10 @@ export class CompilerClient {
 
   /** Get server information, if server is running */
   info(): Promise<CompilerServerInfo | undefined> {
-    return this.#fetch('/info', { timeout: 200 }, false).then(response => JSON.parse(response.text), () => undefined);
+    return this.#fetch('/info', { timeout: 200 }, false).then(
+      response => JSON.parse(response.text),
+      () => undefined
+    );
   }
 
   async isWatching(): Promise<boolean> {
@@ -75,13 +78,19 @@ export class CompilerClient {
 
   /** Clean the server */
   async clean(forceOnFailure?: boolean): Promise<boolean> {
-    const result = await this.#fetch('/clean', { timeout: 300 }).then(response => response.ok, () => false);
+    const result = await this.#fetch('/clean', { timeout: 300 }).then(
+      response => response.ok,
+      () => false
+    );
     if (!result && forceOnFailure) {
       this.#log.warn('Clean request failed, forcing cleanup');
       try {
-        await Promise.all([this.#ctx.build.outputFolder, this.#ctx.build.typesFolder]
-          .map(file => fs.rm(CommonUtil.resolveWorkspace(this.#ctx, file), { force: true, recursive: true })));
-      } catch { }
+        await Promise.all(
+          [this.#ctx.build.outputFolder, this.#ctx.build.typesFolder].map(file =>
+            fs.rm(CommonUtil.resolveWorkspace(this.#ctx, file), { force: true, recursive: true })
+          )
+        );
+      } catch {}
     }
     return result;
   }
@@ -91,18 +100,20 @@ export class CompilerClient {
     const info = await this.info();
     if (!info) {
       this.#log.debug('Stopping server, info not found, manual killing');
-      return Promise.all([this.#handle.server.kill(), this.#handle.compiler.kill()])
-        .then(results => results.some(result => result));
+      return Promise.all([this.#handle.server.kill(), this.#handle.compiler.kill()]).then(results => results.some(result => result));
     }
 
-    await this.#fetch('/stop').catch(() => { }); // Trigger
+    await this.#fetch('/stop').catch(() => {}); // Trigger
     this.#log.debug('Waiting for compiler to exit');
     await this.#handle.compiler.ensureKilled();
     return true;
   }
 
   /** Fetch compiler events */
-  async * fetchEvents<V extends CompilerEventType, T extends CompilerEventPayload<V>>(type: V, config: FetchEventsConfig<T> = {}): AsyncIterable<T> {
+  async *fetchEvents<V extends CompilerEventType, T extends CompilerEventPayload<V>>(
+    type: V,
+    config: FetchEventsConfig<T> = {}
+  ): AsyncIterable<T> {
     let info = await this.info();
     if (!info) {
       return;
@@ -121,14 +132,13 @@ export class CompilerClient {
 
     const { iteration } = info;
 
-    for (; ;) {
+    for (;;) {
       const controller = new AbortController();
       const quit = (): void => controller.abort();
       try {
         signal.addEventListener('abort', quit);
         const response = await new Promise<http.IncomingMessage>((resolve, reject) =>
-          http.get(`${this.#url}/event/${type}`, { agent: streamAgent, signal: controller.signal }, resolve)
-            .on('error', reject)
+          http.get(`${this.#url}/event/${type}`, { agent: streamAgent, signal: controller.signal }, resolve).on('error', reject)
         );
 
         for await (const line of rl.createInterface(response)) {
@@ -143,7 +153,9 @@ export class CompilerClient {
         }
       } catch (error) {
         const aborted = controller.signal.aborted || (typeof error === 'object' && error && 'code' in error && error.code === 'ECONNRESET');
-        if (!aborted) { throw error; }
+        if (!aborted) {
+          throw error;
+        }
       }
       signal.removeEventListener('abort', quit);
 
@@ -156,7 +168,8 @@ export class CompilerClient {
         return;
       }
 
-      if (controller.signal.aborted || !info || (config.enforceIteration && info.iteration !== iteration)) { // If health check fails, or aborted
+      if (controller.signal.aborted || !info || (config.enforceIteration && info.iteration !== iteration)) {
+        // If health check fails, or aborted
         this.#log.debug(`Stopping watch for events of type "${type}"`);
         return;
       } else {
@@ -170,10 +183,11 @@ export class CompilerClient {
     const set = new Set(states);
     // Loop until
     this.#log.debug(`Waiting for states, ${states.join(', ')}`);
-    for await (const _ of this.fetchEvents('state', { signal, until: event => set.has(event.state) })) { }
+    for await (const _ of this.fetchEvents('state', { signal, until: event => set.has(event.state) })) {
+    }
     this.#log.debug(`Found state, one of ${states.join(', ')} `);
     if (message) {
       this.#log.info(message);
     }
   }
-}
+}