@travetto/compiler 4.0.0-rc.5 → 4.0.0-rc.7

package/README.md

@@ -38,8 +38,8 @@ In addition to the normal output, the compiler supports an environment variable
 ```bash
 $ TRV_BUILD=debug trvc build
 
-2029-03-14T04:00:00.618Z info  [compiler-server] Starting server http://127.0.0.1:25539
-2029-03-14T04:00:00.837Z debug [client.main    ] Start Server
+2029-03-14T04:00:00.618Z info  [server         ] Starting server http://127.0.0.1:25539
+2029-03-14T04:00:00.837Z debug [main           ] Start Server
 2029-03-14T04:00:01.510Z debug [event-stream   ] Started event stream
 2029-03-14T04:00:02.450Z debug [precompile     ] Started
 2029-03-14T04:00:02.762Z debug [precompile     ] Skipped @travetto/manifest
@@ -60,14 +60,14 @@ $ TRV_BUILD=debug trvc build
 2029-03-14T04:00:10.799Z debug [manifest       ] Started
 2029-03-14T04:00:11.013Z debug [manifest       ] Wrote manifest @travetto-doc/compiler
 2029-03-14T04:00:11.827Z debug [manifest       ] Completed
-2029-03-14T04:00:11.894Z info  [compiler-server] State changed: compile-end
+2029-03-14T04:00:11.894Z info  [server         ] State changed: compile-end
 2029-03-14T04:00:12.133Z debug [compiler-exec  ] Skipped
 2029-03-14T04:00:13.123Z debug [event-stream   ] Finished event stream
-2029-03-14T04:00:14.014Z info  [compiler-server] Closing down server
-2029-03-14T04:00:14.924Z debug [compiler-server] Server close event
-2029-03-14T04:00:15.690Z info  [compiler-server] Closed down server
-2029-03-14T04:00:15.865Z debug [compiler-server] Finished processing events
-2029-03-14T04:00:16.757Z debug [client.main    ] End Server
+2029-03-14T04:00:14.014Z info  [server         ] Closing down server
+2029-03-14T04:00:14.924Z debug [server         ] Server close event
+2029-03-14T04:00:15.690Z info  [server         ] Closed down server
+2029-03-14T04:00:15.865Z debug [server         ] Finished processing events
+2029-03-14T04:00:16.757Z debug [main           ] End Server
 ```
 
 **Terminal: Sample trv output with default log level**

package/__index__.ts

@@ -2,5 +2,4 @@ export * from './src/compiler';
 export * from './src/state';
 export * from './src/util';
 export * from './src/watch';
-export * from './src/log';
 export * from './src/types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "4.0.0-rc.5",
+  "version": "4.0.0-rc.7",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -31,12 +31,12 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.4.0",
-    "@travetto/manifest": "^4.0.0-rc.5",
-    "@travetto/transformer": "^4.0.0-rc.5",
+    "@travetto/manifest": "^4.0.0-rc.7",
+    "@travetto/transformer": "^4.0.0-rc.7",
     "@types/node": "^20.11.16"
   },
   "peerDependencies": {
-    "@travetto/cli": "^4.0.0-rc.6"
+    "@travetto/cli": "^4.0.0-rc.8"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -1,4 +1,3 @@
-import ts from 'typescript';
 import timers from 'node:timers/promises';
 import fs from 'node:fs/promises';
 import { setMaxListeners } from 'node:events';
@@ -8,10 +7,13 @@ import { ManifestModuleUtil, RuntimeIndex } from '@travetto/manifest';
 import { CompilerUtil } from './util';
 import { CompilerState } from './state';
 import { CompilerWatcher } from './watch';
-import { Log } from './log';
-import { CompileEmitError, CompileEmitEvent, CompileEmitter } from './types';
+import { CompileEmitEvent, CompileEmitter } from './types';
 import { EventUtil } from './event';
 
+import { IpcLogger } from '../support/log';
+
+const log = new IpcLogger({ level: 'debug' });
+
 /**
  * Compilation support
  */
@@ -23,7 +25,7 @@ export class Compiler {
   static async main(): Promise<void> {
     const [dirty, watch] = process.argv.slice(2);
     const state = await CompilerState.get(RuntimeIndex);
-    Log.debug('Running compiler with dirty file', dirty);
+    log.debug('Running compiler with dirty file', dirty);
     const dirtyFiles = ManifestModuleUtil.getFileType(dirty) === 'ts' ? [dirty] : (await fs.readFile(dirty, 'utf8')).split(/\n/).filter(x => !!x);
     await new Compiler(state, dirtyFiles, watch === 'true').run();
   }
@@ -58,19 +60,19 @@ export class Compiler {
     this.#shuttingDown = true;
     switch (mode) {
       case 'manual': {
-        Log.error('Shutting down manually');
+        log.error('Shutting down manually');
         process.exitCode = 2;
         break;
       }
       case 'error': {
         process.exitCode = 1;
         if (err) {
-          Log.error('Shutting down due to failure', err.message);
+          log.error('Shutting down due to failure', err.message);
         }
         break;
       }
       case 'reset': {
-        Log.info('Triggering reset due to change in core files', err?.cause);
+        log.info('Triggering reset due to change in core files', err?.cause);
         EventUtil.sendEvent('state', { state: 'reset' });
         process.exitCode = 0;
         break;
@@ -86,29 +88,8 @@ export class Compiler {
   /**
    * Compile in a single pass, only emitting dirty files
    */
-  async getCompiler(): Promise<CompileEmitter> {
-    let program: ts.Program;
-
-    const emit = async (inputFile: string, needsNewProgram = program === undefined): Promise<CompileEmitError | undefined> => {
-      try {
-        if (needsNewProgram) {
-          program = this.#state.createProgram(program);
-        }
-        await timers.setImmediate();
-        const result = this.#state.writeInputFile(program, inputFile);
-        if (result?.diagnostics?.length) {
-          return result.diagnostics;
-        }
-      } catch (err) {
-        if (err instanceof Error) {
-          return err;
-        } else {
-          throw err;
-        }
-      }
-    };
-
-    return emit;
+  getCompiler(): CompileEmitter {
+    return (inputFile: string, needsNewProgram?: boolean) => this.#state.writeInputFile(inputFile, needsNewProgram);
   }
 
   /**
@@ -134,21 +115,21 @@ export class Compiler {
 
     await timers.setTimeout(1);
 
-    Log.debug(`Compiled ${i} files`);
+    log.debug(`Compiled ${i} files`);
   }
 
   /**
    * Run the compiler
    */
   async run(): Promise<void> {
-    Log.debug('Compilation started');
+    log.debug('Compilation started');
 
     EventUtil.sendEvent('state', { state: 'init', extra: { pid: process.pid } });
 
     const emitter = await this.getCompiler();
     let failed = false;
 
-    Log.debug('Compiler loaded');
+    log.debug('Compiler loaded');
 
     EventUtil.sendEvent('state', { state: 'compile-start' });
 
@@ -161,13 +142,13 @@ export class Compiler {
         }
       }
       if (this.#signal.aborted) {
-        Log.debug('Compilation aborted');
+        log.debug('Compilation aborted');
       } else if (failed) {
-        Log.debug('Compilation failed');
+        log.debug('Compilation failed');
         process.exitCode = 1;
         return;
       } else {
-        Log.debug('Compilation succeeded');
+        log.debug('Compilation succeeded');
       }
     } else if (this.#watch) {
       // Prime compiler before complete
@@ -178,7 +159,7 @@ export class Compiler {
     EventUtil.sendEvent('state', { state: 'compile-end' });
 
     if (this.#watch && !this.#signal.aborted) {
-      Log.info('Watch is ready');
+      log.info('Watch is ready');
 
       EventUtil.sendEvent('state', { state: 'watch-start' });
       try {
@@ -186,14 +167,14 @@ export class Compiler {
           if (ev.action !== 'delete') {
             const err = await emitter(ev.entry.inputFile, true);
             if (err) {
-              Log.info('Compilation Error', CompilerUtil.buildTranspileError(ev.entry.inputFile, err));
+              log.info('Compilation Error', CompilerUtil.buildTranspileError(ev.entry.inputFile, err));
             } else {
-              Log.info(`Compiled ${ev.entry.sourceFile} on ${ev.action}`);
+              log.info(`Compiled ${ev.entry.sourceFile} on ${ev.action}`);
             }
           } else {
             if (ev.entry.outputFile) {
               // Remove output
-              Log.info(`Removed ${ev.entry.sourceFile}, ${ev.entry.outputFile}`);
+              log.info(`Removed ${ev.entry.sourceFile}, ${ev.entry.outputFile}`);
               await fs.rm(ev.entry.outputFile, { force: true }); // Ensure output is deleted
             }
           }
@@ -216,7 +197,7 @@ export class Compiler {
       }
     }
 
-    Log.debug('Compiler process shutdown');
+    log.debug('Compiler process shutdown');
 
     this.#shutdown('complete');
   }

package/src/state.ts

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import timers from 'node:timers/promises';
 
 import { path, ManifestModuleUtil, ManifestModule, ManifestRoot, ManifestIndex } from '@travetto/manifest';
 import { TransformerManager } from '@travetto/transformer';
@@ -6,7 +7,7 @@ import { TransformerManager } from '@travetto/transformer';
 import { CommonUtil } from '../support/util';
 
 import { CompilerUtil } from './util';
-import { CompileStateEntry } from './types';
+import { CompileEmitError, CompileStateEntry } from './types';
 
 function folderMapper(root: string, prefix: string): { dir: string, translate: (val: string) => string } {
   let matched: string = '~~';
@@ -44,6 +45,7 @@ export class CompilerState implements ts.CompilerHost {
   #modules: ManifestModule[];
   #transformerManager: TransformerManager;
   #compilerOptions: ts.CompilerOptions;
+  #program: ts.Program;
 
   #readFile(inputFile: string): string | undefined {
     return ts.sys.readFile(this.#inputToEntry.get(inputFile)?.sourceFile ?? this.#inputPathToSourcePath(inputFile));
@@ -104,24 +106,40 @@ export class CompilerState implements ts.CompilerHost {
     return this.getBySource(this.#manifestIndex.getModule('@travetto/manifest')!.files.src[0].sourceFile)!.inputFile;
   }
 
-  createProgram(oldProgram?: ts.Program): ts.Program {
-    const prog = ts.createProgram({ rootNames: this.getAllFiles(), host: this, options: this.#compilerOptions, oldProgram });
-    this.#transformerManager.init(prog.getTypeChecker());
-    return prog;
-  }
-
-  writeInputFile(program: ts.Program, inputFile: string): ts.EmitResult | undefined | void {
-    switch (ManifestModuleUtil.getFileType(inputFile)) {
-      case 'package-json':
-        return this.writeFile(this.#inputToEntry.get(inputFile)!.outputFile!, this.readFile(inputFile)!, false);
-      case 'js':
-        return this.writeFile(this.#inputToEntry.get(inputFile)!.outputFile!, ts.transpile(this.readFile(inputFile)!, this.#compilerOptions), false);
-      case 'ts':
-        return program.emit(
-          program.getSourceFile(inputFile)!,
-          (...args) => this.writeFile(...args), undefined, false,
-          this.#transformerManager.get()
-        );
+  async createProgram(force = false): Promise<ts.Program> {
+    if (force || !this.#program) {
+      this.#program = ts.createProgram({ rootNames: this.getAllFiles(), host: this, options: this.#compilerOptions, oldProgram: this.#program });
+      this.#transformerManager.init(this.#program.getTypeChecker());
+      await timers.setImmediate();
+    }
+    return this.#program;
+  }
+
+  async writeInputFile(inputFile: string, needsNewProgram = false): Promise<CompileEmitError | undefined> {
+    const program = await this.createProgram(needsNewProgram);
+    try {
+      switch (ManifestModuleUtil.getFileType(inputFile)) {
+        case 'package-json':
+          this.writeFile(this.#inputToEntry.get(inputFile)!.outputFile!, this.readFile(inputFile)!, false), undefined;
+          break;
+        case 'js':
+          this.writeFile(this.#inputToEntry.get(inputFile)!.outputFile!, ts.transpile(this.readFile(inputFile)!, this.#compilerOptions), false);
+          break;
+        case 'ts': {
+          const result = program.emit(
+            program.getSourceFile(inputFile)!,
+            (...args) => this.writeFile(...args), undefined, false,
+            this.#transformerManager.get()
+          );
+          return result?.diagnostics?.length ? result.diagnostics : undefined;
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error) {
+        return err;
+      } else {
+        throw err;
+      }
     }
   }
 

package/support/entry.trvc.ts

@@ -4,8 +4,8 @@ import path from 'node:path';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerLogLevel, CompilerMode, CompilerServerInfo } from './types';
-import { LogUtil } from './log';
+import type { CompilerMode, CompilerServerInfo } from './types';
+import { Log } from './log';
 import { CommonUtil } from './util';
 import { CompilerSetup } from './setup';
 import { CompilerServer } from './server/server';
@@ -14,40 +14,38 @@ import { CompilerClient } from './server/client';
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export const main = (ctx: ManifestContext) => {
-  const log = LogUtil.logger('client.main');
-  const client = new CompilerClient(ctx, log);
+  const client = new CompilerClient(ctx, Log.scoped('client'));
   const buildFolders = [ctx.build.outputFolder, ctx.build.compilerFolder];
+  Log.root = ctx.workspace.path;
+  Log.initLevel('error');
 
   /** Main entry point for compilation */
-  const compile = async (op: CompilerMode, logLevel: CompilerLogLevel, setupOnly = false): Promise<void> => {
-    LogUtil.initLogs(ctx, logLevel ?? 'info');
-
+  const compile = async (op: CompilerMode, setupOnly = false): Promise<void> => {
     const server = await new CompilerServer(ctx, op).listen();
+    const log = Log.scoped('main');
 
     // Wait for build to be ready
     if (server) {
-      log('debug', 'Start Server');
+      log.debug('Start Server');
       await server.processEvents(async function* (signal) {
         const changed = await CompilerSetup.setup(ctx);
         if (!setupOnly) {
           yield* CompilerRunner.runProcess(ctx, changed, op, signal);
         }
       });
-      log('debug', 'End Server');
+      log.debug('End Server');
     } else {
-      log('info', 'Server already running, waiting for initial compile to complete');
+      log.info('Server already running, waiting for initial compile to complete');
       const ctrl = new AbortController();
-      LogUtil.consumeProgressEvents(() => client.fetchEvents('progress', { until: ev => !!ev.complete, signal: ctrl.signal }));
+      Log.consumeProgressEvents(() => client.fetchEvents('progress', { until: ev => !!ev.complete, signal: ctrl.signal }));
       await client.waitForState(['compile-end', 'watch-start'], 'Successfully built');
       ctrl.abort();
     }
-    LogUtil.cleanup();
   };
 
   const ops = {
     /** Stop the server */
     async stop(): Promise<void> {
-      LogUtil.initLogs(ctx);
       if (await client.stop()) {
         console.log(`Stopped server ${ctx.workspace.path}: ${client}`);
       } else {
@@ -63,7 +61,6 @@ export const main = (ctx: ManifestContext) => {
 
     /** Clean the server */
     async clean(): Promise<void> {
-      LogUtil.initLogs(ctx);
       if (await client.clean()) {
         return console.log(`Clean triggered ${ctx.workspace.path}:`, buildFolders);
       } else {
@@ -74,7 +71,6 @@ export const main = (ctx: ManifestContext) => {
 
     /** Stream events */
     events: async (type: string, handler: (ev: unknown) => unknown): Promise<void> => {
-      LogUtil.initLogs(ctx, 'error');
       if (type === 'change' || type === 'log' || type === 'progress' || type === 'state') {
         for await (const ev of client.fetchEvents(type)) { await handler(ev); }
       } else {
@@ -83,23 +79,30 @@ export const main = (ctx: ManifestContext) => {
     },
 
     /** Build the project */
-    async build(): Promise<void> { await compile('build', 'info'); },
+    async build(): Promise<void> {
+      Log.initLevel('info');
+      await compile('build');
+    },
 
     /** Build and watch the project */
-    async watch(): Promise<void> { await compile('watch', 'info'); },
+    async watch(): Promise<void> {
+      Log.initLevel('info');
+      await compile('watch');
+    },
 
     /** Build and return a loader */
     async getLoader(): Promise<(mod: string) => Promise<unknown>> {
-      // Short circuit if we can
-      if (!(await client.isWatching())) {
-        await compile('build', LogUtil.isInteractiveShell ? 'info' : 'error');
+      Log.initLevel('none');
+      if (!(await client.isWatching())) { // Short circuit if we can
+        Log.initLevel('error');
+        await compile('build');
       }
       return CommonUtil.moduleLoader(ctx);
     },
 
     /** Manifest entry point */
     async manifest(output?: string, prod?: boolean): Promise<void> {
-      await compile('build', 'error', true);
+      await compile('build', true);
       await CompilerSetup.exportManifest(ctx, output, prod); return;
     }
   };

package/support/log.ts

@@ -1,117 +1,130 @@
-import type { ManifestContext } from '@travetto/manifest';
-import type { CompilerLogEvent, CompilerLogLevel, CompilerProgressEvent } from './types';
-
-export type CompilerLogger = (level: CompilerLogLevel, message: string, ...args: unknown[]) => void;
-export type WithLogger<T> = (log: CompilerLogger) => Promise<T>;
-
-type ProgressWriter = (ev: CompilerProgressEvent) => (unknown | Promise<unknown>);
-
-const LEVEL_TO_PRI: Record<CompilerLogLevel, number> = { debug: 1, info: 2, warn: 3, error: 4 };
+import { CompilerLogEvent, CompilerLogLevel, CompilerProgressEvent } from './types';
 
+const LEVEL_TO_PRI: Record<CompilerLogLevel | 'none', number> = { debug: 1, info: 2, warn: 3, error: 4, none: 5 };
 const SCOPE_MAX = 15;
 
-const ESC = '\x1b[';
-
-export class LogUtil {
+type LogConfig = {
+  level?: CompilerLogLevel | 'none';
+  root?: string;
+  scope?: string;
+  parent?: Logger;
+};
 
-  static root = process.cwd();
+export type LogShape = Record<'info' | 'debug' | 'warn' | 'error', (message: string, ...args: unknown[]) => void>;
 
-  static logLevel: CompilerLogLevel = 'error';
+const ESC = '\x1b[';
 
-  static logProgress?: ProgressWriter;
+export class Logger implements LogConfig, LogShape {
 
-  static linePartial = false;
+  static #linePartial: boolean | undefined;
 
-  static #rewriteLine(text: string): Promise<void> | void {
+  /** Rewrite text line, tracking cleanup as necessary */
+  static rewriteLine(text: string): Promise<void> | void {
+    if ((!text && !this.#linePartial) || !process.stdout.isTTY) {
+      return;
+    }
+    if (this.#linePartial === undefined) { // First time
+      process.stdout.write(`${ESC}?25l`); // Hide cursor
+      process.on('exit', () => this.reset());
+    }
     // Move to 1st position, and clear after text
     const done = process.stdout.write(`${ESC}1G${text}${ESC}0K`);
-    this.linePartial = !!text;
+    this.#linePartial = !!text;
     if (!done) {
       return new Promise<void>(r => process.stdout.once('drain', r));
     }
   }
 
-  /** Are we in a shell that is interactive */
-  static get isInteractiveShell(): boolean {
-    return !!process.env.PS1 && process.stdout.isTTY;
+  static reset(): void { process.stdout.write(`${ESC}!p${ESC}?25h`); }
+
+  level?: CompilerLogLevel | 'none';
+  root: string = process.cwd();
+  scope?: string;
+  parent?: Logger;
+
+  constructor(cfg: LogConfig = {}) {
+    Object.assign(this, cfg);
   }
 
-  /**
-   * Set level for operation
-   */
-  static initLogs(ctx: ManifestContext, defaultLevel?: CompilerLogLevel): void {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const build = process.env.TRV_BUILD as CompilerLogLevel | 'none';
-    if (build !== 'none' && process.env.TRV_QUIET !== 'true') {
-      this.logLevel = build || defaultLevel;
-    }
-    this.root = ctx.workspace.path;
-    // If we are in info or a terminal and also in a tty
-    this.logProgress = (this.isLevelActive('info') && process.stdout.isTTY) ? this.#logProgressEvent : undefined;
-    if (this.logProgress) {
-      process.stdout.write(`${ESC}?25l`); // Hide cursor
+  valid(ev: CompilerLogEvent): boolean {
+    return LEVEL_TO_PRI[this.level ?? this.parent?.level!] <= LEVEL_TO_PRI[ev.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, ' ')}]`);
     }
-    process.on('exit', () => this.cleanup());
+    params.unshift(new Date().toISOString(), `${ev.level.padEnd(5)}`);
+    Logger.rewriteLine(''); // Clear out progress line, if active
+    // eslint-disable-next-line no-console
+    console[ev.level]!(...params);
   }
 
-  static cleanup(): void {
-    if (this.logProgress) {
-      process.stdout.write(`${ESC}!p`); // Reset
+  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 }); }
+}
+
+
+class $RootLogger extends Logger {
+  #logProgress?: boolean;
+
+  /** Get if we should log progress */
+  get logProgress(): boolean {
+    if (this.#logProgress === undefined) {
+      this.#logProgress = !!process.env.PS1 && process.stdout.isTTY && process.env.TRV_BUILD !== 'none' && process.env.TRV_QUIET !== 'true';
     }
+    return this.#logProgress;
   }
 
-  static #logProgressEvent(ev: CompilerProgressEvent): Promise<void> | void {
-    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}`;
-    return this.#rewriteLine(text);
+  /** Set level for operation */
+  initLevel(defaultLevel: CompilerLogLevel | 'none'): void {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const build = process.env.TRV_BUILD as CompilerLogLevel | 'none';
+    this.level = (build !== 'none' && process.env.TRV_QUIET !== 'true') ? (build || defaultLevel) : 'none';
   }
 
-  /**
-   * Is the log level active?
-   */
-  static isLevelActive(lvl: CompilerLogLevel): boolean {
-    return LEVEL_TO_PRI[this.logLevel] <= LEVEL_TO_PRI[lvl];
+  /** Produce a scoped logger */
+  scoped(name: string): Logger {
+    return new Logger({ parent: this, scope: name });
   }
 
-  /**
-   * Log event with filtering by level
-   */
-  static logEvent(ev: CompilerLogEvent): void {
-    if (this.isLevelActive(ev.level)) {
-      const params = [ev.message, ...ev.args ?? []].map(x => typeof x === 'string' ? x.replaceAll(this.root, '.') : x);
-      if (ev.scope) {
-        params.unshift(`[${ev.scope.padEnd(SCOPE_MAX, ' ')}]`);
-      }
-      params.unshift(new Date().toISOString(), `${ev.level.padEnd(5)}`);
-      if (this.linePartial) {
-        this.#rewriteLine(''); // Clear out progress line
-      }
-      // eslint-disable-next-line no-console
-      console[ev.level]!(...params);
-    }
+  /** 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);
   }
 
-  /**
-   * With logger
-   */
-  static withLogger<T>(scope: string, op: WithLogger<T>, basic = true): Promise<T> {
-    const log = this.logger(scope);
-    basic && log('debug', 'Started');
-    return op(log).finally(() => basic && log('debug', 'Completed'));
+  /** Write progress event, if active */
+  onProgressEvent(ev: 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}`;
+    return Logger.rewriteLine(text);
   }
 
-  /**
-   * With scope
-   */
-  static logger(scope: string): CompilerLogger {
-    return (level, message, ...args) => this.logEvent({ scope, message, level, args, time: Date.now() });
+  /** Write all progress events if active */
+  async consumeProgressEvents(src: () => AsyncIterable<CompilerProgressEvent>): Promise<void> {
+    if (!(this.logProgress)) { return; }
+    for await (const ev of src()) { this.onProgressEvent(ev); }
+    Logger.reset();
   }
+}
 
-  /**
-   * Write all progress events if active
-   */
-  static async consumeProgressEvents(src: () => AsyncIterable<CompilerProgressEvent>): Promise<void> {
-    if (!this.logProgress) { return; }
-    for await (const item of src()) { await this.logProgress?.(item); }
+export const Log = new $RootLogger();
+
+export class IpcLogger extends Logger {
+  render(ev: CompilerLogEvent): void {
+    if (!this.valid(ev)) { return; }
+    if (process.connected && process.send) {
+      process.send({ type: 'log', payload: ev });
+    }
+    if (!process.connected) {
+      super.render(ev);
+    }
   }
-}
+}

package/support/server/client.ts

@@ -5,7 +5,7 @@ import { Readable } from 'node:stream';
 import { ManifestContext } from '@travetto/manifest';
 
 import type { CompilerEvent, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types';
-import type { CompilerLogger } from '../log';
+import type { LogShape } from '../log';
 import { ProcessHandle } from './process-handle';
 
 type FetchEventsConfig<T> = {
@@ -20,10 +20,10 @@ type FetchEventsConfig<T> = {
 export class CompilerClient {
 
   #url: string;
-  #log: CompilerLogger;
+  #log: LogShape;
   #handle: Record<'compiler' | 'server', ProcessHandle>;
 
-  constructor(ctx: ManifestContext, log: CompilerLogger) {
+  constructor(ctx: ManifestContext, log: LogShape) {
     this.#url = ctx.build.compilerUrl.replace('localhost', '127.0.0.1');
     this.#log = log;
     this.#handle = { compiler: new ProcessHandle(ctx, 'compiler'), server: new ProcessHandle(ctx, 'server') };
@@ -41,7 +41,7 @@ export class CompilerClient {
     const ctrl = new AbortController();
     opts?.signal?.addEventListener('abort', () => ctrl.abort());
     const timeoutId = setTimeout(() => {
-      logTimeout && this.#log('error', `Timeout on request to ${this.#url}${rel}`);
+      logTimeout && this.#log.error(`Timeout on request to ${this.#url}${rel}`);
       ctrl.abort('TIMEOUT');
     }, opts?.timeout ?? 100).unref();
     try {
@@ -71,13 +71,13 @@ export class CompilerClient {
   async stop(): Promise<boolean> {
     const info = await this.info();
     if (!info) {
-      this.#log('debug', 'Stopping server, info not found, manual killing');
+      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));
     }
 
     await this.#fetch('/stop').catch(() => { }); // Trigger
-    this.#log('debug', 'Waiting for compiler to exit');
+    this.#log.debug('Waiting for compiler to exit');
     await this.#handle.compiler.ensureKilled();
     return true;
   }
@@ -92,7 +92,7 @@ export class CompilerClient {
       return;
     }
 
-    this.#log('debug', `Starting watch for events of type "${type}"`);
+    this.#log.debug(`Starting watch for events of type "${type}"`);
 
     let signal = cfg.signal;
 
@@ -132,15 +132,15 @@ export class CompilerClient {
       info = await this.info();
 
       if (ctrl.signal.reason === 'TIMEOUT') {
-        this.#log('debug', 'Failed due to 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
-        this.#log('debug', `Stopping watch for events of type "${type}"`);
+        this.#log.debug(`Stopping watch for events of type "${type}"`);
         return;
       } else {
-        this.#log('debug', `Restarting watch for events of type "${type}"`);
+        this.#log.debug(`Restarting watch for events of type "${type}"`);
       }
     }
   }
@@ -149,11 +149,11 @@ export class CompilerClient {
   async waitForState(states: CompilerStateType[], message?: string, signal?: AbortSignal): Promise<void> {
     const set = new Set(states);
     // Loop until
-    this.#log('debug', `Waiting for states, ${states.join(', ')}`);
+    this.#log.debug(`Waiting for states, ${states.join(', ')}`);
     for await (const _ of this.fetchEvents('state', { signal, until: s => set.has(s.state) })) { }
-    this.#log('debug', `Found state, one of ${states.join(', ')} `);
+    this.#log.debug(`Found state, one of ${states.join(', ')} `);
     if (message) {
-      this.#log('info', message);
+      this.#log.info(message);
     }
   }
 }

package/support/server/process-handle.ts

@@ -3,16 +3,16 @@ import path from 'node:path';
 import timers from 'node:timers/promises';
 
 import type { ManifestContext } from '@travetto/manifest';
-import { CompilerLogger, LogUtil } from '../log';
+import { Log, Logger } from '../log';
 
 export class ProcessHandle {
 
   #file: string;
-  #log: CompilerLogger;
+  #log: Logger;
 
   constructor(ctx: ManifestContext, name: string) {
     this.#file = path.resolve(ctx.workspace.path, ctx.build.toolFolder, `${name}.pid`);
-    this.#log = LogUtil.logger(`process-handle.${name}`);
+    this.#log = Log.scoped(`process-handle.${name}`);
   }
 
   async writePid(pid: number): Promise<void> {
@@ -29,10 +29,10 @@ export class ProcessHandle {
     if (!pid) { return false; }
     try {
       process.kill(pid, 0); // See if process is still running
-      this.#log('debug', 'Is running', pid);
+      this.#log.debug('Is running', pid);
       return true;
     } catch {
-      this.#log('debug', 'Is not running', pid);
+      this.#log.debug('Is not running', pid);
     }
     return false; // Not running
   }
@@ -41,7 +41,7 @@ export class ProcessHandle {
     const pid = await this.getPid();
     if (pid && await this.isRunning()) {
       try {
-        this.#log('debug', 'Killing', pid);
+        this.#log.debug('Killing', pid);
         return process.kill(pid);
       } catch { }
     }
@@ -51,7 +51,7 @@ export class ProcessHandle {
   async ensureKilled(gracePeriod: number = 3000): Promise<boolean> {
     const start = Date.now();
     const pid = await this.getPid();
-    this.#log('debug', 'Ensuring Killed', pid);
+    this.#log.debug('Ensuring Killed', pid);
     while (pid && (Date.now() - start) < gracePeriod) { // Ensure its done
       if (!await this.isRunning()) {
         return true;
@@ -59,10 +59,10 @@ export class ProcessHandle {
       await timers.setTimeout(100);
     }
     try {
-      this.#log('debug', 'Force Killing', pid);
+      this.#log.debug('Force Killing', pid);
       pid && process.kill(pid); // Force kill
     } catch { }
-    this.#log('debug', 'Did Kill', this.#file, !!pid);
+    this.#log.debug('Did Kill', this.#file, !!pid);
     return pid !== undefined;
   }
 }

package/support/server/runner.ts

@@ -6,10 +6,10 @@ import type { ManifestContext, DeltaEvent } from '@travetto/manifest';
 
 import type { CompilerEvent, CompilerMode } from '../types';
 import { AsyncQueue } from '../queue';
-import { LogUtil } from '../log';
+import { Log } from '../log';
 import { CommonUtil } from '../util';
 
-const log = LogUtil.logger('compiler-exec');
+const log = Log.scoped('compiler-exec');
 const isEvent = (msg: unknown): msg is CompilerEvent => !!msg && typeof msg === 'object' && 'type' in msg;
 
 /**
@@ -22,17 +22,17 @@ export class CompilerRunner {
    */
   static async * runProcess(ctx: ManifestContext, changed: DeltaEvent[], mode: CompilerMode, signal: AbortSignal): AsyncIterable<CompilerEvent> {
     if (signal.aborted) {
-      log('debug', 'Skipping, shutting down');
+      log.debug('Skipping, shutting down');
       return;
     }
 
     const watch = mode === 'watch';
     if (!changed.length && !watch) {
       yield { type: 'state', payload: { state: 'compile-end' } };
-      log('debug', 'Skipped');
+      log.debug('Skipped');
       return;
     } else {
-      log('debug', `Started watch=${watch} changed=${changed.slice(0, 10).map(x => `${x.module}/${x.file}`)}`);
+      log.debug(`Started watch=${watch} changed=${changed.slice(0, 10).map(x => `${x.module}/${x.file}`)}`);
     }
 
     const main = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules', '@travetto/compiler/support/entry.compiler.js');
@@ -45,7 +45,7 @@ export class CompilerRunner {
     try {
       await CommonUtil.writeTextFile(deltaFile, changedFiles.join('\n'));
 
-      log('info', 'Launching compiler');
+      log.info('Launching compiler');
       const proc = cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
         env: {
           ...process.env,
@@ -58,7 +58,7 @@ export class CompilerRunner {
         .on('exit', () => queue.close());
 
       const kill = (): unknown => {
-        log('debug', 'Shutting down process');
+        log.debug('Shutting down process');
         return (proc.connected ? proc.send('shutdown', (err) => proc.kill()) : proc.kill());
       };
 
@@ -68,11 +68,11 @@ export class CompilerRunner {
       yield* queue;
 
       if (proc.exitCode !== 0) {
-        log('error', `Terminated during compilation, code=${proc.exitCode}, killed=${proc.killed}`);
+        log.error(`Terminated during compilation, code=${proc.exitCode}, killed=${proc.killed}`);
       }
       process.off('SIGINT', kill);
 
-      log('debug', 'Finished');
+      log.debug('Finished');
     } finally {
       rmSync(deltaFile, { force: true });
     }

package/support/server/server.ts

@@ -6,12 +6,12 @@ import { setMaxListeners } from 'node:events';
 import type { ManifestContext } from '@travetto/manifest';
 
 import type { CompilerMode, CompilerProgressEvent, CompilerEvent, CompilerEventType, CompilerServerInfo } from '../types';
-import { LogUtil } from '../log';
+import { Log } from '../log';
 import { CommonUtil } from '../util';
 import { CompilerClient } from './client';
 import { ProcessHandle } from './process-handle';
 
-const log = LogUtil.logger('compiler-server');
+const log = Log.scoped('server');
 
 /**
  * Compiler Server Class
@@ -30,7 +30,7 @@ export class CompilerServer {
 
   constructor(ctx: ManifestContext, mode: CompilerMode) {
     this.#ctx = ctx;
-    this.#client = new CompilerClient(ctx, LogUtil.logger('client.server'));
+    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') };
 
@@ -70,11 +70,11 @@ export class CompilerServer {
             const info = await this.#client.info();
             resolve((info && info.mode === 'build' && this.mode === 'watch') ? 'retry' : 'running');
           } else {
-            log('warn', 'Failed in running server', err);
+            log.warn('Failed in running server', err);
             reject(err);
           }
         })
-        .on('close', () => log('debug', 'Server close event'));
+        .on('close', () => log.debug('Server close event'));
 
       const url = new URL(this.#url);
       setTimeout(() => this.#server.listen(+url.port, url.hostname), 1); // Run async
@@ -84,7 +84,7 @@ export class CompilerServer {
       if (attempt >= 5) {
         throw new Error('Unable to verify compilation server');
       }
-      log('info', 'Waiting for build to finish, before retrying');
+      log.info('Waiting for build to finish, before retrying');
       // Let the server finish
       await this.#client.waitForState(['close'], 'Server closed', this.signal);
       return this.#tryListen(attempt + 1);
@@ -119,7 +119,7 @@ export class CompilerServer {
   }
 
   async #disconnectActive(): Promise<void> {
-    log('info', 'Server disconnect requested');
+    log.info('Server disconnect requested');
     this.info.iteration = Date.now();
     await new Promise(r => setTimeout(r, 20));
     for (const el of Object.values(this.#listeners)) {
@@ -142,8 +142,6 @@ export class CompilerServer {
 
     const [, action, subAction] = new URL(`${this.#url}${req.url}`).pathname.split('/');
 
-    log('debug', 'Receive request', { action, subAction });
-
     let out: unknown;
     let close = false;
     switch (action) {
@@ -165,7 +163,7 @@ export class CompilerServer {
   async processEvents(src: (signal: AbortSignal) => AsyncIterable<CompilerEvent>): Promise<void> {
     for await (const ev of CommonUtil.restartableEvents(src, this.signal, this.isResetEvent)) {
       if (ev.type === 'progress') {
-        await LogUtil.logProgress?.(ev.payload);
+        await Log.onProgressEvent(ev.payload);
       }
 
       this.#emitEvent(ev);
@@ -176,9 +174,9 @@ export class CompilerServer {
         if (ev.payload.state === 'init' && ev.payload.extra && 'pid' in ev.payload.extra && typeof ev.payload.extra.pid === 'number') {
           this.info.compilerPid = ev.payload.extra.pid;
         }
-        log('info', `State changed: ${this.info.state}`);
+        log.info(`State changed: ${this.info.state}`);
       } else if (ev.type === 'log') {
-        LogUtil.logEvent(ev.payload);
+        log.render(ev.payload);
       }
       if (this.isResetEvent(ev)) {
         await this.#disconnectActive();
@@ -188,19 +186,19 @@ export class CompilerServer {
     // Terminate, after letting all remaining events emit
     await this.close();
 
-    log('debug', 'Finished processing events');
+    log.debug('Finished processing events');
   }
 
   /**
    * Close server
    */
   async close(): Promise<void> {
-    log('info', 'Closing down server');
+    log.info('Closing down server');
 
     // If we are in a place where progress exists
     if (this.info.state === 'compile-start') {
       const cancel: CompilerProgressEvent = { complete: true, idx: 0, total: 0, message: 'Complete', operation: 'compile' };
-      LogUtil.logProgress?.(cancel);
+      await Log.onProgressEvent(cancel);
       this.#emitEvent({ type: 'progress', payload: cancel });
     }
 
@@ -220,7 +218,7 @@ export class CompilerServer {
       await this.#handle.compiler.kill();
     }
 
-    log('info', 'Closed down server');
+    log.info('Closed down server');
   }
 
   /**
@@ -228,7 +226,7 @@ export class CompilerServer {
    */
   async listen(): Promise<CompilerServer | undefined> {
     const running = await this.#tryListen() === 'ok';
-    log('info', running ? 'Starting server' : 'Server already running under a different process', this.#url);
+    log.info(running ? 'Starting server' : 'Server already running under a different process', this.#url);
     return running ? this : undefined;
   }
 }

package/support/setup.ts

@@ -4,7 +4,7 @@ import fs from 'node:fs/promises';
 
 import { type DeltaEvent, type ManifestContext, type Package } from '@travetto/manifest';
 
-import { LogUtil } from './log';
+import { Log } from './log';
 import { CommonUtil } from './util';
 
 type ModFile = { input: string, output: string, stale: boolean };
@@ -128,19 +128,19 @@ export class CompilerSetup {
     const out: string[] = [];
 
     try {
-      await LogUtil.withLogger(scope, async log => {
+      await Log.wrap(scope, async log => {
         if (files.some(f => f.stale)) {
-          log('debug', 'Starting', mod);
+          log.debug('Starting', mod);
           for (const file of files.filter(x => x.stale)) {
             await this.#transpileFile(ctx, file.input, file.output);
           }
           if (changes.length) {
             out.push(...changes.map(x => `${mod}/${x}`));
-            log('debug', `Source changed: ${changes.join(', ')}`, mod);
+            log.debug(`Source changed: ${changes.join(', ')}`, mod);
           }
-          log('debug', 'Completed', mod);
+          log.debug('Completed', mod);
         } else {
-          log('debug', 'Skipped', mod);
+          log.debug('Skipped', mod);
         }
       }, false);
     } catch (err) {
@@ -173,7 +173,7 @@ export class CompilerSetup {
   static async setup(ctx: ManifestContext): Promise<DeltaEvent[]> {
     let changes = 0;
 
-    await LogUtil.withLogger('precompile', async () => {
+    await Log.wrap('precompile', async () => {
       for (const mod of PRECOMPILE_MODS) {
         changes += (await this.#compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
       }
@@ -181,18 +181,18 @@ export class CompilerSetup {
 
     const { ManifestUtil, ManifestDeltaUtil } = await this.#importManifest(ctx);
 
-    const manifest = await LogUtil.withLogger('manifest', () =>
+    const manifest = await Log.wrap('manifest', () =>
       ManifestUtil.buildManifest(ManifestUtil.getWorkspaceContext(ctx)));
 
-    await LogUtil.withLogger('transformers', async () => {
+    await Log.wrap('transformers', async () => {
       for (const mod of Object.values(manifest.modules).filter(m => m.files.$transformer?.length)) {
         changes += (await this.#compileIfStale(ctx, 'transformers', mod.name, ['package.json', ...mod.files.$transformer!.map(x => x[0])])).length;
       }
     });
 
-    const delta = await LogUtil.withLogger('delta', async log => {
+    const delta = await Log.wrap('delta', async log => {
       if (changes) {
-        log('debug', 'Skipping, everything changed');
+        log.debug('Skipping, everything changed');
         return [{ type: 'changed', file: '*', module: ctx.workspace.name, sourceFile: '' } as const];
       } else {
         return ManifestDeltaUtil.produceDelta(manifest);
@@ -200,16 +200,16 @@ export class CompilerSetup {
     });
 
     if (changes) {
-      await LogUtil.withLogger('reset', async log => {
+      await Log.wrap('reset', async log => {
         await fs.rm(path.resolve(ctx.workspace.path, ctx.build.outputFolder), { recursive: true, force: true });
-        log('info', 'Clearing output due to compiler changes');
+        log.info('Clearing output due to compiler changes');
       }, false);
     }
 
     // Write manifest
-    await LogUtil.withLogger('manifest', async log => {
+    await Log.wrap('manifest', async log => {
       await ManifestUtil.writeManifest(manifest);
-      log('debug', `Wrote manifest ${ctx.workspace.name}`);
+      log.debug(`Wrote manifest ${ctx.workspace.name}`);
 
       // Update all manifests when in mono repo
       if (delta.length && ctx.workspace.mono) {
@@ -221,8 +221,8 @@ export class CompilerSetup {
           await ManifestUtil.writeManifest(modManifest);
           names.push(mod.name);
         }
-        log('debug', `Changes triggered ${delta.slice(0, 10).map(x => `${x.type}:${x.module}:${x.file}`)}`);
-        log('debug', `Rewrote monorepo manifests [changes=${delta.length}] ${names.slice(0, 10).join(', ')}`);
+        log.debug(`Changes triggered ${delta.slice(0, 10).map(x => `${x.type}:${x.module}:${x.file}`)}`);
+        log.debug(`Rewrote monorepo manifests [changes=${delta.length}] ${names.slice(0, 10).join(', ')}`);
       }
     });
 

package/support/types.ts

@@ -3,7 +3,7 @@ export type CompilerMode = 'build' | 'watch';
 export type CompilerStateType = 'startup' | 'init' | 'compile-start' | 'compile-end' | 'watch-start' | 'watch-end' | 'reset' | 'close';
 export type CompilerChangeEvent = { file: string, action: 'create' | 'update' | 'delete', output: string, module: string, time: number };
 export type CompilerLogLevel = 'info' | 'debug' | 'warn' | 'error';
-export type CompilerLogEvent = { level: CompilerLogLevel, message: string, time: number, args?: unknown[], scope?: string };
+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> };
 

package/support/util.ts

@@ -4,7 +4,7 @@ import { setMaxListeners } from 'node:events';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import { LogUtil } from './log';
+import { Log } from './log';
 
 const OPT_CACHE: Record<string, import('typescript').CompilerOptions> = {};
 
@@ -58,7 +58,7 @@ export class CommonUtil {
    * Restartable Event Stream
    */
   static async * restartableEvents<T>(src: (signal: AbortSignal) => AsyncIterable<T>, parent: AbortSignal, shouldRestart: (item: T) => boolean): AsyncIterable<T> {
-    const log = LogUtil.logger('event-stream');
+    const log = Log.scoped('event-stream');
     outer: while (!parent.aborted) {
       const controller = new AbortController();
       setMaxListeners(1000, controller.signal);
@@ -68,20 +68,20 @@ export class CommonUtil {
 
       const comp = src(controller.signal);
 
-      log('debug', 'Started event stream');
+      log.debug('Started event stream');
 
       // Wait for all events, close at the end
       for await (const ev of comp) {
         yield ev;
         if (shouldRestart(ev)) {
-          log('debug', 'Restarting stream');
+          log.debug('Restarting stream');
           controller.abort(); // Ensure terminated of process
           parent.removeEventListener('abort', kill);
           continue outer;
         }
       }
 
-      log('debug', 'Finished event stream');
+      log.debug('Finished event stream');
 
       // Natural exit, we done
       if (!controller.signal.aborted) { // Shutdown source if still running

package/src/log.ts

@@ -1,17 +0,0 @@
-import type { CompilerLogLevel } from '../support/types';
-import { EventUtil } from './event';
-
-function log(level: CompilerLogLevel, message: string, ...args: unknown[]): void {
-  EventUtil.sendEvent('log', { level, message, args, time: Date.now(), scope: 'compiler-exec' });
-  if (!process.connected) {
-    // eslint-disable-next-line no-console
-    console[level](message, ...args);
-  }
-}
-
-export const Log = {
-  warn: log.bind(null, 'warn'),
-  debug: log.bind(null, 'debug'),
-  info: log.bind(null, 'info'),
-  error: log.bind(null, 'error'),
-};