@travetto/compiler 8.0.0-alpha.9 → 8.0.1

package/src/state.ts

@@ -1,32 +1,36 @@
 import fs from 'node:fs';
-import type { CompilerHost, SourceFile, CompilerOptions, Program, ScriptTarget } from 'typescript';
 
-import { path, ManifestModuleUtil, type ManifestModule, type ManifestRoot, type ManifestIndex, type ManifestModuleFolderType } from '@travetto/manifest';
+import type { CompilerHost, CompilerOptions, Program, ScriptTarget, SourceFile } from 'typescript';
+
+import {
+  type ManifestIndex,
+  type ManifestModule,
+  type ManifestModuleFolderType,
+  ManifestModuleUtil,
+  type ManifestRoot,
+  path
+} from '@travetto/manifest';
 import type { TransformerManager } from '@travetto/transformer';
 
-import { CompilerUtil } from './util.ts';
-import type { CompileStateEntry } from './types.ts';
 import { CommonUtil } from './common.ts';
 import { tsProxy as ts, tsProxyInit } from './ts-proxy.ts';
+import type { CompileStateEntry } from './types.ts';
+import { CompilerUtil } from './util.ts';
 
 const TYPINGS_FOLDER_KEYS = new Set<ManifestModuleFolderType>(['$index', 'support', 'src', '$package']);
 
 export class CompilerState implements CompilerHost {
-
   static async get(idx: ManifestIndex): Promise<CompilerState> {
     return new CompilerState().init(idx);
   }
 
-  /** @private */
-  constructor() { }
-
   #outputPath: string;
   #typingsPath: string;
   #sourceFiles = new Set<string>();
   #sourceDirectory = new Map<string, string>();
   #sourceToEntry = new Map<string, CompileStateEntry>();
   #outputToEntry = new Map<string, CompileStateEntry>();
-  #tscOutputFileToOuptut = new Map<string, string>();
+  #tscOutputFileToOutput = new Map<string, string>();
 
   #sourceContents = new Map<string, string | undefined>();
   #sourceFileObjects = new Map<string, SourceFile>();
@@ -44,7 +48,9 @@ export class CompilerState implements CompilerHost {
     try {
       return ts.sys.readFile(location, 'utf8');
     } catch {
-      try { return fs.readFileSync(location, 'utf8'); } catch { }
+      try {
+        return fs.readFileSync(location, 'utf8');
+      } catch {}
     }
     return undefined;
   }
@@ -61,13 +67,17 @@ export class CompilerState implements CompilerHost {
   #fileExists(location: string): boolean {
     try {
       return ts.sys.fileExists(location);
-    } catch { return fs.existsSync(location); }
+    } catch {
+      return fs.existsSync(location);
+    }
   }
 
   #directoryExists(location: string): boolean {
     try {
       return ts.sys.directoryExists(location);
-    } catch { return fs.existsSync(location); }
+    } catch {
+      return fs.existsSync(location);
+    }
   }
 
   #writeExternalTypings(location: string, text: string, bom?: boolean): void {
@@ -120,14 +130,14 @@ export class CompilerState implements CompilerHost {
     for (const module of this.#modules) {
       const base = module?.files ?? {};
       const files = [
-        ...base.bin ?? [],
-        ...base.src ?? [],
-        ...base.support ?? [],
-        ...base.doc ?? [],
-        ...base.test ?? [],
-        ...base.$transformer ?? [],
-        ...base.$index ?? [],
-        ...base.$package ?? []
+        ...(base.bin ?? []),
+        ...(base.src ?? []),
+        ...(base.support ?? []),
+        ...(base.doc ?? []),
+        ...(base.test ?? []),
+        ...(base.$transformer ?? []),
+        ...(base.$index ?? []),
+        ...(base.$package ?? [])
       ];
       for (const [file, type] of files) {
         if (ManifestModuleUtil.isSourceType(type)) {
@@ -158,9 +168,7 @@ export class CompilerState implements CompilerHost {
   }
 
   getArbitraryInputFile(): string {
-    const randomSource = this.#manifestIndex.getWorkspaceModules()
-      .filter(module => module.files.src?.length)[0]
-      .files.src[0].sourceFile;
+    const randomSource = this.#manifestIndex.getWorkspaceModules().filter(module => module.files.src?.length)[0].files.src[0].sourceFile;
 
     return this.getBySource(randomSource)!.sourceFile;
   }
@@ -168,7 +176,12 @@ export class CompilerState implements CompilerHost {
   async getProgram(force = false): Promise<Program> {
     if (force || !this.#program) {
       await this.initializeTypescript();
-      this.#program = ts.createProgram({ rootNames: this.getAllFiles(), host: this, options: this.#compilerOptions, oldProgram: this.#program });
+      this.#program = ts.createProgram({
+        rootNames: this.getAllFiles(),
+        host: this,
+        options: this.#compilerOptions,
+        oldProgram: this.#program
+      });
       this.#transformerManager.init(this.#program.getTypeChecker());
       await CommonUtil.queueMacroTask();
     }
@@ -185,36 +198,40 @@ export class CompilerState implements CompilerHost {
       case 'package-json': {
         const text = this.readFile(sourceFile)!;
         const finalText = CompilerUtil.rewritePackageJSON(this.#manifest, text);
-        const location = this.#tscOutputFileToOuptut.get(output) ?? output;
+        const location = this.#tscOutputFileToOutput.get(output) ?? output;
         this.#writeFile(location, finalText);
         this.#writeExternalTypings(location, finalText);
         break;
       }
       case 'js':
-      case 'typings': this.writeFile(output, this.readFile(sourceFile)!); break;
+      case 'typings':
+        this.writeFile(output, this.readFile(sourceFile)!);
+        break;
       case 'ts': {
         const program = await this.getProgram(needsNewProgram);
         const tsSourceFile = program.getSourceFile(sourceFile)!;
         program.emit(
           tsSourceFile,
-          (...args) => this.writeFile(args[0], args[1], args[2]), undefined, false,
+          (...args) => this.writeFile(args[0], args[1], args[2]),
+          undefined,
+          false,
           this.#transformerManager.get()
         );
         return [
           ...program.getSemanticDiagnostics(tsSourceFile),
           ...program.getSyntacticDiagnostics(tsSourceFile),
-          ...program.getDeclarationDiagnostics(tsSourceFile),
+          ...program.getDeclarationDiagnostics(tsSourceFile)
         ]
           .filter(d => d.category === ts.DiagnosticCategory.Error)
           .map(diag => {
             let message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
             if (
-              message.includes("is not under 'rootDir'")
-              || message.includes("does not exist on type 'EnvDataCombinedType'")
-              || message.startsWith('Could not find a declaration file for module')
-              || message.startsWith("Cannot find module '@travetto")
-              || message.startsWith("This JSX tag requires the module path '@travetto")
-              || message.startsWith("JSX element implicitly has type 'any'")
+              message.includes("is not under 'rootDir'") ||
+              message.includes("does not exist on type 'EnvDataCombinedType'") ||
+              message.startsWith('Could not find a declaration file for module') ||
+              message.startsWith("Cannot find module '@travetto") ||
+              message.startsWith("This JSX tag requires the module path '@travetto") ||
+              message.startsWith("JSX element implicitly has type 'any'")
             ) {
               return '';
             }
@@ -235,7 +252,11 @@ export class CompilerState implements CompilerHost {
 
   isCompilerFile(file: string): boolean {
     const entry = this.getBySource(file);
-    return (entry?.moduleFile && ManifestModuleUtil.getFileRole(entry.moduleFile) === 'compile') || entry?.module.roles.includes('compile') || false;
+    return (
+      (entry?.moduleFile && ManifestModuleUtil.getFileRole(entry.moduleFile) === 'compile') ||
+      entry?.module.roles.includes('compile') ||
+      false
+    );
   }
 
   registerInput(module: ManifestModule, moduleFile: string): CompileStateEntry {
@@ -256,14 +277,14 @@ export class CompilerState implements CompilerHost {
     this.#sourceToEntry.set(sourceFile, entry);
     this.#sourceDirectory.set(sourceFolder, sourceFolder);
 
-    this.#tscOutputFileToOuptut.set(tscOutputFile, outputFile);
-    this.#tscOutputFileToOuptut.set(`${tscOutputFile}.map`, `${outputFile}.map`);
+    this.#tscOutputFileToOutput.set(tscOutputFile, outputFile);
+    this.#tscOutputFileToOutput.set(`${tscOutputFile}.map`, `${outputFile}.map`);
 
     if (!isTypings) {
       const srcBase = `${ManifestModuleUtil.withoutSourceExtension(tscOutputFile)}${ManifestModuleUtil.TYPINGS_EXT}`;
       const outBase = `${ManifestModuleUtil.withoutSourceExtension(outputFile)}${ManifestModuleUtil.TYPINGS_EXT}`;
-      this.#tscOutputFileToOuptut.set(`${srcBase}.map`, `${outBase}.map`);
-      this.#tscOutputFileToOuptut.set(srcBase, outBase);
+      this.#tscOutputFileToOutput.set(`${srcBase}.map`, `${outBase}.map`);
+      this.#tscOutputFileToOutput.set(srcBase, outBase);
     }
 
     return entry;
@@ -298,10 +319,10 @@ export class CompilerState implements CompilerHost {
     this.#sourceFiles.delete(sourceFile);
 
     const tscOutputDts = `${ManifestModuleUtil.withoutSourceExtension(entry.tscOutputFile)}${ManifestModuleUtil.TYPINGS_EXT}`;
-    this.#tscOutputFileToOuptut.delete(entry.tscOutputFile);
-    this.#tscOutputFileToOuptut.delete(`${entry.tscOutputFile}.map`);
-    this.#tscOutputFileToOuptut.delete(tscOutputDts);
-    this.#tscOutputFileToOuptut.delete(`${tscOutputDts}.map`);
+    this.#tscOutputFileToOutput.delete(entry.tscOutputFile);
+    this.#tscOutputFileToOutput.delete(`${entry.tscOutputFile}.map`);
+    this.#tscOutputFileToOutput.delete(tscOutputDts);
+    this.#tscOutputFileToOutput.delete(`${tscOutputDts}.map`);
   }
 
   getAllFiles(): string[] {
@@ -309,12 +330,24 @@ export class CompilerState implements CompilerHost {
   }
 
   /* Start Compiler Host */
-  getCanonicalFileName(file: string): string { return file; }
-  getCurrentDirectory(): string { return this.#manifest.workspace.path; }
-  getDefaultLibFileName(options: CompilerOptions): string { return ts.getDefaultLibFileName(options); }
-  getNewLine(): string { return ts.sys.newLine; }
-  useCaseSensitiveFileNames(): boolean { return ts.sys.useCaseSensitiveFileNames; }
-  getDefaultLibLocation(): string { return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions)); }
+  getCanonicalFileName(file: string): string {
+    return file;
+  }
+  getCurrentDirectory(): string {
+    return this.#manifest.workspace.path;
+  }
+  getDefaultLibFileName(options: CompilerOptions): string {
+    return ts.getDefaultLibFileName(options);
+  }
+  getNewLine(): string {
+    return ts.sys.newLine;
+  }
+  useCaseSensitiveFileNames(): boolean {
+    return ts.sys.useCaseSensitiveFileNames;
+  }
+  getDefaultLibLocation(): string {
+    return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions));
+  }
 
   fileExists(sourceFile: string): boolean {
     return this.#sourceToEntry.has(sourceFile) || this.#fileExists(sourceFile);
@@ -328,13 +361,13 @@ export class CompilerState implements CompilerHost {
     // JSX runtime shenanigans
     text = text.replace(/support\/jsx-runtime"/g, 'support/jsx-runtime.js"');
 
-    const location = this.#tscOutputFileToOuptut.get(outputFile) ?? outputFile;
+    const location = this.#tscOutputFileToOutput.get(outputFile) ?? outputFile;
 
     if (ManifestModuleUtil.TYPINGS_WITH_MAP_EXT_REGEX.test(outputFile)) {
       this.#writeExternalTypings(location, text, bom);
     }
 
-    return this.#writeFile(location, text, bom);
+    this.#writeFile(location, text, bom);
   }
 
   readFile(sourceFile: string): string | undefined {
@@ -349,4 +382,4 @@ export class CompilerState implements CompilerHost {
       return ts.createSourceFile(sourceFile, content ?? '', language);
     });
   }
-}
+}

package/src/ts-proxy.ts

@@ -1,12 +1,14 @@
-/* eslint-disable @typescript-eslint/consistent-type-assertions */
 import type ts from 'typescript';
 
 let state: typeof ts | undefined;
 let promise: Promise<unknown> | undefined;
-export const tsProxyInit = (): Promise<unknown> => promise ??= import('typescript').then(module => { state = module.default; });
+export const tsProxyInit = (): Promise<unknown> =>
+  (promise ??= import('typescript').then(module => {
+    state = module.default;
+  }));
 
 export const tsProxy = new Proxy({}!, {
   get(_, prop: string): unknown {
     return state![prop as keyof typeof ts];
   }
-}) as typeof ts;
+}) as typeof ts;

package/src/types.ts

@@ -3,23 +3,30 @@ import type { ChangeEventType, ManifestModule } from '@travetto/manifest';
 export type CompilerStateType = 'startup' | 'init' | 'compile-start' | 'compile-end' | 'watch-start' | 'watch-end' | 'reset' | 'closed';
 export type CompilerLogLevel = 'info' | 'debug' | 'warn' | 'error';
 
-export type CompileEmitEvent = { file: string, i: number, total: number, errors?: string[], duration: number };
-export type CompileStateEntry = { sourceFile: string, tscOutputFile: string, outputFile?: string, module: ManifestModule, import: string, moduleFile: string };
-export type CompilerWatchEvent = { action: ChangeEventType, file: string, entry: CompileStateEntry, moduleFile: string };
+export type CompileEmitEvent = { file: string; i: number; total: number; errors?: string[]; duration: number };
+export type CompileStateEntry = {
+  sourceFile: string;
+  tscOutputFile: string;
+  outputFile?: string;
+  module: ManifestModule;
+  import: string;
+  moduleFile: string;
+};
+export type CompilerWatchEvent = { action: ChangeEventType; file: string; entry: CompileStateEntry; moduleFile: string };
 
-export type CompilerChangeEvent = { file: string, action: ChangeEventType, output: string, module: string, import: string, time: number };
-export type CompilerLogEvent = { level: CompilerLogLevel, message: string, time?: number, args?: unknown[], scope?: string };
-export type CompilerProgressEvent = { idx: number, total: number, message: string, operation: 'compile', complete?: boolean };
-export type CompilerStateEvent = { state: CompilerStateType, extra?: Record<string, unknown> };
-export type FileChangeEvent = { files: { file: string, action: ChangeEventType }[], time: number };
+export type CompilerChangeEvent = { file: string; action: ChangeEventType; output: string; module: string; import: string; time: number };
+export type CompilerLogEvent = { level: CompilerLogLevel; message: string; time?: number; args?: unknown[]; scope?: string };
+export type CompilerProgressEvent = { idx: number; total: number; message: string; operation: 'compile'; complete?: boolean };
+export type CompilerStateEvent = { state: CompilerStateType; extra?: Record<string, unknown> };
+export type FileChangeEvent = { files: { file: string; action: ChangeEventType }[]; time: number };
 
 export type CompilerEvent =
-  { type: 'file', payload: FileChangeEvent } |
-  { type: 'change', payload: CompilerChangeEvent } |
-  { type: 'log', payload: CompilerLogEvent } |
-  { type: 'progress', payload: CompilerProgressEvent } |
-  { type: 'state', payload: CompilerStateEvent } |
-  { type: 'all', payload: unknown };
+  | { type: 'file'; payload: FileChangeEvent }
+  | { type: 'change'; payload: CompilerChangeEvent }
+  | { type: 'log'; payload: CompilerLogEvent }
+  | { type: 'progress'; payload: CompilerProgressEvent }
+  | { type: 'state'; payload: CompilerStateEvent }
+  | { type: 'all'; payload: unknown };
 
 export type CompilerEventType = CompilerEvent['type'];
 export type CompilerEventPayload<V> = (CompilerEvent & { type: V })['payload'];
@@ -35,4 +42,4 @@ export type CompilerServerInfo = {
   env?: Record<string, string>;
 };
 
-export class CompilerReset extends Error { }
+export class CompilerReset extends Error {}

package/src/util.ts

@@ -4,7 +4,6 @@ import { ManifestModuleUtil, type ManifestRoot, type Package } from '@travetto/m
  * Standard utilities for compiler
  */
 export class CompilerUtil {
-
   /**
    * Rewrites the package.json to target output file names, and pins versions
    * @param manifest
@@ -39,11 +38,10 @@ export class CompilerUtil {
   static naiveHash(text: string): number {
     let hash = 5381;
 
-    for (let i = 0; i < text.length; i++) {
-      // eslint-disable-next-line no-bitwise
+    for (let i = 0; i < text.length; i += 1) {
       hash = (hash * 33) ^ text.charCodeAt(i);
     }
 
     return Math.abs(hash);
   }
-}
+}

package/src/watch.ts

@@ -1,14 +1,13 @@
-import fs from 'node:fs/promises';
 import { watch } from 'node:fs';
+import fs from 'node:fs/promises';
 
 import { ManifestFileUtil, ManifestModuleUtil, ManifestUtil, PACKAGE_MANAGERS, PackageUtil, path } from '@travetto/manifest';
 
-import { CompilerReset, type CompilerWatchEvent, type CompileStateEntry } from './types.ts';
-import type { CompilerState } from './state.ts';
-
-import { AsyncQueue } from './queue.ts';
-import { IpcLogger } from './log.ts';
 import { EventUtil } from './event.ts';
+import { IpcLogger } from './log.ts';
+import { AsyncQueue } from './queue.ts';
+import type { CompilerState } from './state.ts';
+import { CompilerReset, type CompilerWatchEvent, type CompileStateEntry } from './types.ts';
 
 const log = new IpcLogger({ level: 'debug' });
 
@@ -16,7 +15,7 @@ type CompilerWatchEventCandidate = Omit<CompilerWatchEvent, 'entry'> & { entry?:
 
 export class CompilerWatcher {
   #state: CompilerState;
-  #cleanup: Partial<Record<'tool' | 'workspace' | 'canary' | 'git', () => (void | Promise<void>)>> = {};
+  #cleanup: Partial<Record<'tool' | 'workspace' | 'canary' | 'git', () => void | Promise<void>>> = {};
   #watchCanary: string = '.trv/canary.id';
   #lastWorkspaceModified = Date.now();
   #watchCanaryFrequency = 5;
@@ -27,22 +26,22 @@ export class CompilerWatcher {
     this.#state = state;
     this.#root = state.manifest.workspace.path;
     this.#queue = new AsyncQueue(signal);
-    signal.addEventListener('abort', () => Object.values(this.#cleanup).forEach(fn => fn?.()));
+    signal.addEventListener('abort', () =>
+      Object.values(this.#cleanup).forEach(fn => {
+        fn?.();
+      })
+    );
   }
 
   async #getWatchIgnores(): Promise<string[]> {
     const pkg = PackageUtil.readPackage(this.#root);
-    const patterns = [
-      ...pkg?.travetto?.build?.watchIgnores ?? [],
-      '**/node_modules',
-      '.*/**/node_modules'
-    ];
+    const patterns = [...(pkg?.travetto?.build?.watchIgnores ?? []), '**/node_modules', '.*/**/node_modules'];
     const ignores = new Set(['node_modules', '.git', this.#state.resolveOutputFile('.')]);
     for (const item of patterns) {
       if (item.includes('*')) {
         for await (const sub of fs.glob(item, { cwd: this.#root })) {
           if (sub.startsWith('node_modules')) {
-            continue;
+            // Continue
           } else if (sub.endsWith('/node_modules')) {
             ignores.add(sub.split('/node_modules')[0]);
           } else {
@@ -53,7 +52,7 @@ export class CompilerWatcher {
         ignores.add(item);
       }
     }
-    return [...ignores].toSorted().map(ignore => ignore.endsWith('/') ? ignore : `${ignore}/`);
+    return [...ignores].toSorted().map(ignore => (ignore.endsWith('/') ? ignore : `${ignore}/`));
   }
 
   #toCandidateEvent({ action, file }: Pick<CompilerWatchEvent, 'action' | 'file'>): CompilerWatchEventCandidate {
@@ -68,7 +67,7 @@ export class CompilerWatcher {
       this.#state.removeSource(entry.sourceFile); // Ensure we remove it
     }
 
-    return { entry, file: entry?.sourceFile ?? file, action, moduleFile: entry?.moduleFile! };
+    return { entry, file: entry?.sourceFile ?? file, action, moduleFile: entry?.moduleFile ?? '' };
   }
 
   #isValidFile(file: string): boolean {
@@ -97,8 +96,7 @@ export class CompilerWatcher {
 
   async #updateManifestWithEvents(compilerEvents: CompilerWatchEvent[]): Promise<void> {
     const eventsByModule = this.#state.manifestIndex.groupByLineage(
-      compilerEvents.map(event => ({ item: event, module: event.entry!.module.name }))
-        .filter(x => x.item.action !== 'update')
+      compilerEvents.map(event => ({ item: event, module: event.entry!.module.name })).filter(x => x.item.action !== 'update')
     );
 
     for (const [moduleName, events] of eventsByModule.entries()) {
@@ -116,66 +114,76 @@ export class CompilerWatcher {
   async #listenWorkspace(): Promise<void> {
     const lib = await import('@parcel/watcher');
     const ignore = await this.#getWatchIgnores();
-    const packageFiles = new Set([
-      'package.json',
-      ...PACKAGE_MANAGERS.flatMap(x => [x.workspaceFile!, x.lock].filter(Boolean))
-    ].map(file => path.resolve(this.#root, file)));
+    const packageFiles = new Set(
+      ['package.json', ...PACKAGE_MANAGERS.flatMap(x => [x.workspaceFile!, x.lock].filter(Boolean))].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 (error, events) => {
-      this.#lastWorkspaceModified = Date.now();
+    const listener = await lib.subscribe(
+      this.#root,
+      async (error, events) => {
+        this.#lastWorkspaceModified = Date.now();
 
-      try {
-        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(event => packageFiles.has(path.toPosix(event.path)))) {
-          throw new CompilerReset('Package information changed');
-        }
+        try {
+          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(event => packageFiles.has(path.toPosix(event.path)))) {
+            throw new CompilerReset('Package information changed');
+          }
 
-        // One event per file set
-        const filesChanged = events
-          .map(event => ({ file: path.toPosix(event.path), action: event.type }))
-          .filter(event => this.#isValidFile(event.file));
+          // One event per file set
+          const filesChanged = events
+            .map(event => ({ file: path.toPosix(event.path), action: event.type }))
+            .filter(event => this.#isValidFile(event.file));
 
-        if (filesChanged.length) {
-          EventUtil.sendEvent('file', { time: Date.now(), files: filesChanged });
-        }
+          if (filesChanged.length) {
+            EventUtil.sendEvent('file', { time: Date.now(), files: filesChanged });
+          }
 
-        if (filesChanged.some(item => this.#state.isCompilerFile(item.file))) {
-          throw new CompilerReset('Compiler has changed, restarting');
-        }
+          if (filesChanged.some(item => this.#state.isCompilerFile(item.file))) {
+            throw new CompilerReset('Compiler has changed, restarting');
+          }
 
-        const items = filesChanged
-          .map(event => this.#toCandidateEvent(event))
-          .filter(event => this.#isValidEvent(event));
+          const items = filesChanged.map(event => this.#toCandidateEvent(event)).filter(event => this.#isValidEvent(event));
 
-        if (items.length === 0) {
-          return;
-        }
+          if (items.length === 0) {
+            return;
+          }
 
-        try {
-          await this.#updateManifestWithEvents(items);
-        } catch (manifestError) {
-          log.info('Restarting due to manifest rebuild failure', manifestError);
-          throw new CompilerReset(`Manifest rebuild failure: ${manifestError} `);
-        }
+          try {
+            await this.#updateManifestWithEvents(items);
+          } catch (manifestError) {
+            log.info('Restarting due to manifest rebuild failure', manifestError);
+            throw new CompilerReset(`Manifest rebuild failure: ${manifestError} `);
+          }
 
-        for (const item of items) {
-          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');
+          for (const item of items) {
+            this.#queue.add(item);
+          }
+        } catch (out) {
+          let error: Error;
+          if (out instanceof Error) {
+            if (out.message.includes('Events were dropped by the FSEvents client.')) {
+              error = new CompilerReset('FSEvents failure, requires restart');
+            } else {
+              error = out;
+            }
+          } else {
+            error = new Error(`${out}`);
+          }
+          return this.#queue.throw(error);
         }
-        return this.#queue.throw(out instanceof Error ? out : new Error(`${out} `));
-      }
-    }, { ignore });
+      },
+      { ignore }
+    );
 
     this.#cleanup.workspace = (): Promise<void> => listener.unsubscribe();
   }
@@ -183,10 +191,12 @@ export class CompilerWatcher {
   async #listenToolFolder(): Promise<void> {
     const build = this.#state.manifest.build;
     const toolRootFolder = path.dirname(path.resolve(this.#root, build.outputFolder));
-    const toolFolders = new Set([toolRootFolder, build.typesFolder, build.outputFolder]
-      .map(folder => path.resolve(this.#root, folder)));
+    const toolFolders = new Set([toolRootFolder, build.typesFolder, build.outputFolder].map(folder => path.resolve(this.#root, folder)));
 
-    log.debug('Tooling Folders', [...toolFolders].map(folder => folder.replace(`${this.#root}/`, '')));
+    log.debug(
+      'Tooling Folders',
+      [...toolFolders].map(folder => folder.replace(`${this.#root}/`, ''))
+    );
 
     await this.#cleanup.tool?.();
 
@@ -229,7 +239,9 @@ export class CompilerWatcher {
 
   async #listenGitChanges(): Promise<void> {
     const gitFolder = path.resolve(this.#root, '.git');
-    if (!await fs.stat(gitFolder, { throwIfNoEntry: false })) { return; }
+    if (!(await fs.stat(gitFolder, { throwIfNoEntry: false }))) {
+      return;
+    }
     log.debug('Starting git canary');
     const listener = watch(gitFolder, { encoding: 'utf8' }, async (event, file) => {
       if (!file) {
@@ -251,4 +263,4 @@ export class CompilerWatcher {
     }
     return this.#queue[Symbol.asyncIterator]();
   }
-}
+}