@travetto/compiler 8.0.0-alpha.1 → 8.0.0-alpha.11

package/README.md

@@ -25,7 +25,7 @@ Beyond the [Typescript](https://typescriptlang.org) compiler functionality, the
 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|watch` - Run the compiler in watch mode
+   *  `start` - Run the compiler in watch mode
    *  `stop` - Stop the compiler if running
    *  `restart` - Restart the compiler in watch mode
    *  `build` - Ensure the project is built and upto date
@@ -48,7 +48,7 @@ $ TRV_BUILD=debug trvc build
 2029-03-14T04:00:02.450Z info  [compiler-exec  ] Launching compiler
 2029-03-14T04:00:02.762Z debug [server         ] Compilation started
 2029-03-14T04:00:02.947Z info  [server         ] State changed: init
-2029-03-14T04:00:03.093Z debug [server         ] Compiler loaded
+2029-03-14T04:00:03.093Z debug [server         ] Compiler loaded: 0 files changed
 2029-03-14T04:00:04.003Z info  [server         ] State changed: compile-start
 2029-03-14T04:00:04.495Z info  [server         ] State changed: compile-end
 2029-03-14T04:00:05.066Z debug [server         ] Compiler process shutdown

package/bin/hook.js

@@ -1,26 +1,17 @@
+// @ts-check
 import module from 'node:module';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
-import '@travetto/runtime/support/polyfill.js';
-
-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
-const ogEmitWarning = process.emitWarning;
-Error.stackTraceLimit = 50;
+globalThis.devProcessWarningExclusions?.push((message) => message.startsWith('stripTypeScriptTypes'));
 
 module.registerHooks({
   load: (url, context, nextLoad) => {
     if (/[.]tsx?$/.test(url)) {
-      try {
-        process.emitWarning = () => { }; // Suppress ts-node experimental warnings
-        const source = readFileSync(fileURLToPath(url), 'utf8');
-        return { format: 'module', source: module.stripTypeScriptTypes(source), shortCircuit: true };
-      } finally {
-        process.emitWarning = ogEmitWarning;
-      }
+      const source = readFileSync(fileURLToPath(url), 'utf8');
+      return { format: 'module', source: module.stripTypeScriptTypes(source), shortCircuit: true };
     } else {
       return nextLoad(url, context);
     }
   }
-});
+});

package/bin/trvc-target.js

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

package/bin/trvc.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "8.0.0-alpha.1",
+  "version": "8.0.0-alpha.11",
   "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.1",
-    "@travetto/transformer": "^8.0.0-alpha.1"
+    "@travetto/manifest": "^8.0.0-alpha.4",
+    "@travetto/transformer": "^8.0.0-alpha.5"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.1"
+    "@travetto/cli": "^8.0.0-alpha.15"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -3,10 +3,9 @@ import { setMaxListeners } from 'node:events';
 
 import { getManifestContext, ManifestDeltaUtil, ManifestIndex, ManifestUtil, type DeltaEvent } from '@travetto/manifest';
 
-import { CompilerUtil } from './util.ts';
 import { CompilerState } from './state.ts';
 import { CompilerWatcher } from './watch.ts';
-import { type CompileEmitEvent, type CompileEmitter, CompilerReset } from './types.ts';
+import { type CompileEmitEvent, CompilerReset } from './types.ts';
 import { EventUtil } from './event.ts';
 
 import { IpcLogger } from './log.ts';
@@ -32,8 +31,8 @@ export class Compiler {
 
   #state: CompilerState;
   #watch?: boolean;
-  #controller: AbortController;
-  #signal: AbortSignal;
+  #shutdownController: AbortController;
+  #shutdownSignal: AbortSignal;
   #shuttingDown = false;
   #deltaEvents: DeltaEvent[];
 
@@ -42,15 +41,15 @@ export class Compiler {
     this.#watch = watch;
     this.#deltaEvents = deltaEvents;
 
-    this.#controller = new AbortController();
-    this.#signal = this.#controller.signal;
-    setMaxListeners(1000, this.#signal);
+    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'));
   }
 
-  #shutdown(mode: 'error' | 'manual' | 'complete' | 'reset', error?: Error): void {
+  #shutdown(mode: 'error' | 'manual' | 'complete' | 'reset', errorMessage?: string): void {
     if (this.#shuttingDown) {
       return;
     }
@@ -64,14 +63,13 @@ export class Compiler {
       }
       case 'error': {
         process.exitCode = 1;
-        if (error) {
-          EventUtil.sendEvent('log', { level: 'error', message: error.toString(), time: Date.now() });
-          log.error('Shutting down due to failure', error.stack);
+        if (errorMessage) {
+          log.error('Shutting down due to failure', errorMessage);
         }
         break;
       }
       case 'reset': {
-        log.info('Reset due to', error?.message);
+        log.info('Reset due to', errorMessage);
         EventUtil.sendEvent('state', { state: 'reset' });
         process.exitCode = 0;
         break;
@@ -80,7 +78,7 @@ export class Compiler {
     // No longer listen to disconnect
     process.removeAllListeners('disconnect');
     process.removeAllListeners('message');
-    this.#controller.abort();
+    this.#shutdownController.abort();
     CommonUtil.nonBlockingTimeout(1000).then(() => process.exit()); // Allow upto 1s to shutdown gracefully
   }
 
@@ -110,35 +108,26 @@ export class Compiler {
     });
   }
 
-  /**
-   * Compile in a single pass, only emitting dirty files
-   */
-  getCompiler(): CompileEmitter {
-    return (sourceFile: string, needsNewProgram?: boolean) => this.#state.compileSourceFile(sourceFile, needsNewProgram);
-  }
-
   /**
    * Emit all files as a stream
    */
-  async * emit(files: string[], emitter: CompileEmitter): AsyncIterable<CompileEmitEvent> {
+  async * emit(files: string[]): AsyncIterable<CompileEmitEvent> {
     let i = 0;
     let lastSent = Date.now();
 
-    await emitter(files[0]); // Prime
-
     for (const file of files) {
       const start = Date.now();
-      const error = await emitter(file);
+      const errors = await this.#state.compileSourceFile(file);
       const duration = Date.now() - start;
       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, error, total: files.length, duration };
+      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' });
       }
-      if (this.#signal.aborted) {
+      if (this.#shutdownSignal.aborted) {
         break;
       }
     }
@@ -157,10 +146,9 @@ export class Compiler {
 
     EventUtil.sendEvent('state', { state: 'init', extra: { processId: process.pid } });
 
-    const emitter = this.getCompiler();
-    let failure: Error | undefined;
+    const failures = new Map<string, number>();
 
-    log.debug('Compiler loaded');
+    log.debug(`Compiler loaded: ${this.#deltaEvents.length} files changed`);
 
     EventUtil.sendEvent('state', { state: 'compile-start' });
 
@@ -168,38 +156,42 @@ export class Compiler {
     const isCompilerChanged = this.#deltaEvents.some(event => this.#state.isCompilerFile(event.sourceFile));
     const changedFiles = (isCompilerChanged ? this.#state.getAllFiles() : this.#deltaEvents.map(event => event.sourceFile));
 
-    if (this.#watch || changedFiles.length) {
-      await ManifestUtil.writeManifest(this.#state.manifestIndex.manifest);
-      await this.#state.initializeTypescript();
-    }
-
     if (changedFiles.length) {
-      for await (const event of this.emit(changedFiles, emitter)) {
-        if (event.error) {
-          const compileError = CompilerUtil.buildTranspileError(event.file, event.error);
-          failure ??= compileError;
-          EventUtil.sendEvent('log', { level: 'error', message: compileError.toString(), time: Date.now() });
+      for await (const event of this.emit(changedFiles)) {
+        if (event.errors?.length) {
+          failures.set(event.file, event.errors.length);
+          for (const error of event.errors) {
+            log.error(`ERROR ${event.file}:${error}`);
+          }
+          // Touch file to ensure recompilation later
+          if (await fs.stat(event.file, { throwIfNoEntry: false })) {
+            await fs.utimes(event.file, new Date(), new Date());
+          }
         }
         metrics.push(event);
       }
-      if (this.#signal.aborted) {
+      if (this.#shutdownSignal.aborted) {
         log.debug('Compilation aborted');
-      } else if (failure) {
-        log.debug('Compilation failed');
-        return this.#shutdown('error', failure);
+      } 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')
+        );
       } else {
         log.debug('Compilation succeeded');
       }
 
-      // Rebuild manifests if dirty
+      // Rebuild manifests
       const manifest = await ManifestUtil.buildManifest(this.#state.manifestIndex.manifest);
       await ManifestUtil.writeManifest(manifest);
       await ManifestUtil.writeDependentManifests(manifest);
+
+      if (!this.#watch && failures.size) {
+        return this.#shutdown('error');
+      }
+
       this.#state.manifestIndex.reinitForModule(this.#state.manifest.main.name); // Reload
-    } else if (this.#watch) {
-      // Prime compiler before complete
-      const resolved = this.#state.getArbitraryInputFile();
-      await emitter(resolved, true);
     }
 
     EventUtil.sendEvent('state', { state: 'compile-end' });
@@ -208,16 +200,22 @@ export class Compiler {
       this.logStatistics(metrics);
     }
 
-    if (this.#watch && !this.#signal.aborted) {
+    if (this.#watch && !this.#shutdownSignal.aborted) {
+      const resolved = this.#state.getArbitraryInputFile();
+      await this.#state.compileSourceFile(resolved);
+
       log.info('Watch is ready');
 
       EventUtil.sendEvent('state', { state: 'watch-start' });
       try {
-        for await (const event of new CompilerWatcher(this.#state, this.#signal)) {
+        for await (const event of new CompilerWatcher(this.#state, this.#shutdownSignal)) {
           if (event.action !== 'delete') {
-            const error = await emitter(event.entry.sourceFile, true);
-            if (error) {
-              log.info('Compilation Error', CompilerUtil.buildTranspileError(event.entry.sourceFile, error));
+            const errors = await this.#state.compileSourceFile(event.entry.sourceFile, true);
+            if (errors?.length) {
+              log.error('Compilation failed', `${event.entry.sourceFile}: ${errors.length} errors found`);
+              for (const error of errors) {
+                log.error(`ERROR ${event.file}:${error}`);
+              }
             } else {
               log.info(`Compiled ${event.entry.sourceFile} on ${event.action}`);
             }
@@ -242,7 +240,7 @@ export class Compiler {
         EventUtil.sendEvent('state', { state: 'watch-end' });
       } catch (error) {
         if (error instanceof Error) {
-          this.#shutdown(error instanceof CompilerReset ? 'reset' : 'error', error);
+          this.#shutdown(error instanceof CompilerReset ? 'reset' : 'error', error.message);
         }
       }
     }
@@ -251,4 +249,4 @@ export class Compiler {
 
     this.#shutdown('complete');
   }
-}
+}

package/src/server/manager.ts

@@ -48,8 +48,9 @@ export class CompilerManager {
 
     yield* queue;
 
-    if (subProcess.exitCode !== 0) {
+    if (subProcess.exitCode !== 0 && subProcess.exitCode) {
       log.error(`Terminated during compilation, code=${subProcess.exitCode}, killed=${subProcess.killed}`);
+      process.exitCode = subProcess.exitCode;
     }
     process.off('SIGINT', kill);
 
@@ -76,7 +77,7 @@ export class CompilerManager {
       log.info('Server already running, waiting for initial compile to complete');
       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');
+      await client.waitForState(['compile-end'], 'Successfully built');
       controller.abort();
     }
   }

package/src/server/server.ts

@@ -27,12 +27,14 @@ export class CompilerServer {
   #client: CompilerClient;
   #url: string;
   #handle: Record<'compiler' | 'server', ProcessHandle>;
+  #suppressLogs: boolean;
 
-  constructor(ctx: ManifestContext, watching: boolean) {
+  constructor(ctx: ManifestContext, watching: boolean, suppressLogs?: boolean) {
     this.#ctx = ctx;
     this.#client = new CompilerClient(ctx, Log.scoped('server.client'));
     this.#url = this.#client.url;
     this.#handle = { server: new ProcessHandle(ctx, 'server'), compiler: new ProcessHandle(ctx, 'compiler') };
+    this.#suppressLogs = suppressLogs ?? /^(1|true|on|yes)$/i.test(process.env.TRV_QUIET ?? '');
 
     this.info = {
       state: 'startup',
@@ -207,7 +209,9 @@ export class CompilerServer {
         }
         log.info(`State changed: ${this.info.state}`);
       } else if (event.type === 'log') {
-        log.render(event.payload);
+        if (!this.#suppressLogs) {
+          log.render(event.payload);
+        }
       }
       if (this.isResetEvent(event)) {
         await this.#disconnectActive();

package/src/state.ts

@@ -1,14 +1,14 @@
+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 { TransformerManager } from '@travetto/transformer';
 
 import { CompilerUtil } from './util.ts';
-import type { CompileEmitError, CompileStateEntry } from './types.ts';
+import type { CompileStateEntry } from './types.ts';
 import { CommonUtil } from './common.ts';
 import { tsProxy as ts, tsProxyInit } from './ts-proxy.ts';
 
-
 const TYPINGS_FOLDER_KEYS = new Set<ManifestModuleFolderType>(['$index', 'support', 'src', '$package']);
 
 export class CompilerState implements CompilerHost {
@@ -40,10 +40,37 @@ export class CompilerState implements CompilerHost {
   #program: Program;
 
   #readFile(sourceFile: string): string | undefined {
-    return ts.sys.readFile(this.#sourceToEntry.get(sourceFile)?.sourceFile ?? sourceFile);
+    const location = this.#sourceToEntry.get(sourceFile)?.sourceFile ?? sourceFile;
+    try {
+      return ts.sys.readFile(location, 'utf8');
+    } catch {
+      try { return fs.readFileSync(location, 'utf8'); } catch { }
+    }
+    return undefined;
   }
 
-  #writeExternalTypings(location: string, text: string, bom: boolean): void {
+  #writeFile(location: string, text: string, bom?: boolean): void {
+    try {
+      ts.sys.writeFile(location, text, bom);
+    } catch {
+      fs.mkdirSync(path.dirname(location), { recursive: true });
+      fs.writeFileSync(location, text, 'utf8');
+    }
+  }
+
+  #fileExists(location: string): boolean {
+    try {
+      return ts.sys.fileExists(location);
+    } catch { return fs.existsSync(location); }
+  }
+
+  #directoryExists(location: string): boolean {
+    try {
+      return ts.sys.directoryExists(location);
+    } catch { return fs.existsSync(location); }
+  }
+
+  #writeExternalTypings(location: string, text: string, bom?: boolean): void {
     let core = location.replace('.map', '');
     if (!this.#outputToEntry.has(core)) {
       core = core.replace(ManifestModuleUtil.TYPINGS_EXT_REGEX, ManifestModuleUtil.OUTPUT_EXT);
@@ -52,7 +79,7 @@ export class CompilerState implements CompilerHost {
     if (entry) {
       const relative = this.#manifestIndex.getFromSource(entry.sourceFile)?.relativeFile;
       if (relative && TYPINGS_FOLDER_KEYS.has(ManifestModuleUtil.getFolderKey(relative))) {
-        ts.sys.writeFile(location.replace(this.#outputPath, this.#typingsPath), text, bom);
+        this.#writeFile(location.replace(this.#outputPath, this.#typingsPath), text, bom);
       }
     }
   }
@@ -60,7 +87,7 @@ export class CompilerState implements CompilerHost {
   async #initCompilerOptions(): Promise<CompilerOptions> {
     const tsconfigFile = CommonUtil.resolveWorkspace(this.#manifest, 'tsconfig.json');
     if (!ts.sys.fileExists(tsconfigFile)) {
-      ts.sys.writeFile(tsconfigFile, JSON.stringify({ extends: '@travetto/compiler/tsconfig.trv.json' }, null, 2));
+      this.#writeFile(tsconfigFile, JSON.stringify({ extends: '@travetto/compiler/tsconfig.trv.json' }, null, 2));
     }
 
     const { options } = ts.parseJsonSourceFileConfigFileContent(
@@ -72,9 +99,7 @@ export class CompilerState implements CompilerHost {
     return {
       ...options,
       noEmit: false,
-      emitDeclarationOnly: false,
       allowJs: true,
-      resolveJsonModule: true,
       sourceRoot: this.#manifest.workspace.path,
       rootDir: this.#manifest.workspace.path,
       moduleResolution: ts.ModuleResolutionKind.Bundler,
@@ -140,8 +165,9 @@ export class CompilerState implements CompilerHost {
     return this.getBySource(randomSource)!.sourceFile;
   }
 
-  async createProgram(force = false): Promise<Program> {
+  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.#transformerManager.init(this.#program.getTypeChecker());
       await CommonUtil.queueMacroTask();
@@ -149,36 +175,56 @@ export class CompilerState implements CompilerHost {
     return this.#program;
   }
 
-  async compileSourceFile(sourceFile: string, needsNewProgram = false): Promise<CompileEmitError | undefined> {
+  async compileSourceFile(sourceFile: string, needsNewProgram = false): Promise<string[] | undefined> {
     const output = this.#sourceToEntry.get(sourceFile)?.outputFile;
     if (!output) {
       return;
     }
 
-    const program = await this.createProgram(needsNewProgram);
-    try {
-      switch (ManifestModuleUtil.getFileType(sourceFile)) {
-        case 'typings':
-        case 'package-json':
-          this.writeFile(output, this.readFile(sourceFile)!, false), undefined;
-          break;
-        case 'js':
-          this.writeFile(output, ts.transpile(this.readFile(sourceFile)!, this.#compilerOptions), false);
-          break;
-        case 'ts': {
-          const result = program.emit(
-            program.getSourceFile(sourceFile)!,
-            (...args) => this.writeFile(args[0], args[1], args[2]), undefined, false,
-            this.#transformerManager.get()
-          );
-          return result?.diagnostics?.length ? result.diagnostics : undefined;
-        }
+    switch (ManifestModuleUtil.getFileType(sourceFile)) {
+      case 'package-json': {
+        const text = this.readFile(sourceFile)!;
+        const finalText = CompilerUtil.rewritePackageJSON(this.#manifest, text);
+        const location = this.#tscOutputFileToOuptut.get(output) ?? output;
+        this.#writeFile(location, finalText);
+        this.#writeExternalTypings(location, finalText);
+        break;
       }
-    } catch (error) {
-      if (error instanceof Error) {
-        return error;
-      } else {
-        throw error;
+      case 'js':
+      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,
+          this.#transformerManager.get()
+        );
+        return [
+          ...program.getSemanticDiagnostics(tsSourceFile),
+          ...program.getSyntacticDiagnostics(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'")
+            ) {
+              return '';
+            }
+            if (diag.file) {
+              const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start!);
+              message = `${line + 1}:${character + 1} -- ${message}`;
+            }
+            return message;
+          })
+          .filter(Boolean);
       }
     }
   }
@@ -271,32 +317,24 @@ export class CompilerState implements CompilerHost {
   getDefaultLibLocation(): string { return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions)); }
 
   fileExists(sourceFile: string): boolean {
-    return this.#sourceToEntry.has(sourceFile) || ts.sys.fileExists(sourceFile);
+    return this.#sourceToEntry.has(sourceFile) || this.#fileExists(sourceFile);
   }
 
   directoryExists(sourceDirectory: string): boolean {
-    return this.#sourceDirectory.has(sourceDirectory) || ts.sys.directoryExists(sourceDirectory);
+    return this.#sourceDirectory.has(sourceDirectory) || this.#directoryExists(sourceDirectory);
   }
 
-  writeFile(
-    outputFile: string,
-    text: string,
-    bom: boolean
-  ): void {
-    if (outputFile.endsWith('package.json')) {
-      text = CompilerUtil.rewritePackageJSON(this.#manifest, text);
-    }
-
+  writeFile(outputFile: string, text: string, bom?: boolean): void {
     // JSX runtime shenanigans
     text = text.replace(/support\/jsx-runtime"/g, 'support/jsx-runtime.js"');
 
     const location = this.#tscOutputFileToOuptut.get(outputFile) ?? outputFile;
 
-    if (ManifestModuleUtil.TYPINGS_WITH_MAP_EXT_REGEX.test(outputFile) || outputFile.endsWith('package.json')) {
+    if (ManifestModuleUtil.TYPINGS_WITH_MAP_EXT_REGEX.test(outputFile)) {
       this.#writeExternalTypings(location, text, bom);
     }
 
-    ts.sys.writeFile(location, text, bom);
+    return this.#writeFile(location, text, bom);
   }
 
   readFile(sourceFile: string): string | undefined {

package/src/ts-proxy.ts

@@ -2,7 +2,8 @@
 import type ts from 'typescript';
 
 let state: typeof ts | undefined;
-export const tsProxyInit = (): Promise<unknown> => import('typescript').then(module => { state = module.default; });
+let promise: Promise<unknown> | undefined;
+export const tsProxyInit = (): Promise<unknown> => promise ??= import('typescript').then(module => { state = module.default; });
 
 export const tsProxy = new Proxy({}!, {
   get(_, prop: string): unknown {

package/src/types.ts

@@ -1,13 +1,9 @@
-import type ts from 'typescript';
-
 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 CompileEmitError = Error | readonly ts.Diagnostic[];
-export type CompileEmitter = (file: string, newProgram?: boolean) => Promise<CompileEmitError | undefined>;
-export type CompileEmitEvent = { file: string, i: number, total: number, error?: CompileEmitError, duration: number };
+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 };
 

package/src/util.ts

@@ -1,10 +1,5 @@
 import { ManifestModuleUtil, type ManifestRoot, type Package } from '@travetto/manifest';
 
-import type { CompileEmitError } from './types.ts';
-import { tsProxy as ts } from './ts-proxy.ts';
-
-const nativeCwd = process.cwd();
-
 /**
  * Standard utilities for compiler
  */
@@ -38,32 +33,6 @@ export class CompilerUtil {
     return JSON.stringify(pkg, null, 2);
   }
 
-  /**
-   * Build transpilation error
-   * @param filename The name of the file
-   * @param diagnostics The diagnostic errors
-   */
-  static buildTranspileError(filename: string, diagnostics: CompileEmitError): Error {
-    if (diagnostics instanceof Error) {
-      return diagnostics;
-    }
-
-    const errors: string[] = diagnostics.slice(0, 5).map(diag => {
-      const message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
-      if (diag.file) {
-        const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start!);
-        return ` @ ${diag.file.fileName.replace(nativeCwd, '.')}(${line + 1}, ${character + 1}): ${message}`;
-      } else {
-        return ` ${message}`;
-      }
-    });
-
-    if (diagnostics.length > 5) {
-      errors.push(`${diagnostics.length - 5} more ...`);
-    }
-    return new Error(`Transpiling ${filename.replace(nativeCwd, '.')} failed: \n${errors.join('\n')}`);
-  }
-
   /**
    * Naive hashing
    */

package/src/watch.ts

@@ -195,7 +195,7 @@ export class CompilerWatcher {
         return;
       }
       const full = path.resolve(toolRootFolder, file);
-      const stat = await fs.stat(full).catch(() => null);
+      const stat = await fs.stat(full, { throwIfNoEntry: false });
       if (toolFolders.has(full) && !stat) {
         this.#queue.throw(new CompilerReset(`Tooling folder removal ${full}`));
       }
@@ -229,7 +229,7 @@ export class CompilerWatcher {
 
   async #listenGitChanges(): Promise<void> {
     const gitFolder = path.resolve(this.#root, '.git');
-    if (!await fs.stat(gitFolder).catch(() => 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) {

package/support/invoke.ts

@@ -7,40 +7,62 @@ import { CompilerClient } from '../src/server/client.ts';
 import { CommonUtil } from '../src/common.ts';
 import { EventUtil } from '../src/event.ts';
 
-const HELP = `
-trvc [command]
+const hasColor = (process.stdout.isTTY && /^(0)*$/.test(process.env.NO_COLOR ?? '')) || /1\d*/.test(process.env.FORCE_COLOR ?? '');
+const color = (code: number) => (value: string): string => hasColor ? `\x1b[${code}m${value}\x1b[0m` : `${value}`;
+const STYLE = { error: color(91), title: color(36), main: color(92), command: color(35), arg: color(37), description: color(33), };
 
-Available Commands:
- * start|watch                  - Run the compiler in watch mode
- * stop                         - Stop the compiler if running
- * restart                      - Restart the compiler in watch mode
- * build                        - Ensure the project is built and upto date
- * clean                        - Clean out the output and compiler caches
- * info                         - Retrieve the compiler information, if running
- * event <log|progress|state>   - Watch events in realtime as newline delimited JSON
- * exec <file> [...args]        - Allow for compiling and executing an entrypoint file
- * manifest [output]            - Generate the project manifest
- * manifest:production [output] - Generate the production project manifest
-`;
+const COMMANDS = {
+  start: { description: 'Run the compiler in watch mode' },
+  stop: { description: 'Stop the compiler if running' },
+  restart: { description: 'Restart the compiler in watch mode' },
+  build: { description: 'Ensure the project is built and upto date' },
+  clean: { description: 'Clean out the output and compiler caches' },
+  info: { description: 'Retrieve the compiler information, if running' },
+  event: { args: ['<log|progress|state>'], description: 'Watch events in realtime as newline delimited JSON' },
+  exec: { args: ['<file>', '[...args]'], description: 'Allow for compiling and executing an entrypoint file' },
+  manifest: { args: ['[output]'], description: 'Generate the project manifest' },
+  'manifest:production': { args: ['[output]'], description: 'Generate the production project manifest' }
+} as const;
+
+function showHelp(errorMessage?: string): void {
+  const PREPARED = Object.entries(COMMANDS)
+    .map(([name, config]) => ({ args: [], ...config, name }))
+    .map(config => ({ ...config, commandLength: [config.name, ...config.args].join(' ').length }));
+
+  const commandWidth = Math.max(...PREPARED.map(config => config.commandLength));
+
+  console.log([
+    ...(errorMessage ? ['', STYLE.error(errorMessage)] : []),
+    '', `${STYLE.main('trvc')} ${STYLE.command('[command]')}`,
+    '', STYLE.title('Available Commands'),
+    ...PREPARED.map(({ name, args, description, commandLength }) => [
+      '*', STYLE.command(name), ...args.map(arg => STYLE.arg(arg)),
+      ' '.repeat(commandWidth - commandLength), '-', STYLE.description(description)
+
+    ].join(' ')),
+    ''
+  ].join('\n'));
+}
+
+const validateInputs = (value: string[]): value is [keyof typeof COMMANDS, ...string[]] => !!value.length && value[0] in COMMANDS;
 
 /**
  * Invoke the compiler
  */
-export async function invoke(operation?: string, args: string[] = []): Promise<unknown> {
-  if (operation === undefined) {
-    [operation, ...args] = process.argv.slice(2);
+export async function invoke(...input: string[]): Promise<unknown> {
+  if (!validateInputs(input)) {
+    return showHelp(input[0] ? `Unknown trvc command: ${input[0]}` : undefined);;
   }
+
+  const [command, ...args] = input;
   const ctx = getManifestContext();
   const client = new CompilerClient(ctx, Log.scoped('client'));
 
   Log.initLevel('error');
   Log.root = ctx.workspace.path;
 
-  switch (operation) {
-    case undefined:
-    case 'help': console.log(HELP); break;
-    case 'start':
-    case 'watch': return CompilerManager.compile(ctx, client, { watch: true });
+  switch (command) {
+    case 'start': return CompilerManager.compile(ctx, client, { watch: true });
     case 'build': return CompilerManager.compile(ctx, client, { watch: false });
     case 'restart': return CompilerManager.compile(ctx, client, { watch: true, forceRestart: true });
     case 'info': {
@@ -59,7 +81,7 @@ export async function invoke(operation?: string, args: string[] = []): Promise<u
     case 'manifest:production':
     case 'manifest': {
       let manifest = await ManifestUtil.buildManifest(ctx);
-      if (operation === 'manifest:production') {
+      if (command === 'manifest:production') {
         manifest = ManifestUtil.createProductionManifest(manifest);
       }
       if (args[0]) {
@@ -92,6 +114,5 @@ export async function invoke(operation?: string, args: string[] = []): Promise<u
       // Return function to run import on a module
       return import(importTarget);
     }
-    default: console.error(`\nUnknown trvc operation: ${operation}\n${HELP}`);
   }
 }

package/tsconfig.trv.json

@@ -7,17 +7,22 @@
     "lib": [
       "ESNext",
     ],
+    "types": [
+      "node"
+    ],
     "jsx": "react-jsx",
     "stableTypeOrdering": true,
     "strict": true,
     "declaration": true,
     "declarationMap": true,
+    "emitDeclarationOnly": false,
     "noUncheckedSideEffectImports": true,
     "libReplacement": false,
     "strictPropertyInitialization": false,
     "erasableSyntaxOnly": true,
     "experimentalDecorators": true,
     "noEmitOnError": false,
+    "allowJs": true,
     "noErrorTruncation": true,
     "resolveJsonModule": true,
     "sourceMap": true,