@travetto/compiler 7.0.0-rc.0 → 7.0.0-rc.2

package/src/watch.ts

@@ -19,15 +19,15 @@ export class CompilerWatcher {
   #cleanup: Partial<Record<'tool' | 'workspace' | 'canary', () => (void | Promise<void>)>> = {};
   #watchCanary: string = '.trv/canary.id';
   #lastWorkspaceModified = Date.now();
-  #watchCanaryFreq = 5;
+  #watchCanaryFrequency = 5;
   #root: string;
-  #q: AsyncQueue<CompilerWatchEvent>;
+  #queue: AsyncQueue<CompilerWatchEvent>;
 
   constructor(state: CompilerState, signal: AbortSignal) {
     this.#state = state;
     this.#root = state.manifest.workspace.path;
-    this.#q = new AsyncQueue(signal);
-    signal.addEventListener('abort', () => Object.values(this.#cleanup).forEach(x => x()));
+    this.#queue = new AsyncQueue(signal);
+    signal.addEventListener('abort', () => Object.values(this.#cleanup).forEach(fn => fn()));
   }
 
   async #getWatchIgnores(): Promise<string[]> {
@@ -53,7 +53,7 @@ export class CompilerWatcher {
         ignores.add(item);
       }
     }
-    return [...ignores].toSorted().map(x => x.endsWith('/') ? x : `${x}/`);
+    return [...ignores].toSorted().map(ignore => ignore.endsWith('/') ? ignore : `${ignore}/`);
   }
 
   #toCandidateEvent(action: CompilerWatchEvent['action'], file: string): CompilerWatchEventCandidate {
@@ -69,16 +69,16 @@ export class CompilerWatcher {
     return { entry, file: entry?.sourceFile ?? file, action };
   }
 
-  #isValidEvent(ev: CompilerWatchEventCandidate): ev is CompilerWatchEvent {
-    const relativeFile = ev.file.replace(`${this.#root}/`, '');
+  #isValidEvent(event: CompilerWatchEventCandidate): event is CompilerWatchEvent {
+    const relativeFile = event.file.replace(`${this.#root}/`, '');
     if (relativeFile === this.#watchCanary) {
       return false;
     } else if (relativeFile.startsWith('.')) {
       return false;
-    } else if (!ev.entry) {
+    } else if (!event.entry) {
       log.debug(`Skipping unknown file ${relativeFile}`);
       return false;
-    } else if (ev.action === 'update' && !this.#state.checkIfSourceChanged(ev.entry.sourceFile)) {
+    } else if (event.action === 'update' && !this.#state.checkIfSourceChanged(event.entry.sourceFile)) {
       log.debug(`Skipping update, as contents unchanged ${relativeFile}`);
       return false;
     } else if (!CompilerUtil.validFile(ManifestModuleUtil.getFileType(relativeFile))) {
@@ -89,19 +89,19 @@ export class CompilerWatcher {
 
   #getManifestUpdateEventsByParents(events: CompilerWatchEvent[]): Map<string, CompilerWatchEvent[]> {
     const eventsByMod = new Map<string, CompilerWatchEvent[]>();
-    for (const ev of events) {
-      if (ev.action === 'update') {
+    for (const event of events) {
+      if (event.action === 'update') {
         continue;
       }
 
-      const mod = ev.entry.module;
-      const moduleSet = new Set(this.#state.manifestIndex.getDependentModules(mod.name, 'parents').map(x => x.name));
+      const mod = event.entry.module;
+      const moduleSet = new Set(this.#state.manifestIndex.getDependentModules(mod.name, 'parents').map(indexedMod => indexedMod.name));
       moduleSet.add(this.#state.manifest.workspace.name);
-      for (const m of moduleSet) {
-        if (!eventsByMod.has(m)) {
-          eventsByMod.set(m, []);
+      for (const moduleName of moduleSet) {
+        if (!eventsByMod.has(moduleName)) {
+          eventsByMod.set(moduleName, []);
         }
-        eventsByMod.get(m)!.push(ev);
+        eventsByMod.get(moduleName)!.push(event);
       }
     }
     return eventsByMod;
@@ -120,7 +120,7 @@ export class CompilerWatcher {
     const roleType = ManifestModuleUtil.getFileRole(relativeFile)!;
 
     const manifestModuleFiles = manifest.modules[moduleName].files[folderKey] ??= [];
-    const idx = manifestModuleFiles.findIndex(x => x[0] === relativeFile);
+    const idx = manifestModuleFiles.findIndex(indexedFile => indexedFile[0] === relativeFile);
     const wrappedIdx = idx < 0 ? manifestModuleFiles.length : idx;
 
     switch (action) {
@@ -137,8 +137,8 @@ export class CompilerWatcher {
       const moduleManifest = ManifestUtil.readManifestSync(manifestLocation);
 
       log.debug('Updating manifest', { module: mod, events: events.length });
-      for (const ev of events) {
-        this.#updateManifestForEvent(ev, moduleManifest);
+      for (const event of events) {
+        this.#updateManifestForEvent(event, moduleManifest);
       }
       await ManifestUtil.writeManifest(moduleManifest);
     }
@@ -149,44 +149,44 @@ export class CompilerWatcher {
   async #listenWorkspace(): Promise<void> {
     const lib = await import('@parcel/watcher');
     const ignore = await this.#getWatchIgnores();
-    const packageFiles = new Set(['package-lock.json', 'yarn.lock', 'package.json'].map(x => path.resolve(this.#root, x)));
+    const packageFiles = new Set(['package-lock.json', 'yarn.lock', 'package.json'].map(file => path.resolve(this.#root, file)));
 
     log.debug('Ignore Globs', ignore);
     log.debug('Watching', this.#root);
 
     await this.#cleanup.workspace?.();
 
-    const listener = await lib.subscribe(this.#root, async (err, events) => {
+    const listener = await lib.subscribe(this.#root, async (error, events) => {
       this.#lastWorkspaceModified = Date.now();
 
       try {
-        if (err) {
-          throw err instanceof Error ? err : new Error(`${err}`);
+        if (error) {
+          throw error instanceof Error ? error : new Error(`${error}`);
         } else if (events.length > 25) {
           throw new CompilerReset(`Large influx of file changes: ${events.length}`);
-        } else if (events.some(ev => packageFiles.has(path.toPosix(ev.path)))) {
+        } else if (events.some(event => packageFiles.has(path.toPosix(event.path)))) {
           throw new CompilerReset('Package information changed');
         }
 
         const items = events
-          .map(x => this.#toCandidateEvent(x.type, path.toPosix(x.path)))
-          .filter(x => this.#isValidEvent(x));
+          .map(event => this.#toCandidateEvent(event.type, path.toPosix(event.path)))
+          .filter(event => this.#isValidEvent(event));
 
         try {
           await this.#reconcileManifestUpdates(items);
-        } catch (mErr) {
-          log.info('Restarting due to manifest rebuild failure', mErr);
-          throw new CompilerReset(`Manifest rebuild failure: ${mErr}`);
+        } catch (manifestError) {
+          log.info('Restarting due to manifest rebuild failure', manifestError);
+          throw new CompilerReset(`Manifest rebuild failure: ${manifestError}`);
         }
 
         for (const item of items) {
-          this.#q.add(item);
+          this.#queue.add(item);
         }
       } catch (out) {
         if (out instanceof Error && out.message.includes('Events were dropped by the FSEvents client.')) {
           out = new CompilerReset('FSEvents failure, requires restart');
         }
-        return this.#q.throw(out instanceof Error ? out : new Error(`${out}`));
+        return this.#queue.throw(out instanceof Error ? out : new Error(`${out}`));
       }
     }, { ignore });
 
@@ -198,20 +198,20 @@ export class CompilerWatcher {
     const toolRootFolder = path.dirname(path.resolve(this.#root, build.compilerFolder));
     const toolFolders = new Set([
       toolRootFolder, build.compilerFolder, build.typesFolder, build.outputFolder
-    ].map(x => path.resolve(this.#root, x)));
+    ].map(folder => path.resolve(this.#root, folder)));
 
-    log.debug('Tooling Folders', [...toolFolders].map(x => x.replace(`${this.#root}/`, '')));
+    log.debug('Tooling Folders', [...toolFolders].map(folder => folder.replace(`${this.#root}/`, '')));
 
     await this.#cleanup.tool?.();
 
-    const listener = watch(toolRootFolder, { encoding: 'utf8' }, async (ev, f) => {
-      if (!f) {
+    const listener = watch(toolRootFolder, { encoding: 'utf8' }, async (event, file) => {
+      if (!file) {
         return;
       }
-      const full = path.resolve(toolRootFolder, f);
+      const full = path.resolve(toolRootFolder, file);
       const stat = await fs.stat(full).catch(() => null);
       if (toolFolders.has(full) && !stat) {
-        this.#q.throw(new CompilerReset(`Tooling folder removal ${full}`));
+        this.#queue.throw(new CompilerReset(`Tooling folder removal ${full}`));
       }
     });
     this.#cleanup.tool = (): void => listener.close();
@@ -228,15 +228,15 @@ export class CompilerWatcher {
       if (delta > 600) {
         log.error('Restarting canary due to extra long delay');
         this.#lastWorkspaceModified = Date.now(); // Reset
-      } else if (delta > this.#watchCanaryFreq * 2) {
-        this.#q.throw(new CompilerReset(`Workspace watch stopped responding ${delta}s ago`));
-      } else if (delta > this.#watchCanaryFreq) {
+      } else if (delta > this.#watchCanaryFrequency * 2) {
+        this.#queue.throw(new CompilerReset(`Workspace watch stopped responding ${delta}s ago`));
+      } else if (delta > this.#watchCanaryFrequency) {
         log.error('Restarting parcel due to inactivity');
         await this.#listenWorkspace();
       } else {
         await fs.utimes(full, new Date(), new Date());
       }
-    }, this.#watchCanaryFreq * 1000);
+    }, this.#watchCanaryFrequency * 1000);
 
     this.#cleanup.canary = (): void => clearInterval(canaryId);
   }
@@ -247,6 +247,6 @@ export class CompilerWatcher {
       this.#listenToolFolder();
       this.#listenCanary();
     }
-    return this.#q[Symbol.asyncIterator]();
+    return this.#queue[Symbol.asyncIterator]();
   }
 }

package/support/entry.main.ts

@@ -19,8 +19,8 @@ export const main = (ctx: ManifestContext) => {
   Log.initLevel('error');
 
   /** Main entry point for compilation */
-  const compile = async (op: CompilerMode, setupOnly = false): Promise<void> => {
-    const server = await new CompilerServer(ctx, op).listen();
+  const compile = async (operation: CompilerMode, setupOnly = false): Promise<void> => {
+    const server = await new CompilerServer(ctx, operation).listen();
     const log = Log.scoped('main');
 
     // Wait for build to be ready
@@ -29,20 +29,20 @@ export const main = (ctx: ManifestContext) => {
       await server.processEvents(async function* (signal) {
         const changed = await CompilerSetup.setup(ctx);
         if (!setupOnly) {
-          yield* CompilerRunner.runProcess(ctx, changed, op, signal);
+          yield* CompilerRunner.runProcess(ctx, changed, operation, signal);
         }
       });
       log.debug('End Server');
     } else {
       log.info('Server already running, waiting for initial compile to complete');
-      const ctrl = new AbortController();
-      Log.consumeProgressEvents(() => client.fetchEvents('progress', { until: ev => !!ev.complete, signal: ctrl.signal }));
+      const controller = new AbortController();
+      Log.consumeProgressEvents(() => client.fetchEvents('progress', { until: event => !!event.complete, signal: controller.signal }));
       await client.waitForState(['compile-end', 'watch-start'], 'Successfully built');
-      ctrl.abort();
+      controller.abort();
     }
   };
 
-  const ops = {
+  const operations = {
     /** Stop the server */
     async stop(): Promise<void> {
       if (await client.stop()) {
@@ -53,7 +53,7 @@ export const main = (ctx: ManifestContext) => {
     },
 
     /** Restart the server */
-    async restart(): Promise<void> { await client.stop().then(() => ops.watch()); },
+    async restart(): Promise<void> { await client.stop().then(() => operations.watch()); },
 
     /** Get server info */
     info: (): Promise<CompilerServerInfo | undefined> => client.info(),
@@ -64,17 +64,17 @@ export const main = (ctx: ManifestContext) => {
         return console.log(`Clean triggered ${ctx.workspace.path}:`, buildFolders);
       } else {
         try {
-          await Promise.all(buildFolders.map(f => fs.rm(CommonUtil.resolveWorkspace(ctx, f), { force: true, recursive: true })));
+          await Promise.all(buildFolders.map(file => fs.rm(CommonUtil.resolveWorkspace(ctx, file), { force: true, recursive: true })));
         } catch { }
         return console.log(`Cleaned ${ctx.workspace.path}:`, buildFolders);
       }
     },
 
     /** Stream events */
-    events: async (type: string, handler: (ev: unknown) => unknown): Promise<void> => {
+    events: async (type: string, handler: (event: unknown) => unknown): Promise<void> => {
       if (type === 'change' || type === 'log' || type === 'progress' || type === 'state' || type === 'all') {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        for await (const ev of client.fetchEvents(type as 'change')) { await handler(ev); }
+        for await (const event of client.fetchEvents(type as 'change')) { await handler(event); }
       } else {
         throw new Error(`Unknown event type: ${type}`);
       }
@@ -113,7 +113,7 @@ export const main = (ctx: ManifestContext) => {
       await CompilerSetup.exportManifest(ctx, output, prod); return;
     }
   };
-  return ops;
+  return operations;
 };
 
 export type Operations = ReturnType<typeof main>;

package/support/log.ts

@@ -1,6 +1,6 @@
 import { CompilerLogEvent, CompilerLogLevel, CompilerProgressEvent } from './types.ts';
 
-const LEVEL_TO_PRI: Record<CompilerLogLevel | 'none', number> = { debug: 1, info: 2, warn: 3, error: 4, none: 5 };
+const LEVEL_TO_PRIORITY: Record<CompilerLogLevel | 'none', number> = { debug: 1, info: 2, warn: 3, error: 4, none: 5 };
 const SCOPE_MAX = 15;
 
 type LogConfig = {
@@ -31,7 +31,7 @@ export class Logger implements LogConfig, LogShape {
     const done = process.stdout.write(`${ESC}1G${text}${ESC}0K`);
     this.#linePartial = !!text;
     if (!done) {
-      return new Promise<void>(r => process.stdout.once('drain', r));
+      return new Promise<void>(resolve => process.stdout.once('drain', resolve));
     }
   }
 
@@ -42,25 +42,27 @@ export class Logger implements LogConfig, LogShape {
   scope?: string;
   parent?: Logger;
 
-  constructor(cfg: LogConfig = {}) {
-    Object.assign(this, cfg);
+  constructor(config: LogConfig = {}) {
+    Object.assign(this, config);
   }
 
-  valid(ev: CompilerLogEvent): boolean {
-    return LEVEL_TO_PRI[this.level ?? this.parent?.level!] <= LEVEL_TO_PRI[ev.level];
+  valid(event: CompilerLogEvent): boolean {
+    return LEVEL_TO_PRIORITY[this.level ?? this.parent?.level!] <= LEVEL_TO_PRIORITY[event.level];
   }
 
   /** Log event with filtering by level */
-  render(ev: CompilerLogEvent): void {
-    if (!this.valid(ev)) { return; }
-    const params = [ev.message, ...ev.args ?? []].map(x => typeof x === 'string' ? x.replaceAll(this.root ?? this.parent?.root!, '.') : x);
-    if (ev.scope ?? this.scope) {
-      params.unshift(`[${(ev.scope ?? this.scope!).padEnd(SCOPE_MAX, ' ')}]`);
+  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 (event.scope ?? this.scope) {
+      params.unshift(`[${(event.scope ?? this.scope!).padEnd(SCOPE_MAX, ' ')}]`);
     }
-    params.unshift(new Date().toISOString(), `${ev.level.padEnd(5)}`);
+    params.unshift(new Date().toISOString(), `${event.level.padEnd(5)}`);
     Logger.rewriteLine(''); // Clear out progress line, if active
     // eslint-disable-next-line no-console
-    console[ev.level]!(...params);
+    console[event.level]!(...params);
   }
 
   info(message: string, ...args: unknown[]): void { return this.render({ level: 'info', message, args }); }
@@ -82,9 +84,9 @@ class $RootLogger extends Logger {
 
   /** Set level for operation */
   initLevel(defaultLevel: CompilerLogLevel | 'none'): void {
-    const val = process.env.TRV_QUIET !== 'true' ? process.env.TRV_BUILD : 'none';
-    switch (val) {
-      case 'debug': case 'warn': case 'error': case 'info': this.level = val; break;
+    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';
     }
@@ -96,23 +98,23 @@ class $RootLogger extends Logger {
   }
 
   /** Scope and provide a callback pattern for access to a logger */
-  wrap<T = unknown>(scope: string, op: (log: Logger) => Promise<T>, basic = true): Promise<T> {
-    const l = this.scoped(scope);
-    return basic ? (l.debug('Started'), op(l).finally(() => l.debug('Completed'))) : op(l);
+  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);
   }
 
   /** Write progress event, if active */
-  onProgressEvent(ev: CompilerProgressEvent): void | Promise<void> {
+  onProgressEvent(event: CompilerProgressEvent): void | Promise<void> {
     if (!(this.logProgress)) { return; }
-    const pct = Math.trunc(ev.idx * 100 / ev.total);
-    const text = ev.complete ? '' : `Compiling [${'#'.repeat(Math.trunc(pct / 10)).padEnd(10, ' ')}] [${ev.idx}/${ev.total}] ${ev.message}`;
+    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(src: () => AsyncIterable<CompilerProgressEvent>): Promise<void> {
+  async consumeProgressEvents(input: () => AsyncIterable<CompilerProgressEvent>): Promise<void> {
     if (!(this.logProgress)) { return; }
-    for await (const ev of src()) { this.onProgressEvent(ev); }
+    for await (const event of input()) { this.onProgressEvent(event); }
     Logger.reset();
   }
 }
@@ -120,13 +122,13 @@ class $RootLogger extends Logger {
 export const Log = new $RootLogger();
 
 export class IpcLogger extends Logger {
-  render(ev: CompilerLogEvent): void {
-    if (!this.valid(ev)) { return; }
+  render(event: CompilerLogEvent): void {
+    if (!this.valid(event)) { return; }
     if (process.connected && process.send) {
-      process.send({ type: 'log', payload: ev });
+      process.send({ type: 'log', payload: event });
     }
     if (!process.connected) {
-      super.render(ev);
+      super.render(event);
     }
   }
 }

package/support/queue.ts

@@ -1,15 +1,7 @@
-type PromiseResolver<T> = { resolve: (v: T) => void, reject: (err?: unknown) => void };
-
-function resolvablePromise<T = void>(): Promise<T> & PromiseResolver<T> {
-  let ops: PromiseResolver<T>;
-  const prom = new Promise<T>((resolve, reject) => ops = { resolve, reject });
-  return Object.assign(prom, ops!);
-}
-
 export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
   #queue: X[] = [];
   #done = false;
-  #ready = resolvablePromise();
+  #ready = Promise.withResolvers<void>();
 
   constructor(signal?: AbortSignal) {
     signal?.addEventListener('abort', () => this.close());
@@ -22,15 +14,15 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
 
   async next(): Promise<IteratorResult<X>> {
     while (!this.#done && !this.#queue.length) {
-      await this.#ready;
-      this.#ready = resolvablePromise();
+      await this.#ready.promise;
+      this.#ready = Promise.withResolvers<void>();
     }
     return { value: (this.#queue.length ? this.#queue.shift() : undefined)!, done: this.#done };
   }
 
-  async throw(e?: Error): Promise<IteratorResult<X>> {
+  async throw(error?: Error): Promise<IteratorResult<X>> {
     this.#done = true;
-    this.#ready.reject(e);
+    this.#ready.reject(error);
     return { value: undefined, done: this.#done };
   }
 

package/support/server/client.ts

@@ -11,7 +11,7 @@ import { ProcessHandle } from './process-handle.ts';
 
 type FetchEventsConfig<T> = {
   signal?: AbortSignal;
-  until?: (ev: T) => boolean;
+  until?: (event: T) => boolean;
   enforceIteration?: boolean;
 };
 
@@ -44,26 +44,26 @@ export class CompilerClient {
     return this.#url;
   }
 
-  async #fetch(rel: string, opts?: RequestInit & { timeout?: number }, logTimeout = true): Promise<{ ok: boolean, text: string }> {
-    const ctrl = new AbortController();
-    const timeoutCtrl = new AbortController();
+  async #fetch(urlPath: string, options?: RequestInit & { timeout?: number }, logTimeout = true): Promise<{ ok: boolean, text: string }> {
+    const controller = new AbortController();
+    const timeoutController = new AbortController();
 
-    opts?.signal?.addEventListener('abort', () => ctrl.abort());
-    timers.setTimeout(opts?.timeout ?? 100, undefined, { ref: false, signal: timeoutCtrl.signal })
+    options?.signal?.addEventListener('abort', () => controller.abort());
+    timers.setTimeout(options?.timeout ?? 100, undefined, { ref: false, signal: timeoutController.signal })
       .then(() => {
-        logTimeout && this.#log.error(`Timeout on request to ${this.#url}${rel}`);
-        ctrl.abort('TIMEOUT');
+        logTimeout && this.#log.error(`Timeout on request to ${this.#url}${urlPath}`);
+        controller.abort('TIMEOUT');
       })
       .catch(() => { });
-    const response = await fetch(`${this.#url}${rel}`, { ...opts, signal: ctrl.signal });
+    const response = await fetch(`${this.#url}${urlPath}`, { ...options, signal: controller.signal });
     const out = { ok: response.ok, text: await response.text() };
-    timeoutCtrl.abort();
+    timeoutController.abort();
     return out;
   }
 
   /** Get server information, if server is running */
   info(): Promise<CompilerServerInfo | undefined> {
-    return this.#fetch('/info', { timeout: 200 }, false).then(v => JSON.parse(v.text), () => undefined);
+    return this.#fetch('/info', { timeout: 200 }, false).then(response => JSON.parse(response.text), () => undefined);
   }
 
   async isWatching(): Promise<boolean> {
@@ -72,7 +72,7 @@ export class CompilerClient {
 
   /** Clean the server */
   clean(): Promise<boolean> {
-    return this.#fetch('/clean', { timeout: 300 }).then(v => v.ok, () => false);
+    return this.#fetch('/clean', { timeout: 300 }).then(response => response.ok, () => false);
   }
 
   /** Stop server and wait for shutdown */
@@ -81,7 +81,7 @@ export class CompilerClient {
     if (!info) {
       this.#log.debug('Stopping server, info not found, manual killing');
       return Promise.all([this.#handle.server.kill(), this.#handle.compiler.kill()])
-        .then(v => v.some(x => x));
+        .then(results => results.some(result => result));
     }
 
     await this.#fetch('/stop').catch(() => { }); // Trigger
@@ -94,9 +94,9 @@ export class CompilerClient {
   fetchEvents<
     V extends CompilerEventType,
     T extends (CompilerEvent & { type: V })['payload']
-  >(type: V, cfg?: FetchEventsConfig<T>): AsyncIterable<T>;
-  fetchEvents(type: 'all', cfg?: FetchEventsConfig<CompilerEvent>): AsyncIterable<CompilerEvent>;
-  async * fetchEvents<T = unknown>(type: string, cfg: FetchEventsConfig<T> = {}): AsyncIterable<T> {
+  >(type: V, config?: FetchEventsConfig<T>): AsyncIterable<T>;
+  fetchEvents(type: 'all', config?: FetchEventsConfig<CompilerEvent>): AsyncIterable<CompilerEvent>;
+  async * fetchEvents<T = unknown>(type: string, config: FetchEventsConfig<T> = {}): AsyncIterable<T> {
     let info = await this.info();
     if (!info) {
       return;
@@ -104,40 +104,40 @@ export class CompilerClient {
 
     this.#log.debug(`Starting watch for events of type "${type}"`);
 
-    let signal = cfg.signal;
+    let signal = config.signal;
 
     // Ensure we capture end of process at least
     if (!signal) {
-      const ctrl = new AbortController();
-      process.on('SIGINT', () => ctrl.abort());
-      signal = ctrl.signal;
+      const controller = new AbortController();
+      process.on('SIGINT', () => controller.abort());
+      signal = controller.signal;
     }
 
     const { iteration } = info;
 
     for (; ;) {
-      const ctrl = new AbortController();
-      const quit = (): void => ctrl.abort();
+      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: ctrl.signal }, resolve)
+          http.get(`${this.#url}/event/${type}`, { agent: streamAgent, signal: controller.signal }, resolve)
             .on('error', reject)
         );
 
         for await (const line of rl.createInterface(response)) {
           if (line.trim().charAt(0) === '{') {
-            const val: T = JSON.parse(line);
-            if (cfg.until?.(val)) {
+            const event: T = JSON.parse(line);
+            if (config.until?.(event)) {
               await CommonUtil.queueMacroTask();
-              ctrl.abort();
+              controller.abort();
             }
-            yield val;
+            yield event;
           }
         }
-      } catch (err) {
-        const aborted = ctrl.signal.aborted || (typeof err === 'object' && err && 'code' in err && err.code === 'ECONNRESET');
-        if (!aborted) { throw err; }
+      } catch (error) {
+        const aborted = controller.signal.aborted || (typeof error === 'object' && error && 'code' in error && error.code === 'ECONNRESET');
+        if (!aborted) { throw error; }
       }
       signal.removeEventListener('abort', quit);
 
@@ -145,12 +145,12 @@ export class CompilerClient {
 
       info = await this.info();
 
-      if (ctrl.signal.reason === 'TIMEOUT') {
+      if (controller.signal.reason === 'TIMEOUT') {
         this.#log.debug('Failed due to timeout');
         return;
       }
 
-      if (ctrl.signal.aborted || !info || (cfg.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 {
@@ -164,7 +164,7 @@ 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: s => set.has(s.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);