@travetto/compiler 4.0.0-rc.6 → 4.0.0

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.6",
+  "version": "4.0.0",
   "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.6",
-    "@travetto/transformer": "^4.0.0-rc.6",
+    "@travetto/manifest": "^4.0.0",
+    "@travetto/transformer": "^4.0.0",
     "@types/node": "^20.11.16"
   },
   "peerDependencies": {
-    "@travetto/cli": "^4.0.0-rc.7"
+    "@travetto/cli": "^4.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -7,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 { CompileEmitEvent, CompileEmitter } from './types';
 import { EventUtil } from './event';
 
+import { IpcLogger } from '../support/log';
+
+const log = new IpcLogger({ level: 'debug' });
+
 /**
  * Compilation support
  */
@@ -22,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();
   }
@@ -57,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;
@@ -112,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' });
 
@@ -139,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
@@ -156,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 {
@@ -164,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
             }
           }
@@ -194,7 +197,7 @@ export class Compiler {
       }
     }
 
-    Log.debug('Compiler process shutdown');
+    log.debug('Compiler process shutdown');
 
     this.#shutdown('complete');
   }

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 { CompilerLogger } 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,15 +14,15 @@ import { CompilerClient } from './server/client';
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export const main = (ctx: ManifestContext) => {
-  const client = new CompilerClient(ctx, new CompilerLogger('client'));
+  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> => {
-    CompilerLogger.init(ctx, logLevel ?? 'info');
-
+  const compile = async (op: CompilerMode, setupOnly = false): Promise<void> => {
     const server = await new CompilerServer(ctx, op).listen();
-    const log = new CompilerLogger('main');
+    const log = Log.scoped('main');
 
     // Wait for build to be ready
     if (server) {
@@ -37,7 +37,7 @@ export const main = (ctx: ManifestContext) => {
     } else {
       log.info('Server already running, waiting for initial compile to complete');
       const ctrl = new AbortController();
-      log.consumeProgressEvents(() => client.fetchEvents('progress', { until: ev => !!ev.complete, signal: ctrl.signal }));
+      Log.consumeProgressEvents(() => client.fetchEvents('progress', { until: ev => !!ev.complete, signal: ctrl.signal }));
       await client.waitForState(['compile-end', 'watch-start'], 'Successfully built');
       ctrl.abort();
     }
@@ -46,7 +46,6 @@ export const main = (ctx: ManifestContext) => {
   const ops = {
     /** Stop the server */
     async stop(): Promise<void> {
-      CompilerLogger.init(ctx);
       if (await client.stop()) {
         console.log(`Stopped server ${ctx.workspace.path}: ${client}`);
       } else {
@@ -62,7 +61,6 @@ export const main = (ctx: ManifestContext) => {
 
     /** Clean the server */
     async clean(): Promise<void> {
-      CompilerLogger.init(ctx);
       if (await client.clean()) {
         return console.log(`Clean triggered ${ctx.workspace.path}:`, buildFolders);
       } else {
@@ -73,7 +71,6 @@ export const main = (ctx: ManifestContext) => {
 
     /** Stream events */
     events: async (type: string, handler: (ev: unknown) => unknown): Promise<void> => {
-      CompilerLogger.init(ctx, 'error');
       if (type === 'change' || type === 'log' || type === 'progress' || type === 'state') {
         for await (const ev of client.fetchEvents(type)) { await handler(ev); }
       } else {
@@ -82,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', '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,18 +1,23 @@
-import type { ManifestContext } from '@travetto/manifest';
-import type { CompilerLogEvent, CompilerLogLevel, CompilerProgressEvent } from './types';
+import { CompilerLogEvent, CompilerLogLevel, CompilerProgressEvent } from './types';
 
-const LEVEL_TO_PRI: Record<CompilerLogLevel, number> = { debug: 1, info: 2, warn: 3, error: 4 };
+const LEVEL_TO_PRI: Record<CompilerLogLevel | 'none', number> = { debug: 1, info: 2, warn: 3, error: 4, none: 5 };
 const SCOPE_MAX = 15;
+
+type LogConfig = {
+  level?: CompilerLogLevel | 'none';
+  root?: string;
+  scope?: string;
+  parent?: Logger;
+};
+
+export type LogShape = Record<'info' | 'debug' | 'warn' | 'error', (message: string, ...args: unknown[]) => void>;
+
 const ESC = '\x1b[';
 
-export class CompilerLogger {
+export class Logger implements LogConfig, LogShape {
 
-  static #root = process.cwd();
-  static #logLevel: CompilerLogLevel = 'error';
   static #linePartial: boolean | undefined;
 
-  static logProgress = false;
-
   /** Rewrite text line, tracking cleanup as necessary */
   static rewriteLine(text: string): Promise<void> | void {
     if ((!text && !this.#linePartial) || !process.stdout.isTTY) {
@@ -30,78 +35,96 @@ export class CompilerLogger {
     }
   }
 
-  /** 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`); }
 
-  /**
-   * Set level for operation
-   */
-  static init(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.logProgress = this.isInteractiveShell;
-    }
-    this.#root = ctx.workspace.path;
-  }
+  level?: CompilerLogLevel | 'none';
+  root: string = process.cwd();
+  scope?: string;
+  parent?: Logger;
 
-  /** Cleanup to restore behavior */
-  static reset(): void {
-    if (process.stdout.isTTY) {
-      process.stdout.write(`${ESC}!p${ESC}?25h`);
-    }
+  constructor(cfg: LogConfig = {}) {
+    Object.assign(this, cfg);
   }
 
-  constructor(
-    private scope: string,
-    private level?: CompilerLogLevel,
-    private logProgress?: boolean,
-    private root = CompilerLogger.#root,
-  ) { }
-
-  isActive(level: CompilerLogLevel): boolean {
-    return LEVEL_TO_PRI[this.level ?? CompilerLogger.#logLevel] <= LEVEL_TO_PRI[level];
+  valid(ev: CompilerLogEvent): boolean {
+    return LEVEL_TO_PRI[this.level ?? this.parent?.level!] <= LEVEL_TO_PRI[ev.level];
   }
 
   /** Log event with filtering by level */
-  onLogEvent(ev: CompilerLogEvent): void {
-    if (!this.isActive(ev.level)) { return; }
-    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, ' ')}]`);
+  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, ' ')}]`);
     }
     params.unshift(new Date().toISOString(), `${ev.level.padEnd(5)}`);
-    CompilerLogger.rewriteLine(''); // Clear out progress line, if active
+    Logger.rewriteLine(''); // Clear out progress line, if active
     // eslint-disable-next-line no-console
     console[ev.level]!(...params);
   }
 
+  info(message: string, ...args: unknown[]): void { return this.render({ level: 'info', message, args }); }
+  debug(message: string, ...args: unknown[]): void { return this.render({ level: 'debug', message, args }); }
+  warn(message: string, ...args: unknown[]): void { return this.render({ level: 'warn', message, args }); }
+  error(message: string, ...args: unknown[]): void { return this.render({ level: 'error', message, args }); }
+}
+
+
+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;
+  }
+
+  /** 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';
+  }
+
+  /** Produce a scoped logger */
+  scoped(name: string): Logger {
+    return new Logger({ parent: this, scope: name });
+  }
+
+  /** 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);
+  }
+
   /** Write progress event, if active */
   onProgressEvent(ev: CompilerProgressEvent): void | Promise<void> {
-    if (!(this.logProgress ?? CompilerLogger.logProgress)) { return; }
+    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 CompilerLogger.rewriteLine(text);
+    return Logger.rewriteLine(text);
   }
 
   /** Write all progress events if active */
   async consumeProgressEvents(src: () => AsyncIterable<CompilerProgressEvent>): Promise<void> {
-    if (!(this.logProgress ?? CompilerLogger.logProgress)) { return; }
+    if (!(this.logProgress)) { return; }
     for await (const ev of src()) { this.onProgressEvent(ev); }
-    await CompilerLogger.reset();
+    Logger.reset();
   }
+}
 
-  log(level: CompilerLogLevel, message: string, args: unknown[]): void {
-    this.onLogEvent({ scope: this.scope, message, level, args, time: Date.now() });
-  }
-  info(message: string, ...args: unknown[]): void { return this.log('info', message, args); }
-  debug(message: string, ...args: unknown[]): void { return this.log('debug', message, args); }
-  warn(message: string, ...args: unknown[]): void { return this.log('warn', message, args); }
-  error(message: string, ...args: unknown[]): void { return this.log('error', message, args); }
-  wrap<T = unknown>(op: (log: typeof this) => Promise<T>, basic = false): Promise<T> {
-    return basic ? (this.debug('Started'), op(this).finally(() => this.debug('Completed'))) : op(this);
+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> = {
@@ -14,18 +14,16 @@ type FetchEventsConfig<T> = {
   enforceIteration?: boolean;
 };
 
-type SimpleLogger = Pick<CompilerLogger, 'error' | 'info' | 'debug'>;
-
 /**
  * Compiler Client Operations
  */
 export class CompilerClient {
 
   #url: string;
-  #log: SimpleLogger;
+  #log: LogShape;
   #handle: Record<'compiler' | 'server', ProcessHandle>;
 
-  constructor(ctx: ManifestContext, log: SimpleLogger) {
+  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') };

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 } 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 = new CompilerLogger(`process-handle.${name}`);
+    this.#log = Log.scoped(`process-handle.${name}`);
   }
 
   async writePid(pid: number): Promise<void> {

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 { CompilerLogger } from '../log';
+import { Log } from '../log';
 import { CommonUtil } from '../util';
 
-const log = new CompilerLogger('compiler-exec');
+const log = Log.scoped('compiler-exec');
 const isEvent = (msg: unknown): msg is CompilerEvent => !!msg && typeof msg === 'object' && 'type' in msg;
 
 /**

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 { CompilerLogger } from '../log';
+import { Log } from '../log';
 import { CommonUtil } from '../util';
 import { CompilerClient } from './client';
 import { ProcessHandle } from './process-handle';
 
-const log = new CompilerLogger('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, new CompilerLogger('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') };
 
@@ -163,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 log.onProgressEvent(ev.payload);
+        await Log.onProgressEvent(ev.payload);
       }
 
       this.#emitEvent(ev);
@@ -176,7 +176,7 @@ export class CompilerServer {
         }
         log.info(`State changed: ${this.info.state}`);
       } else if (ev.type === 'log') {
-        log.onLogEvent(ev.payload);
+        log.render(ev.payload);
       }
       if (this.isResetEvent(ev)) {
         await this.#disconnectActive();
@@ -198,7 +198,7 @@ export class CompilerServer {
     // 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' };
-      await log.onProgressEvent(cancel);
+      await Log.onProgressEvent(cancel);
       this.#emitEvent({ type: 'progress', payload: cancel });
     }
 

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 { CompilerLogger } from './log';
+import { Log } from './log';
 import { CommonUtil } from './util';
 
 type ModFile = { input: string, output: string, stale: boolean };
@@ -128,7 +128,7 @@ export class CompilerSetup {
     const out: string[] = [];
 
     try {
-      await new CompilerLogger(scope).wrap(async log => {
+      await Log.wrap(scope, async log => {
         if (files.some(f => f.stale)) {
           log.debug('Starting', mod);
           for (const file of files.filter(x => x.stale)) {
@@ -173,7 +173,7 @@ export class CompilerSetup {
   static async setup(ctx: ManifestContext): Promise<DeltaEvent[]> {
     let changes = 0;
 
-    await new CompilerLogger('precompile').wrap(async () => {
+    await Log.wrap('precompile', async () => {
       for (const mod of PRECOMPILE_MODS) {
         changes += (await this.#compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
       }
@@ -181,16 +181,16 @@ export class CompilerSetup {
 
     const { ManifestUtil, ManifestDeltaUtil } = await this.#importManifest(ctx);
 
-    const manifest = await new CompilerLogger('manifest').wrap(() =>
+    const manifest = await Log.wrap('manifest', () =>
       ManifestUtil.buildManifest(ManifestUtil.getWorkspaceContext(ctx)));
 
-    await new CompilerLogger('transformers').wrap(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 new CompilerLogger('delta').wrap(async log => {
+    const delta = await Log.wrap('delta', async log => {
       if (changes) {
         log.debug('Skipping, everything changed');
         return [{ type: 'changed', file: '*', module: ctx.workspace.name, sourceFile: '' } as const];
@@ -200,14 +200,14 @@ export class CompilerSetup {
     });
 
     if (changes) {
-      await new CompilerLogger('reset').wrap(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');
       }, false);
     }
 
     // Write manifest
-    await new CompilerLogger('manifest').wrap(async log => {
+    await Log.wrap('manifest', async log => {
       await ManifestUtil.writeManifest(manifest);
       log.debug(`Wrote manifest ${ctx.workspace.name}`);
 

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 { CompilerLogger } 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 = new CompilerLogger('event-stream');
+    const log = Log.scoped('event-stream');
     outer: while (!parent.aborted) {
       const controller = new AbortController();
       setMaxListeners(1000, controller.signal);

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'),
-};