@travetto/compiler 3.4.2 → 4.0.0-rc.0

package/support/server/runner.ts

@@ -1,41 +1,26 @@
-import cp from 'child_process';
-import path from 'path';
+import cp from 'node:child_process';
+import path from 'node:path';
+import { rmSync } from 'node:fs';
 
-import type { ManifestContext, ManifestRoot, DeltaEvent } from '@travetto/manifest';
+import type { ManifestContext, DeltaEvent } from '@travetto/manifest';
 
-import type { CompilerOp, CompilerProgressEvent, CompilerServerEvent } from '../types';
+import type { CompilerOp, CompilerEvent } 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');
+const log = LogUtil.scoped('compiler-exec');
+const isEvent = (msg: unknown): msg is CompilerEvent => !!msg && typeof msg === 'object' && 'type' in msg;
 
 /**
  * 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> {
+  static async * runProcess(ctx: ManifestContext, changed: DeltaEvent[], op: CompilerOp, signal: AbortSignal): AsyncIterable<CompilerEvent> {
     const watch = op === 'watch';
     if (!changed.length && !watch) {
       yield { type: 'state', payload: { state: 'compile-end' } };
@@ -45,63 +30,46 @@ export class CompilerRunner {
       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 main = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules', '@travetto/compiler/support/entry.compiler.js');
+    const deltaFile = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, `manifest-delta-${Date.now()}.json`);
 
-    const changedFiles = changed[0]?.file === '*' ? ['*'] : changed.map(ev =>
-      path.resolve(manifest.workspacePath, manifest.modules[ev.module].sourceFolder, ev.file)
-    );
+    const changedFiles = changed[0]?.file === '*' ? ['*'] : changed.map(ev => ev.sourceFile);
 
-    let proc: cp.ChildProcess | undefined;
+    const queue = new AsyncQueue<CompilerEvent>();
     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}`], {
+      const proc = cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
         env: {
           ...process.env,
-          TRV_MANIFEST: path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule),
+          TRV_MANIFEST: path.resolve(ctx.workspace.path, ctx.build.outputFolder, 'node_modules', ctx.workspace.name),
         },
-        stdio: ['pipe', 'pipe', 2, 'ipc'],
+        detached: true,
+        stdio: ['pipe', 1, 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();
-        });
+        .on('message', msg => isEvent(msg) && queue.add(msg))
+        .on('exit', () => queue.close());
+
+      kill = (): unknown => proc.kill('SIGINT');
 
-      kill = (): void => { proc?.kill('SIGKILL'); };
+      process.once('SIGINT', kill);
       signal.addEventListener('abort', kill);
-      process.on('exit', kill);
 
       yield* queue;
 
-      log('debug', `exit code: ${proc?.exitCode}`);
+      if (!proc.killed && proc.exitCode !== 0) {
+        log('error', `Failed during compilation, code=${proc.exitCode}, killed=${proc.killed}`);
+      }
+
       log('debug', 'Finished');
     } finally {
-      if (proc?.killed === false) {
-        proc.kill('SIGKILL');
-      }
       if (kill) {
-        process.off('exit', kill);
+        process.off('SIGINT', kill);
       }
+      rmSync(deltaFile, { force: true });
     }
   }
 }

package/support/server/server.ts

@@ -1,15 +1,15 @@
-import http from 'http';
-import fs from 'fs/promises';
-import path from 'path';
+import http from 'node:http';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerMode, CompilerOp, CompilerServerEvent, CompilerServerEventType, CompilerServerInfo } from '../types';
+import type { CompilerMode, CompilerOp, CompilerProgressEvent, CompilerEvent, CompilerEventType, CompilerServerInfo } from '../types';
 import { LogUtil } from '../log';
-import { CompilerClientUtil } from './client';
+import { CompilerClient } from './client';
 import { CommonUtil } from '../util';
 
-const log = LogUtil.log.bind(LogUtil, 'compiler-server');
+const log = LogUtil.scoped('compiler-server');
 
 /**
  * Compiler Server Class
@@ -33,21 +33,25 @@ export class CompilerServer {
 
   #ctx: ManifestContext;
   #server: http.Server;
-  #listeners: { res: http.ServerResponse, type: CompilerServerEventType }[] = [];
+  #listeners: { res: http.ServerResponse, type: CompilerEventType }[] = [];
   #shutdown = new AbortController();
   signal = this.#shutdown.signal;
   info: CompilerServerInfo;
+  #client: CompilerClient;
+  #url: string;
 
   constructor(ctx: ManifestContext, op: CompilerOp) {
     this.#ctx = ctx;
+    this.#client = new CompilerClient(ctx, LogUtil.scoped('client.server'));
+    this.#url = this.#client.url;
     this.info = {
       state: 'startup',
       iteration: Date.now(),
       mode: op === 'run' ? 'build' : op,
       serverPid: process.pid,
       compilerPid: -1,
-      path: ctx.workspacePath,
-      url: ctx.compilerUrl
+      path: ctx.workspace.path,
+      url: this.#url
     };
 
     this.#server = http.createServer({
@@ -56,15 +60,14 @@ export class CompilerServer {
       keepAliveTimeout: 1000 * 60 * 60,
     }, (req, res) => this.#onRequest(req, res));
 
-    // Connect
-    process.on('SIGINT', () => this.#shutdown.abort());
+    process.once('exit', () => this.#shutdown.abort());
   }
 
   get mode(): CompilerMode {
     return this.info.mode;
   }
 
-  isResetEvent(ev: CompilerServerEvent): boolean {
+  isResetEvent(ev: CompilerEvent): boolean {
     return ev.type === 'state' && ev.payload.state === 'reset';
   }
 
@@ -74,14 +77,14 @@ export class CompilerServer {
         .on('listening', () => resolve('ok'))
         .on('error', async err => {
           if ('code' in err && err.code === 'EADDRINUSE') {
-            const info = await CompilerClientUtil.getServerInfo(this.#ctx);
+            const info = await this.#client.info();
             resolve((info && info.mode === 'build' && this.mode === 'watch') ? 'retry' : 'running');
           } else {
             reject(err);
           }
         });
 
-      const url = new URL(this.#ctx.compilerUrl);
+      const url = new URL(this.#url);
       setTimeout(() => this.#server.listen(+url.port, url.hostname), 1); // Run async
     });
 
@@ -91,7 +94,7 @@ export class CompilerServer {
       }
       log('info', 'Waiting for build to finish, before retrying');
       // Let the server finish
-      await CompilerClientUtil.waitForState(this.#ctx, ['close'], this.signal);
+      await this.#client.waitForState(['close'], 'Server closed', this.signal);
       return this.#tryListen(attempt + 1);
     }
 
@@ -107,7 +110,7 @@ export class CompilerServer {
     res.end();
   }
 
-  #emitEvent(ev: CompilerServerEvent): void {
+  #emitEvent(ev: CompilerEvent): void {
     const msg = `${JSON.stringify(ev.payload)}\n`;
     for (const el of this.#listeners) {
       if (!el.res.closed && el.type === ev.type) {
@@ -124,8 +127,8 @@ export class CompilerServer {
   }
 
   async #clean(): Promise<{ clean: boolean }> {
-    await Promise.all([this.#ctx.compilerFolder, this.#ctx.outputFolder]
-      .map(f => fs.rm(path.resolve(this.#ctx.workspacePath, f), { recursive: true, force: true })));
+    await Promise.all([this.#ctx.build.compilerFolder, this.#ctx.build.outputFolder]
+      .map(f => fs.rm(path.resolve(this.#ctx.workspace.path, f), { recursive: true, force: true })));
     return { clean: true };
   }
 
@@ -135,7 +138,7 @@ export class CompilerServer {
   async #onRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     res.setHeader('Content-Type', 'application/json');
 
-    const [, action, subAction] = new URL(`${this.#ctx.compilerUrl}${req.url}`).pathname.split('/');
+    const [, action, subAction] = new URL(`${this.#url}${req.url}`).pathname.split('/');
 
     log('debug', 'Receive request', { action, subAction });
 
@@ -143,7 +146,7 @@ export class CompilerServer {
     switch (action) {
       case 'send-event': await this.#emitEvent(await CompilerServer.readJSONRequest(req)); out = { received: true }; break;
       case 'event': return await this.#addListener(subAction, res);
-      case 'stop': out = await this.close(); break;
+      case 'stop': out = await this.close(true); break;
       case 'clean': out = await this.#clean(); break;
       case 'info':
       default: out = this.info ?? {}; break;
@@ -154,11 +157,16 @@ export class CompilerServer {
   /**
    * Process events
    */
-  async processEvents(src: (signal: AbortSignal) => AsyncIterable<CompilerServerEvent>): Promise<void> {
+  async processEvents(src: (signal: AbortSignal) => AsyncIterable<CompilerEvent>): Promise<void> {
 
-    CompilerClientUtil.streamLogs(this.#ctx, this.signal); // Send logs to stdout
+    LogUtil.log('compiler', 'debug', 'Started, streaming logs');
+    LogUtil.consumeLogEvents(this.#client.fetchEvents('log', { signal: this.signal }));
 
     for await (const ev of CommonUtil.restartableEvents(src, this.signal, this.isResetEvent)) {
+      if (ev.type === 'progress') {
+        await LogUtil.logProgress?.(ev.payload);
+      }
+
       this.#emitEvent(ev);
 
       if (ev.type === 'state') {
@@ -174,19 +182,22 @@ export class CompilerServer {
     }
 
     // Terminate, after letting all remaining events emit
-    await this.close();
+    await this.close(this.signal.aborted);
   }
 
   /**
    * Close server
    */
-  async close(): Promise<unknown> {
-    if (this.signal.aborted) {
-      return;
-    }
-
+  async close(force: boolean): Promise<unknown> {
     log('info', 'Closing down server');
     await new Promise(r => {
+
+      if (force) {
+        const cancel: CompilerProgressEvent = { complete: true, idx: 0, total: 0, message: 'Complete', operation: 'compile' };
+        LogUtil.logProgress?.(cancel);
+        this.#emitEvent({ type: 'progress', payload: cancel });
+      }
+
       this.#server.close(r);
       this.#emitEvent({ type: 'state', payload: { state: 'close' } });
       this.#server.unref();
@@ -203,7 +214,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.#ctx.compilerUrl);
+    log('info', running ? 'Starting server' : 'Server already running under a different process', this.#url);
     return running ? this : undefined;
   }
 }

package/support/setup.ts

@@ -1,16 +1,18 @@
-import path from 'path';
-import fs from 'fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import fs from 'node:fs/promises';
 
-import { type DeltaEvent, type ManifestContext, type ManifestRoot, Package } from '@travetto/manifest';
+import { type DeltaEvent, type ManifestContext, type Package } from '@travetto/manifest';
 
 import { LogUtil } from './log';
 import { CommonUtil } from './util';
 
 type ModFile = { input: string, output: string, stale: boolean };
 
-const SOURCE_SEED = ['package.json', 'index.ts', '__index__.ts', 'src', 'support', 'bin'];
-const PRECOMPILE_MODS = ['@travetto/terminal', '@travetto/manifest', '@travetto/transformer', '@travetto/compiler'];
+const SOURCE_SEED = ['package.json', '__index__.ts', 'src', 'support', 'bin'];
+const PRECOMPILE_MODS = ['@travetto/manifest', '@travetto/transformer', '@travetto/compiler'];
 const RECENT_STAT = (stat: { ctimeMs: number, mtimeMs: number }): number => Math.max(stat.ctimeMs, stat.mtimeMs);
+const REQ = createRequire(path.resolve('node_modules')).resolve.bind(null);
 
 /**
  * Compiler Setup Utilities
@@ -18,10 +20,16 @@ const RECENT_STAT = (stat: { ctimeMs: number, mtimeMs: number }): number => Math
 export class CompilerSetup {
 
   /**
-   * Import a compiled manifest
+   * Import compiled manifest utilities
    */
-  static #importManifest = (ctx: ManifestContext): Promise<typeof import('@travetto/manifest')> =>
-    import(path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', '@travetto/manifest/__index__.js'));
+  static #importManifest = (ctx: ManifestContext): Promise<
+    Pick<typeof import('@travetto/manifest'), 'ManifestDeltaUtil' | 'ManifestUtil'>
+  > => {
+    const all = ['util', 'delta'].map(f =>
+      import(path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules', `@travetto/manifest/src/${f}.js`))
+    );
+    return Promise.all(all).then(props => Object.assign({}, ...props));
+  };
 
   /**  Convert a file to a given ext */
   static #sourceToExtension(inputFile: string, ext: string): string {
@@ -41,7 +49,7 @@ export class CompilerSetup {
   static async #transpileFile(ctx: ManifestContext, inputFile: string, outputFile: string): Promise<void> {
     const type = CommonUtil.getFileType(inputFile);
     if (type === 'js' || type === 'ts') {
-      const compilerOut = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules');
+      const compilerOut = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules');
 
       const text = (await fs.readFile(inputFile, 'utf8'))
         .replace(/from '([.][^']+)'/g, (_, i) => `from '${i.replace(/[.]js$/, '')}.js'`)
@@ -59,7 +67,7 @@ export class CompilerSetup {
       const main = pkg.main ? this.#sourceToOutputExt(pkg.main) : undefined;
       const files = pkg.files?.map(x => this.#sourceToOutputExt(x));
 
-      const content = JSON.stringify({ ...pkg, main, type: ctx.moduleType, files }, null, 2);
+      const content = JSON.stringify({ ...pkg, main, type: ctx.workspace.type, files }, null, 2);
       await CommonUtil.writeTextFile(outputFile, content);
     }
   }
@@ -68,9 +76,7 @@ export class CompilerSetup {
    * Scan directory to find all project sources for comparison
    */
   static async #getModuleSources(ctx: ManifestContext, module: string, seed: string[]): Promise<ModFile[]> {
-    const inputFolder = (ctx.mainModule === module) ?
-      process.cwd() :
-      CommonUtil.resolveModuleFolder(module);
+    const inputFolder = path.dirname(REQ(`${module}/package.json`));
 
     const folders = seed.filter(x => !/[.]/.test(x)).map(x => path.resolve(inputFolder, x));
     const files = seed.filter(x => /[.]/.test(x)).map(x => path.resolve(inputFolder, x));
@@ -98,7 +104,7 @@ export class CompilerSetup {
       }
     }
 
-    const outputFolder = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', module);
+    const outputFolder = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules', module);
     const out: ModFile[] = [];
     for (const input of files) {
       const output = this.#sourceToOutputExt(input.replace(inputFolder, outputFolder));
@@ -162,25 +168,21 @@ export class CompilerSetup {
   }
 
   /**
-   * Sets up compiler, and produces a manifest and set of changes that need to be processed
+   * Sets up compiler, and produces a set of changes that need to be processed
    */
-  static async setup(ctx: ManifestContext): Promise<{ manifest: ManifestRoot, changed: DeltaEvent[] }> {
+  static async setup(ctx: ManifestContext): Promise<DeltaEvent[]> {
     let changes = 0;
 
     await LogUtil.withLogger('precompile', async () => {
       for (const mod of PRECOMPILE_MODS) {
-        const count = (await this.#compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
-        if (mod !== '@travetto/terminal') {
-          changes += count;
-        }
+        changes += (await this.#compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
       }
     });
 
-    const { ManifestUtil, ManifestDeltaUtil, PackageUtil } = await this.#importManifest(ctx);
-
-    PackageUtil.clearCache();
+    const { ManifestUtil, ManifestDeltaUtil } = await this.#importManifest(ctx);
 
-    const manifest = await LogUtil.withLogger('manifest', () => ManifestUtil.buildManifest(ctx));
+    const manifest = await LogUtil.withLogger('manifest', () =>
+      ManifestUtil.buildManifest(ManifestUtil.getWorkspaceContext(ctx)));
 
     await LogUtil.withLogger('transformers', async () => {
       for (const mod of Object.values(manifest.modules).filter(m => m.files.$transformer?.length)) {
@@ -191,30 +193,32 @@ export class CompilerSetup {
     const delta = await LogUtil.withLogger('delta', async log => {
       if (changes) {
         log('debug', 'Skipping, everything changed');
-        return [{ type: 'changed', file: '*', module: ctx.mainModule } as const];
+        return [{ type: 'changed', file: '*', module: ctx.workspace.name, sourceFile: '' } as const];
       } else {
-        return ManifestDeltaUtil.produceDelta(ctx, manifest);
+        return ManifestDeltaUtil.produceDelta(manifest);
       }
     });
 
     if (changes) {
       await LogUtil.withLogger('reset', async log => {
-        await fs.rm(path.resolve(ctx.workspacePath, ctx.outputFolder), { recursive: true, force: true });
+        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 LogUtil.withLogger('manifest', async log => {
-      await ManifestUtil.writeManifest(ctx, manifest);
-      log('debug', `Wrote manifest ${ctx.mainModule}`);
+      await ManifestUtil.writeManifest(manifest);
+      log('debug', `Wrote manifest ${ctx.workspace.name}`);
 
-      // Update all manifests
-      if (delta.length && ctx.monoRepo && !ctx.mainFolder) {
+      // 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.local && x.name !== ctx.mainModule);
+        const mods = Object.values(manifest.modules).filter(x => x.local && x.name !== ctx.workspace.name);
         for (const mod of mods) {
-          await ManifestUtil.rewriteManifest(path.resolve(ctx.workspacePath, mod.sourceFolder));
+          const modCtx = ManifestUtil.getModuleContext(ctx, mod.sourceFolder);
+          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}`)}`);
@@ -222,8 +226,6 @@ export class CompilerSetup {
       }
     });
 
-    const changed = delta.filter(x => x.type === 'added' || x.type === 'changed');
-
-    return { manifest, changed };
+    return delta.filter(x => x.type === 'added' || x.type === 'changed');
   }
 }

package/support/types.ts

@@ -8,13 +8,13 @@ export type CompilerLogEvent = { level: CompilerLogLevel, message: string, time:
 export type CompilerProgressEvent = { idx: number, total: number, message: string, operation: 'compile', complete?: boolean };
 export type CompilerStateEvent = { state: CompilerStateType, extra?: Record<string, unknown> };
 
-export type CompilerServerEvent =
+export type CompilerEvent =
   { type: 'change', payload: CompilerChangeEvent } |
   { type: 'log', payload: CompilerLogEvent } |
   { type: 'progress', payload: CompilerProgressEvent } |
   { type: 'state', payload: CompilerStateEvent };
 
-export type CompilerServerEventType = CompilerServerEvent['type'];
+export type CompilerEventType = CompilerEvent['type'];
 
 export type CompilerServerInfo = {
   path: string;

package/support/util.ts

@@ -1,50 +1,42 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { createRequire } from 'module';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { setMaxListeners } from 'node:events';
 
 import type { ManifestContext } from '@travetto/manifest';
 
 import { LogUtil } from './log';
 
 const OPT_CACHE: Record<string, import('typescript').CompilerOptions> = {};
-const SRC_REQ = createRequire(path.resolve('node_modules'));
 
 export class CommonUtil {
   /**
    * Returns the compiler options
    */
   static async getCompilerOptions(ctx: ManifestContext): Promise<{}> {
-    if (!(ctx.workspacePath in OPT_CACHE)) {
-      let tsconfig = path.resolve(ctx.workspacePath, 'tsconfig.json');
+    if (!(ctx.workspace.path in OPT_CACHE)) {
+      let tsconfig = path.resolve(ctx.workspace.path, 'tsconfig.json');
 
       if (!await fs.stat(tsconfig).then(_ => true, _ => false)) {
-        tsconfig = SRC_REQ.resolve('@travetto/compiler/tsconfig.trv.json');
+        tsconfig = path.resolve(ctx.workspace.path, ctx.build.compilerModuleFolder, 'tsconfig.trv.json');
       }
 
       const ts = (await import('typescript')).default;
 
       const { options } = ts.parseJsonSourceFileConfigFileContent(
-        ts.readJsonConfigFile(tsconfig, ts.sys.readFile), ts.sys, ctx.workspacePath
+        ts.readJsonConfigFile(tsconfig, ts.sys.readFile), ts.sys, ctx.workspace.path
       );
 
-      OPT_CACHE[ctx.workspacePath] = {
+      OPT_CACHE[ctx.workspace.path] = {
         ...options,
         allowJs: true,
         resolveJsonModule: true,
-        sourceRoot: ctx.workspacePath,
-        rootDir: ctx.workspacePath,
-        outDir: path.resolve(ctx.workspacePath),
-        module: ctx.moduleType === 'commonjs' ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext,
+        sourceRoot: ctx.workspace.path,
+        rootDir: ctx.workspace.path,
+        outDir: path.resolve(ctx.workspace.path),
+        module: ctx.workspace.type === 'commonjs' ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext,
       };
     }
-    return OPT_CACHE[ctx.workspacePath];
-  }
-
-  /**
-   * Resolve module location
-   */
-  static resolveModuleFolder(mod: string): string {
-    return path.dirname(SRC_REQ.resolve(`${mod}/package.json`));
+    return OPT_CACHE[ctx.workspace.path];
   }
 
   /**
@@ -68,6 +60,7 @@ export class CommonUtil {
   static async * restartableEvents<T>(src: (signal: AbortSignal) => AsyncIterable<T>, parent: AbortSignal, shouldRestart: (item: T) => boolean): AsyncIterable<T> {
     outer: while (!parent.aborted) {
       const controller = new AbortController();
+      setMaxListeners(1000, controller.signal);
       // Chain
       parent.addEventListener('abort', () => controller.abort());
 
@@ -100,8 +93,8 @@ export class CommonUtil {
    */
   static moduleLoader(ctx: ManifestContext): (mod: string) => Promise<unknown> {
     return (mod) => {
-      const outputRoot = path.resolve(ctx.workspacePath, ctx.outputFolder);
-      process.env.TRV_MANIFEST = path.resolve(outputRoot, 'node_modules', ctx.mainModule); // Setup for running
+      const outputRoot = path.resolve(ctx.workspace.path, ctx.build.outputFolder);
+      process.env.TRV_MANIFEST = path.resolve(outputRoot, 'node_modules', ctx.main.name); // Setup for running
       return import(path.join(outputRoot, 'node_modules', mod)); // Return function to run import on a module
     };
   }