@travetto/compiler 3.3.2 → 3.4.0-rc.1

package/src/watch.ts

@@ -1,19 +1,22 @@
 import { readFileSync } from 'fs';
+import { setMaxListeners } from 'events';
 
 import {
-  ManifestContext, ManifestModuleUtil, ManifestUtil, WatchEvent, ManifestModuleFolderType,
-  ManifestModuleFileType, path, ManifestModule, watchFolders, WatchFolder, RootIndex, WatchStream
+  ManifestContext, ManifestModuleUtil, ManifestUtil, ManifestModuleFolderType, ManifestModuleFileType,
+  path, ManifestModule,
 } from '@travetto/manifest';
 import { getManifestContext } from '@travetto/manifest/bin/context';
 
+import type { CompileStateEntry } from './types';
 import { CompilerState } from './state';
 import { CompilerUtil } from './util';
 
-type CompileWatchEvent = WatchEvent | { action: 'restart', file: string };
-const RESTART_SIGNAL = 'RESTART_SIGNAL';
+import { WatchEvent, fileWatchEvents } from './internal/watch-core';
+
+type DirtyFile = { modFolder: string, mod: string, remove?: boolean, moduleFile: string, folderKey: ManifestModuleFolderType, type: ManifestModuleFileType };
 
 /**
- * Utils for watching
+ * Watch support, based on compiler state and manifest details
  */
 export class CompilerWatcher {
 
@@ -22,13 +25,13 @@ export class CompilerWatcher {
    * @param state
    * @returns
    */
-  static watch(state: CompilerState): AsyncIterable<CompileWatchEvent> {
+  static watch(state: CompilerState): AsyncIterable<WatchEvent<{ entry: CompileStateEntry }>> {
     return new CompilerWatcher(state).watchChanges();
   }
 
   #sourceHashes = new Map<string, number>();
   #manifestContexts = new Map<string, ManifestContext>();
-  #dirtyFiles: { modFolder: string, mod: string, moduleFile?: string, folderKey?: ManifestModuleFolderType, type?: ManifestModuleFileType }[] = [];
+  #dirtyFiles: DirtyFile[] = [];
   #state: CompilerState;
 
   constructor(state: CompilerState) {
@@ -48,15 +51,25 @@ export class CompilerWatcher {
       return this.#manifestContexts.get(folder)!;
     }));
 
-    const files = this.#dirtyFiles;
+    const files = this.#dirtyFiles.slice(0);
     this.#dirtyFiles = [];
 
     for (const ctx of [...contexts, this.#state.manifest]) {
       const newManifest = await ManifestUtil.buildManifest(ctx);
       for (const file of files) {
-        if (file.folderKey && file.moduleFile && file.type && file.mod in newManifest.modules) {
-          newManifest.modules[file.mod].files[file.folderKey] ??= [];
-          newManifest.modules[file.mod].files[file.folderKey]!.push([file.moduleFile, file.type, Date.now()]);
+        if (file.mod in newManifest.modules) {
+          const modFiles = newManifest.modules[file.mod].files[file.folderKey] ??= [];
+          const idx = modFiles.findIndex(x => x[0] === file.moduleFile);
+
+          if (!file.remove && idx < 0) {
+            modFiles.push([file.moduleFile, file.type, Date.now()]);
+          } else if (idx >= 0) {
+            if (file.remove) {
+              modFiles.splice(idx, 1);
+            } else {
+              modFiles[idx] = [file.moduleFile, file.type, Date.now()];
+            }
+          }
         }
       }
       await ManifestUtil.writeManifest(ctx, newManifest);
@@ -71,131 +84,79 @@ export class CompilerWatcher {
     );
   }
 
-  /**
- * Get a watcher for a given compiler state
- * @param state
- * @param handler
- * @returns
- */
-  async * watchChanges(): AsyncIterable<CompileWatchEvent> {
-    const stream = this.#watchFiles();
+  #addDirtyFile(mod: ManifestModule, folder: string, moduleFile: string, remove = false): void {
+    this.#dirtyFiles.push({
+      mod: mod.name, modFolder: folder, remove, moduleFile,
+      folderKey: ManifestModuleUtil.getFolderKey(moduleFile),
+      type: ManifestModuleUtil.getFileType(moduleFile),
+    });
+  }
 
+  /**
+   * Get a watcher for a given compiler state
+   * @param state
+   * @param handler
+   * @returns
+   */
+  async * watchChanges(): AsyncIterable<WatchEvent<{ entry: CompileStateEntry }>> {
     const mods = this.#getModuleMap();
-    for await (const { file: sourceFile, action, folder } of stream) {
+    const ctrl = new AbortController();
+    setMaxListeners(1000, ctrl.signal);
+
+    const modules = [...this.#state.manifestIndex.getModuleList('all')].map(x => this.#state.manifestIndex.getModule(x)!);
+
+    const stream = fileWatchEvents(this.#state.manifest, modules, ctrl.signal);
+    for await (const ev of stream) {
 
-      if (folder === RESTART_SIGNAL) {
-        yield { action: 'restart', file: sourceFile };
+      if (ev.action === 'reset') {
+        yield ev;
+        ctrl.abort();
         return;
       }
 
+      const { action, file: sourceFile, folder } = ev;
       const mod = mods[folder];
       const moduleFile = mod.sourceFolder ?
         (sourceFile.includes(mod.sourceFolder) ? sourceFile.split(`${mod.sourceFolder}/`)[1] : sourceFile) :
         sourceFile.replace(`${this.#state.manifest.workspacePath}/`, '');
+
+      let entry = this.#state.getBySource(sourceFile);
+
       switch (action) {
         case 'create': {
           const fileType = ManifestModuleUtil.getFileType(moduleFile);
-          this.#dirtyFiles.push({
-            mod: mod.name,
-            modFolder: folder,
-            moduleFile,
-            folderKey: ManifestModuleUtil.getFolderKey(moduleFile),
-            type: ManifestModuleUtil.getFileType(moduleFile)
-          });
+          this.#addDirtyFile(mod, folder, moduleFile);
           if (CompilerUtil.validFile(fileType)) {
-            await this.#rebuildManifestsIfNeeded();
-
             const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
-            const input = this.#state.registerInput(mod, moduleFile);
+            entry = this.#state.registerInput(mod, moduleFile);
             this.#sourceHashes.set(sourceFile, hash);
-            yield { action, file: input, folder };
           }
           break;
         }
         case 'update': {
-          await this.#rebuildManifestsIfNeeded();
-          const entry = this.#state.getBySource(sourceFile);
           if (entry) {
             const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
             if (this.#sourceHashes.get(sourceFile) !== hash) {
               this.#state.resetInputSource(entry.input);
               this.#sourceHashes.set(sourceFile, hash);
-              yield { action, file: entry.input, folder };
             }
           }
           break;
         }
         case 'delete': {
-          const entry = this.#state.getBySource(sourceFile);
           if (entry) {
             this.#state.removeInput(entry.input);
             if (entry.output) {
-              this.#dirtyFiles.push({ mod: mod.name, modFolder: folder });
-              yield { action, file: entry.output, folder };
+              this.#addDirtyFile(mod, folder, moduleFile, true);
             }
           }
         }
       }
-    }
-  }
 
-  /**
-   * Watch files based on root index
-   */
-  #watchFiles(): WatchStream {
-    const idx = this.#state.manifestIndex;
-    const modules = [...idx.getModuleList('all')].map(x => idx.getModule(x)!);
-    const options: Partial<WatchFolder> = {
-      filter: (ev: WatchEvent): boolean => {
-        const type = ManifestModuleUtil.getFileType(ev.file);
-        return type === 'ts' || type === 'typings' || type === 'js' || type === 'package-json';
-      },
-      ignore: ['node_modules', '**/.trv_*'],
-    };
-
-    const moduleFolders: WatchFolder[] = modules
-      .filter(x => !idx.manifest.monoRepo || x.sourcePath !== idx.manifest.workspacePath)
-      .map(x => ({ src: x.sourcePath, target: x.sourcePath }));
-
-    // Add monorepo folders
-    if (idx.manifest.monoRepo) {
-      const mono = modules.find(x => x.sourcePath === idx.manifest.workspacePath)!;
-      for (const folder of Object.keys(mono.files)) {
-        if (!folder.startsWith('$')) {
-          moduleFolders.push({ src: path.resolve(mono.sourcePath, folder), target: mono.sourcePath });
-        }
+      if (entry) {
+        await this.#rebuildManifestsIfNeeded();
+        yield { action, file: entry.source, folder, entry };
       }
-      moduleFolders.push({ src: mono.sourcePath, target: mono.sourcePath, immediate: true });
     }
-
-    // Watch output folders
-    const outputWatch = (root: string, sources: string[]): WatchFolder => {
-      const valid = new Set(sources.map(src => path.resolve(root, src)));
-      return {
-        src: root, target: RESTART_SIGNAL, immediate: true, includeHidden: true,
-        filter: ev => ev.action === 'delete' && valid.has(path.resolve(root, ev.file))
-      };
-    };
-
-    const topLevelFiles = (root: string, files: string[]): WatchFolder => {
-      const valid = new Set(files.map(src => path.resolve(root, src)));
-      return {
-        src: root, target: RESTART_SIGNAL, immediate: true,
-        filter: ev => valid.has(path.resolve(root, ev.file))
-      };
-    };
-
-    moduleFolders.push(
-      outputWatch(RootIndex.manifest.workspacePath, [
-        RootIndex.manifest.outputFolder,
-        RootIndex.manifest.compilerFolder
-      ]),
-      topLevelFiles(RootIndex.manifest.workspacePath, [
-        'package.json',
-        'package-lock.json'
-      ])
-    );
-
-    return watchFolders(moduleFolders, options);
   }
 }

package/support/entry.trvc.ts

@@ -0,0 +1,73 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+import type { ManifestContext } from '@travetto/manifest';
+
+import { LogUtil } from './log';
+import { CompilerSetup } from './setup';
+import { CompilerServer } from './server/server';
+import { CompilerRunner } from './server/runner';
+import type { CompilerOp, CompilerServerInfo } from './types';
+import { CompilerClientUtil } from './server/client';
+import { CommonUtil } from './util';
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const main = (root: ManifestContext, ctx: ManifestContext) => {
+  const ops = {
+    /** Stop the server */
+    async stop(): Promise<void> {
+      if (await fetch(`${ctx.compilerUrl}/stop`).then(v => v.ok, () => false)) {
+        console.log(`Stopped server ${ctx.workspacePath}: [${ctx.compilerUrl}]`);
+      } else {
+        console.log(`Server not running ${ctx.workspacePath}: [${ctx.compilerUrl}]`);
+      }
+    },
+
+    /** Get server info */
+    info(): Promise<CompilerServerInfo> {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return fetch(ctx.compilerUrl).then(v => v.json(), () => ({ state: 'Server not running' })) as Promise<CompilerServerInfo>;
+    },
+
+    /** Clean the server */
+    async clean(): Promise<void> {
+      const folders = [ctx.outputFolder, ctx.compilerFolder];
+      if (await fetch(`${ctx.compilerUrl}/clean`).then(v => v.ok, () => false)) {
+        return console.log(`Clean triggered ${ctx.workspacePath}:`, folders);
+      } else {
+        await Promise.all(folders.map(f => fs.rm(path.resolve(ctx.workspacePath, f), { force: true, recursive: true })));
+        return console.log(`Cleaned ${ctx.workspacePath}:`, folders);
+      }
+    },
+
+    /** Main entry point for compilation */
+    async compile(op: CompilerOp, setupOnly = false): Promise<(mod: string) => Promise<unknown>> {
+      LogUtil.initLogs(ctx, op === 'run' ? 'error' : 'info');
+
+      const server = await new CompilerServer(root, op).listen();
+
+      // Wait for build to be ready
+      if (server) {
+        await server.processEvents(async function* (signal) {
+          const { changed, manifest } = await CompilerSetup.setup(root);
+          if (!setupOnly) {
+            yield* CompilerRunner.runProcess(root, manifest, changed, op, signal);
+          } else {
+            yield* [];
+          }
+        });
+      } else {
+        await CompilerClientUtil.waitForBuild(root);
+      }
+      return CommonUtil.moduleLoader(ctx);
+    },
+
+    /** Manifest entry point */
+    async manifest(args: (string | undefined)[] = []): Promise<void> {
+      await ops.compile('run', true);
+      await CompilerSetup.exportManifest(ctx, ...args.filter(x => !x?.startsWith('-'))); return;
+    }
+  };
+  return ops;
+};
+

package/support/log.ts

@@ -1,51 +1,69 @@
-export type CompilerLogEvent = [level: 'info' | 'debug' | 'warn', message: string];
-export type CompilerLogger = (...args: CompilerLogEvent) => void;
+import type { ManifestContext } from '@travetto/manifest';
+import type { CompilerLogEvent, CompilerLogLevel } from './types';
+
+export type CompilerLogger = (level: CompilerLogLevel, message: string, ...args: unknown[]) => void;
 export type WithLogger<T> = (log: CompilerLogger) => Promise<T>;
 
+const LEVEL_TO_PRI: Record<CompilerLogLevel, number> = { debug: 1, info: 2, warn: 3, error: 4 };
+
 const SCOPE_MAX = 15;
 
 export class LogUtil {
 
-  static levels: {
-    debug: boolean;
-    info: boolean;
-    warn: boolean;
-  };
-
-  static set level(value: string) {
-    this.levels = {
-      warn: /^(debug|info|warn)$/.test(value),
-      info: /^(debug|info)$/.test(value),
-      debug: /^debug$/.test(value),
-    };
+  static root = process.cwd();
+
+  static logLevel: CompilerLogLevel = 'error';
+
+  /**
+   * Set level for operation
+   */
+  static initLogs(ctx: ManifestContext, defaultLevel: CompilerLogLevel): void {
+    // Listen only if we aren't in quiet
+    if ((process.env.TRV_BUILD || !process.env.TRV_QUIET)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      this.logLevel = (process.env.TRV_BUILD as 'debug') || defaultLevel;
+    }
+    this.root = ctx.workspacePath;
   }
 
   /**
-   * Is object a log event
+   * Is the log level active?
    */
-  static isLogEvent = (o: unknown): o is CompilerLogEvent => o !== null && o !== undefined && Array.isArray(o);
+  static isLevelActive(lvl: CompilerLogLevel): boolean {
+    return LEVEL_TO_PRI[this.logLevel] <= LEVEL_TO_PRI[lvl];
+  }
 
   /**
    * Log message with filtering by level
    */
-  static log(scope: string, args: string[], ...[level, msg]: CompilerLogEvent): void {
-    const message = msg.replaceAll(process.cwd(), '.');
-    if (LogUtil.levels[level]) {
-      const params = [`[${scope.padEnd(SCOPE_MAX, ' ')}]`, ...args, message];
-      if (!/(0|false|off|no)$/i.test(process.env.TRV_LOG_TIME ?? '')) {
-        params.unshift(new Date().toISOString());
-      }
-      // eslint-disable-next-line no-console
-      console[level]!(...params);
-    }
+  static log(scope: string, level: CompilerLogLevel, message: string, ...args: unknown[]): void {
+    LogUtil.sendLogEventToConsole({ level, scope, message, args, time: Date.now() });
   }
 
   /**
    * With logger
    */
-  static withLogger<T>(scope: string, op: WithLogger<T>, basic = true, args: string[] = []): Promise<T> {
-    const log = this.log.bind(null, scope, args);
+  static withLogger<T>(scope: string, op: WithLogger<T>, basic = true): Promise<T> {
+    const log = this.log.bind(null, scope);
     basic && log('debug', 'Started');
     return op(log).finally(() => basic && log('debug', 'Completed'));
   }
+
+  /**
+   * Compiler log event to console
+   */
+  static sendLogEventToConsole(ev: CompilerLogEvent): void {
+    if (this.isLevelActive(ev.level)) {
+      const params = [ev.message, ...ev.args ?? []].map(x => typeof x === 'string' ? x.replaceAll(LogUtil.root, '.') : x);
+      if (ev.scope) {
+        params.unshift(`[${ev.scope.padEnd(SCOPE_MAX, ' ')}]`);
+      }
+      params.unshift(`${ev.level.padEnd(5)}`);
+      if (!/(0|false|off|no)$/i.test(process.env.TRV_LOG_TIME ?? '')) {
+        params.unshift(new Date().toISOString());
+      }
+      // eslint-disable-next-line no-console
+      console[ev.level]!(...params);
+    }
+  }
 }

package/support/queue.ts

@@ -0,0 +1,41 @@
+type PromiseResolver<T> = { resolve: (v: T) => void, reject: (err?: unknown) => void };
+
+function resolvablePromise<T = void>(): Promise<T> & PromiseResolver<T> {
+  let ops: PromiseResolver<T>;
+  const prom = new Promise<T>((resolve, reject) => ops = { resolve, reject });
+  return Object.assign(prom, ops!);
+}
+
+export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
+  #queue: X[] = [];
+  #done = false;
+  #ready = resolvablePromise();
+
+  constructor(signal?: AbortSignal) {
+    signal?.addEventListener('abort', () => this.close());
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<X> { return this; }
+
+  async next(): Promise<IteratorResult<X>> {
+    while (!this.#done && !this.#queue.length) {
+      await this.#ready;
+      this.#ready = resolvablePromise();
+    }
+    return { value: (this.#queue.length ? this.#queue.shift() : undefined)!, done: this.#done };
+  }
+
+  add(item: X, immediate = false): void {
+    if (!immediate) {
+      this.#queue.push(item);
+    } else {
+      this.#queue.unshift(item);
+    }
+    this.#ready.resolve();
+  }
+
+  close(): void {
+    this.#done = true;
+    this.#ready.resolve();
+  }
+}

package/support/server/client.ts

@@ -0,0 +1,118 @@
+import rl from 'readline/promises';
+import { Readable } from 'stream';
+
+import type { ManifestContext } from '@travetto/manifest';
+import type { CompilerServerEvent, CompilerServerEventType, CompilerServerInfo, CompilerStateType } from '../types';
+
+import { LogUtil } from '../log';
+
+declare global {
+  interface RequestInit { timeout?: number }
+}
+
+const log = LogUtil.log.bind(LogUtil, 'compiler-client');
+
+function getSignal(input?: AbortSignal): AbortSignal {
+  // Ensure we capture end of process at least
+  if (!input) {
+    const ctrl = new AbortController();
+    process.on('SIGINT', () => ctrl.abort());
+    input = ctrl.signal;
+  }
+  return input;
+}
+
+/**
+ * Compiler Client Operations
+ */
+export class CompilerClientUtil {
+
+  /**
+   * Get server information, if server is running
+   */
+  static async getServerInfo(ctx: ManifestContext): Promise<CompilerServerInfo | undefined> {
+    try {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const res = (await fetch(`${ctx.compilerUrl}/info`).then(v => v.json())) as CompilerServerInfo;
+      return res;
+    } catch (err) {
+      return undefined;
+    }
+  }
+
+  /**
+   * Fetch compiler events
+   */
+  static async * fetchEvents<
+    V extends CompilerServerEventType,
+    T extends (CompilerServerEvent & { type: V })['payload']
+  >(ctx: ManifestContext, type: V, signal?: AbortSignal, until?: (ev: T) => boolean): AsyncIterable<T> {
+    log('debug', `Starting watch for events of type "${type}"`);
+
+    signal = getSignal(signal);
+
+    for (; ;) {
+      const ctrl = new AbortController();
+      try {
+        signal.addEventListener('abort', () => ctrl.abort());
+        const stream = await fetch(`${ctx.compilerUrl}/event/${type}`, {
+          signal: ctrl.signal,
+          timeout: 1000 * 60 * 60
+        });
+        for await (const line of rl.createInterface(Readable.fromWeb(stream.body!))) {
+          if (line.trim().charAt(0) === '{') {
+            const val = JSON.parse(line);
+            if (until?.(val)) {
+              setTimeout(() => ctrl.abort(), 1);
+            }
+            yield val;
+          }
+        }
+      } catch (err) { }
+
+      if (ctrl.signal.aborted || !(await this.getServerInfo(ctx))) { // If health check fails, or aborted
+        log('debug', `Stopping watch for events of type "${type}"`);
+        return;
+      } else {
+        log('debug', `Restarting watch for events of type "${type}"`);
+      }
+    }
+  }
+
+  /**
+   * Wait for one of N states to be achieved
+   */
+  static async waitForState(ctx: ManifestContext, states: CompilerStateType[], signal?: AbortSignal): Promise<void> {
+    const set = new Set(states);
+    const existing = await this.getServerInfo(ctx);
+    log('debug', `Existing: ${JSON.stringify(existing)}`);
+    if (existing && set.has(existing.state)) {
+      log('debug', `Waited for state, ${existing.state} in server info`);
+      return;
+    }
+    // Loop until
+    log('debug', `Waiting for states, ${states.join(', ')}`);
+    for await (const _ of this.fetchEvents(ctx, 'state', signal, s => set.has(s.state))) { }
+    log('debug', `Found state, one of ${states.join(', ')}`);
+  }
+
+  /**
+   * Stream logs
+   */
+  static async streamLogs(ctx: ManifestContext, signal?: AbortSignal): Promise<void> {
+    if (!LogUtil.logLevel) {
+      return;
+    }
+    for await (const ev of this.fetchEvents(ctx, 'log', signal!)) {
+      LogUtil.sendLogEventToConsole(ev);
+    }
+  }
+
+  /**
+   * Wait for build
+   */
+  static async waitForBuild(ctx: ManifestContext, signal?: AbortSignal): Promise<void> {
+    await this.waitForState(ctx, ['compile-end', 'watch-start'], signal);
+    log('info', 'Successfully built');
+  }
+}

package/support/server/runner.ts

@@ -0,0 +1,107 @@
+import cp from 'child_process';
+import path from 'path';
+
+import type { ManifestContext, ManifestRoot, DeltaEvent } from '@travetto/manifest';
+
+import type { CompilerOp, CompilerProgressEvent, CompilerServerEvent } from '../types';
+import { AsyncQueue } from '../queue';
+import { LogUtil } from '../log';
+import { CommonUtil } from '../util';
+import { CompilerClientUtil } from './client';
+
+const log = LogUtil.log.bind(null, 'compiler-exec');
+
+/**
+ * Running the compiler
+ */
+export class CompilerRunner {
+
+  /**
+   * Track compiler progress
+   */
+  static async trackProgress(ctx: ManifestContext, src: AsyncIterable<CompilerProgressEvent>): Promise<void> {
+    const compiler = path.resolve(ctx.workspacePath, ctx.compilerFolder);
+    const main = path.resolve(compiler, 'node_modules', '@travetto/terminal/__index__.js');
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const { GlobalTerminal } = await import(main) as typeof import('@travetto/terminal');
+
+    await GlobalTerminal.init();
+    await GlobalTerminal.trackProgress(src,
+      x => ({ ...x, text: `Compiling [%idx/%total] -- ${x.message}` }),
+      { position: 'bottom', minDelay: 50, staticMessage: 'Compiling' }
+    );
+  }
+
+  /**
+   * Run compile process
+   */
+  static async* runProcess(ctx: ManifestContext, manifest: ManifestRoot, changed: DeltaEvent[], op: CompilerOp, signal: AbortSignal): AsyncIterable<CompilerServerEvent> {
+    const watch = op === 'watch';
+    if (!changed.length && !watch) {
+      yield { type: 'state', payload: { state: 'compile-end' } };
+      log('debug', 'Skipped');
+      return;
+    } else {
+      log('debug', `Started watch=${watch} changed=${changed.slice(0, 10).map(x => `${x.module}/${x.file}`)}`);
+    }
+
+    // Track progress if not in run mode
+    if (op !== 'run') {
+      this.trackProgress(ctx, CompilerClientUtil.fetchEvents(ctx, 'progress', signal, ev => !!ev.complete));
+    }
+
+    const compiler = path.resolve(ctx.workspacePath, ctx.compilerFolder);
+    const main = path.resolve(compiler, 'node_modules', '@travetto/compiler/support/entry.compiler.js');
+    const deltaFile = path.resolve(ctx.workspacePath, ctx.toolFolder, 'manifest-delta.json');
+
+    const changedFiles = changed[0]?.file === '*' ? ['*'] : changed.map(ev =>
+      path.resolve(manifest.workspacePath, manifest.modules[ev.module].sourceFolder, ev.file)
+    );
+
+    let proc: cp.ChildProcess | undefined;
+    let kill: (() => void) | undefined;
+
+    const queue = new AsyncQueue<CompilerServerEvent>(signal);
+
+    try {
+      await CommonUtil.writeTextFile(deltaFile, changedFiles.join('\n'));
+
+      log('info', 'Launching compiler');
+      proc = cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
+        env: {
+          ...process.env,
+          TRV_MANIFEST: path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule),
+        },
+        stdio: ['pipe', 'pipe', 2, 'ipc'],
+      })
+        .on('message', msg => {
+          if (msg && typeof msg === 'object' && 'type' in msg) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            queue.add(msg as CompilerServerEvent);
+          }
+        })
+        .on('exit', code => {
+          if (code !== null && code > 0) {
+            log('error', 'Failed during compilation');
+          }
+          queue.close();
+        });
+
+      kill = (): void => { proc?.kill('SIGKILL'); };
+      signal.addEventListener('abort', kill);
+      process.on('exit', kill);
+
+      yield* queue;
+
+      log('debug', `exit code: ${proc?.exitCode}`);
+      log('debug', 'Finished');
+    } finally {
+      if (proc?.killed === false) {
+        proc.kill('SIGKILL');
+      }
+      if (kill) {
+        process.off('exit', kill);
+      }
+    }
+  }
+}