@travetto/compiler 4.0.0-rc.4 → 4.0.0-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "4.0.0-rc.4",
+  "version": "4.0.0-rc.6",
   "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.4",
-    "@travetto/transformer": "^4.0.0-rc.4",
+    "@travetto/manifest": "^4.0.0-rc.6",
+    "@travetto/transformer": "^4.0.0-rc.6",
     "@types/node": "^20.11.16"
   },
   "peerDependencies": {
-    "@travetto/cli": "^4.0.0-rc.5"
+    "@travetto/cli": "^4.0.0-rc.7"
   },
   "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';
@@ -9,7 +8,7 @@ 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';
 
 /**
@@ -70,7 +69,7 @@ export class Compiler {
         break;
       }
       case 'reset': {
-        Log.info('Triggering reset due to change in core files');
+        Log.info('Triggering reset due to change in core files', err?.cause);
         EventUtil.sendEvent('state', { state: 'reset' });
         process.exitCode = 0;
         break;
@@ -86,29 +85,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);
   }
 
   /**

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/src/watch.ts

@@ -128,7 +128,7 @@ export class CompilerWatcher {
         sourceFile === ROOT_PKG ||
         (action === 'delete' && (sourceFile === OUTPUT_PATH || sourceFile === COMPILER_PATH))
       ) {
-        throw new Error('RESET');
+        throw new Error('RESET', { cause: `${action}:${sourceFile}` });
       }
 
       const fileType = ManifestModuleUtil.getFileType(sourceFile);

package/support/entry.trvc.ts

@@ -5,7 +5,7 @@ import path from 'node:path';
 import type { ManifestContext } from '@travetto/manifest';
 
 import type { CompilerLogLevel, CompilerMode, CompilerServerInfo } from './types';
-import { LogUtil } from './log';
+import { CompilerLogger } from './log';
 import { CommonUtil } from './util';
 import { CompilerSetup } from './setup';
 import { CompilerServer } from './server/server';
@@ -14,39 +14,39 @@ 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, new CompilerLogger('client'));
   const buildFolders = [ctx.build.outputFolder, ctx.build.compilerFolder];
 
   /** Main entry point for compilation */
   const compile = async (op: CompilerMode, logLevel: CompilerLogLevel, setupOnly = false): Promise<void> => {
-    LogUtil.initLogs(ctx, logLevel ?? 'info');
+    CompilerLogger.init(ctx, logLevel ?? 'info');
 
     const server = await new CompilerServer(ctx, op).listen();
+    const log = new CompilerLogger('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> {
+      CompilerLogger.init(ctx);
       if (await client.stop()) {
         console.log(`Stopped server ${ctx.workspace.path}: ${client}`);
       } else {
@@ -62,6 +62,7 @@ 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 {
@@ -72,7 +73,7 @@ export const main = (ctx: ManifestContext) => {
 
     /** Stream events */
     events: async (type: string, handler: (ev: unknown) => unknown): Promise<void> => {
-      LogUtil.initLogs(ctx, 'error');
+      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 {

package/support/log.ts

@@ -1,112 +1,107 @@
 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 };
-
 const SCOPE_MAX = 15;
-
 const ESC = '\x1b[';
 
-export class LogUtil {
+export class CompilerLogger {
 
-  static root = process.cwd();
+  static #root = process.cwd();
+  static #logLevel: CompilerLogLevel = 'error';
+  static #linePartial: boolean | undefined;
 
-  static logLevel: CompilerLogLevel = 'error';
+  static logProgress = false;
 
-  static logProgress?: ProgressWriter;
-
-  static linePartial = false;
-
-  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;
+  }
+
   /**
    * Set level for operation
    */
-  static initLogs(ctx: ManifestContext, defaultLevel: CompilerLogLevel): void {
+  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.#logLevel = build || defaultLevel;
+      this.logProgress = this.isInteractiveShell;
     }
-    this.root = ctx.workspace.path;
-    // If we are in info or a terminal and also in a tty
-    this.logProgress = ((this.isLevelActive('info') || process.env.PS1) && process.stdout.isTTY) ? this.#logProgressEvent : undefined;
-    if (this.logProgress) {
-      process.stdout.write(`${ESC}?25l`); // Hide cursor
-    }
-    process.on('exit', () => this.cleanup());
+    this.#root = ctx.workspace.path;
   }
 
-  static cleanup(): void {
-    if (this.logProgress) {
-      process.stdout.write(`${ESC}!p`); // Reset
+  /** Cleanup to restore behavior */
+  static reset(): void {
+    if (process.stdout.isTTY) {
+      process.stdout.write(`${ESC}!p${ESC}?25h`);
     }
   }
 
-  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);
-  }
+  constructor(
+    private scope: string,
+    private level?: CompilerLogLevel,
+    private logProgress?: boolean,
+    private root = CompilerLogger.#root,
+  ) { }
 
-  /**
-   * Is the log level active?
-   */
-  static isLevelActive(lvl: CompilerLogLevel): boolean {
-    return LEVEL_TO_PRI[this.logLevel] <= LEVEL_TO_PRI[lvl];
+  isActive(level: CompilerLogLevel): boolean {
+    return LEVEL_TO_PRI[this.level ?? CompilerLogger.#logLevel] <= LEVEL_TO_PRI[level];
   }
 
-  /**
-   * 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);
+  /** 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, ' ')}]`);
     }
+    params.unshift(new Date().toISOString(), `${ev.level.padEnd(5)}`);
+    CompilerLogger.rewriteLine(''); // Clear out progress line, if active
+    // eslint-disable-next-line no-console
+    console[ev.level]!(...params);
   }
 
-  /**
-   * 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 ?? CompilerLogger.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);
   }
 
-  /**
-   * 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 ?? CompilerLogger.logProgress)) { return; }
+    for await (const ev of src()) { this.onProgressEvent(ev); }
+    await CompilerLogger.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); }
+  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);
   }
 }

package/support/server/client.ts

@@ -14,16 +14,18 @@ type FetchEventsConfig<T> = {
   enforceIteration?: boolean;
 };
 
+type SimpleLogger = Pick<CompilerLogger, 'error' | 'info' | 'debug'>;
+
 /**
  * Compiler Client Operations
  */
 export class CompilerClient {
 
   #url: string;
-  #log: CompilerLogger;
+  #log: SimpleLogger;
   #handle: Record<'compiler' | 'server', ProcessHandle>;
 
-  constructor(ctx: ManifestContext, log: CompilerLogger) {
+  constructor(ctx: ManifestContext, log: SimpleLogger) {
     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,9 +43,9 @@ 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');
-    }, 100).unref();
+    }, opts?.timeout ?? 100).unref();
     try {
       return await fetch(`${this.#url}${rel}`, { ...opts, signal: ctrl.signal });
     } finally {
@@ -53,7 +55,7 @@ export class CompilerClient {
 
   /** Get server information, if server is running */
   info(): Promise<CompilerServerInfo | undefined> {
-    return this.#fetch('/info', {}, false).then(v => v.json(), () => undefined)
+    return this.#fetch('/info', { timeout: 200 }, false).then(v => v.json(), () => undefined)
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       .then(v => v as CompilerServerInfo);
   }
@@ -71,13 +73,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 +94,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 +134,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 +151,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,13 +3,16 @@ import path from 'node:path';
 import timers from 'node:timers/promises';
 
 import type { ManifestContext } from '@travetto/manifest';
+import { CompilerLogger } from '../log';
 
 export class ProcessHandle {
 
   #file: string;
+  #log: CompilerLogger;
 
   constructor(ctx: ManifestContext, name: string) {
     this.#file = path.resolve(ctx.workspace.path, ctx.build.toolFolder, `${name}.pid`);
+    this.#log = new CompilerLogger(`process-handle.${name}`);
   }
 
   async writePid(pid: number): Promise<void> {
@@ -26,15 +29,19 @@ export class ProcessHandle {
     if (!pid) { return false; }
     try {
       process.kill(pid, 0); // See if process is still running
-      return false;
-    } catch { }
-    return true; // Still running
+      this.#log.debug('Is running', pid);
+      return true;
+    } catch {
+      this.#log.debug('Is not running', pid);
+    }
+    return false; // Not running
   }
 
   async kill(): Promise<boolean> {
     const pid = await this.getPid();
     if (pid && await this.isRunning()) {
       try {
+        this.#log.debug('Killing', pid);
         return process.kill(pid);
       } catch { }
     }
@@ -44,6 +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);
     while (pid && (Date.now() - start) < gracePeriod) { // Ensure its done
       if (!await this.isRunning()) {
         return true;
@@ -51,8 +59,10 @@ export class ProcessHandle {
       await timers.setTimeout(100);
     }
     try {
+      this.#log.debug('Force Killing', pid);
       pid && process.kill(pid); // Force kill
     } catch { }
+    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 { CompilerLogger } from '../log';
 import { CommonUtil } from '../util';
 
-const log = LogUtil.logger('compiler-exec');
+const log = new CompilerLogger('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 { CompilerClient } from './client';
+import { CompilerLogger } from '../log';
 import { CommonUtil } from '../util';
+import { CompilerClient } from './client';
 import { ProcessHandle } from './process-handle';
 
-const log = LogUtil.logger('compiler-server');
+const log = new CompilerLogger('compiler-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, new CompilerLogger('client.server'));
     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,12 +119,13 @@ 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)) {
-      el.res.end();
+      try { el.res.end(); } catch { }
     }
+    this.#listeners = {}; // Ensure its empty
   }
 
   async #clean(): Promise<{ clean: boolean }> {
@@ -141,22 +142,19 @@ 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) {
       case 'event': return await this.#addListener(subAction, res);
       case 'clean': out = await this.#clean(); break;
-      case 'stop': {
-        // Must send immediately
-        res.end(JSON.stringify({ closing: true }));
-        await this.close();
-        break;
-      }
+      case 'stop': out = JSON.stringify({ closing: true }); close = true; break;
       case 'info':
       default: out = this.info ?? {}; break;
     }
     res.end(JSON.stringify(out));
+    if (close) {
+      await this.close();
+    }
   }
 
   /**
@@ -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.onLogEvent(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 });
     }
 
@@ -217,14 +215,10 @@ export class CompilerServer {
     } catch { // Timeout or other error
       // Force shutdown
       this.#server.closeAllConnections();
-      if (this.info.compilerPid) { // Ensure its killed
-        try {
-          process.kill(this.info.compilerPid);
-        } catch { }
-      }
+      await this.#handle.compiler.kill();
     }
 
-    log('info', 'Closed down server');
+    log.info('Closed down server');
   }
 
   /**
@@ -232,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 { CompilerLogger } 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 new CompilerLogger(scope).wrap(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 new CompilerLogger('precompile').wrap(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 new CompilerLogger('manifest').wrap(() =>
       ManifestUtil.buildManifest(ManifestUtil.getWorkspaceContext(ctx)));
 
-    await LogUtil.withLogger('transformers', async () => {
+    await new CompilerLogger('transformers').wrap(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 new CompilerLogger('delta').wrap(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,29 +200,29 @@ export class CompilerSetup {
     });
 
     if (changes) {
-      await LogUtil.withLogger('reset', async log => {
+      await new CompilerLogger('reset').wrap(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 new CompilerLogger('manifest').wrap(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) {
         const names: string[] = [];
         const mods = Object.values(manifest.modules).filter(x => x.workspace && x.name !== ctx.workspace.name);
         for (const mod of mods) {
-          const modCtx = ManifestUtil.getModuleContext(ctx, mod.sourceFolder);
+          const modCtx = ManifestUtil.getModuleContext(ctx, mod.sourceFolder, true);
           const modManifest = await ManifestUtil.buildManifest(modCtx);
           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/util.ts

@@ -4,7 +4,7 @@ import { setMaxListeners } from 'node:events';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import { LogUtil } from './log';
+import { CompilerLogger } from './log';
 
 const OPT_CACHE: Record<string, import('typescript').CompilerOptions> = {};
 
@@ -58,28 +58,30 @@ 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 = new CompilerLogger('event-stream');
     outer: while (!parent.aborted) {
       const controller = new AbortController();
       setMaxListeners(1000, controller.signal);
       // Chain
-      parent.addEventListener('abort', () => controller.abort());
+      const kill = (): void => controller.abort();
+      parent.addEventListener('abort', kill);
 
       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