@travetto/compiler 3.4.4 → 4.0.0-rc.1

package/support/server/server.ts

@@ -1,53 +1,47 @@
-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 { setMaxListeners } from 'node:events';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerMode, CompilerOp, CompilerServerEvent, CompilerServerEventType, CompilerServerInfo } from '../types';
+import type { CompilerMode, CompilerProgressEvent, CompilerEvent, CompilerEventType, CompilerServerInfo } from '../types';
 import { LogUtil } from '../log';
-import { CompilerClientUtil } from './client';
+import { CompilerClient } from './client';
 import { CommonUtil } from '../util';
+import { ProcessHandle } from './process-handle';
 
-const log = LogUtil.log.bind(LogUtil, 'compiler-server');
+const log = LogUtil.logger('compiler-server');
 
 /**
  * Compiler Server Class
  */
 export class CompilerServer {
 
-  static readJSONRequest<T>(req: http.IncomingMessage): Promise<T> {
-    return new Promise<T>((res, rej) => {
-      const body: Buffer[] = [];
-      req.on('data', (chunk) => body.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk));
-      req.on('end', () => {
-        try {
-          res(JSON.parse(Buffer.concat(body).toString('utf8')));
-        } catch (err) {
-          rej(err);
-        }
-      });
-      req.on('error', rej);
-    });
-  }
-
   #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;
+  #handle: Record<'compiler' | 'server', ProcessHandle>;
 
-  constructor(ctx: ManifestContext, op: CompilerOp) {
+  constructor(ctx: ManifestContext, mode: CompilerMode) {
     this.#ctx = ctx;
+    this.#client = new CompilerClient(ctx, LogUtil.logger('client.server'));
+    this.#url = this.#client.url;
+    this.#handle = { server: new ProcessHandle(ctx, 'server'), compiler: new ProcessHandle(ctx, 'compiler') };
+
     this.info = {
       state: 'startup',
       iteration: Date.now(),
-      mode: op === 'run' ? 'build' : op,
+      mode,
       serverPid: process.pid,
       compilerPid: -1,
-      path: ctx.workspacePath,
-      url: ctx.compilerUrl
+      path: ctx.workspace.path,
+      url: this.#url
     };
 
     this.#server = http.createServer({
@@ -56,15 +50,14 @@ export class CompilerServer {
       keepAliveTimeout: 1000 * 60 * 60,
     }, (req, res) => this.#onRequest(req, res));
 
-    // Connect
-    process.on('SIGINT', () => this.#shutdown.abort());
+    setMaxListeners(1000, this.signal);
   }
 
   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 +67,16 @@ 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 {
+            log('warn', 'Failed in running server', err);
             reject(err);
           }
-        });
+        })
+        .on('close', () => log('debug', 'Server close event'));
 
-      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,8 +86,10 @@ 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);
+    } else if (output === 'ok') {
+      await this.#handle.server.writePid(this.info.serverPid);
     }
 
     return output;
@@ -102,12 +99,16 @@ export class CompilerServer {
     res.writeHead(200);
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     this.#listeners.push({ res, type: type as 'change' });
+    if (type === 'state') { // Send on initial connect
+      res.write(JSON.stringify({ state: this.info.state }));
+    }
+    res.write('\n'); // Send at least one byte on listen
     await new Promise(resolve => res.on('close', resolve));
     this.#listeners.splice(this.#listeners.findIndex(x => x.res === res), 1);
     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) {
@@ -120,12 +121,14 @@ export class CompilerServer {
     log('info', 'Server disconnect requested');
     this.info.iteration = Date.now();
     await new Promise(r => setTimeout(r, 20));
-    this.#server.closeAllConnections(); // Force reconnects
+    for (const el of this.#listeners) {
+      el.res.destroy();
+    }
   }
 
   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,16 +138,20 @@ 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 });
 
     let out: unknown;
     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 'clean': out = await this.#clean(); break;
+      case 'stop': {
+        // Must send immediately
+        res.end(JSON.stringify({ closing: true }));
+        await this.close();
+        break;
+      }
       case 'info':
       default: out = this.info ?? {}; break;
     }
@@ -154,19 +161,23 @@ export class CompilerServer {
   /**
    * Process events
    */
-  async processEvents(src: (signal: AbortSignal) => AsyncIterable<CompilerServerEvent>): Promise<void> {
-
-    CompilerClientUtil.streamLogs(this.#ctx, this.signal); // Send logs to stdout
-
+  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);
+      }
+
       this.#emitEvent(ev);
 
       if (ev.type === 'state') {
         this.info.state = ev.payload.state;
+        await this.#handle.compiler.writePid(this.info.compilerPid);
         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}`);
+      } else if (ev.type === 'log') {
+        LogUtil.logEvent(ev.payload);
       }
       if (this.isResetEvent(ev)) {
         await this.#disconnectActive();
@@ -175,27 +186,44 @@ export class CompilerServer {
 
     // Terminate, after letting all remaining events emit
     await this.close();
+
+    log('debug', 'Finished processing events');
   }
 
   /**
    * Close server
    */
-  async close(): Promise<unknown> {
-    if (this.signal.aborted) {
-      return;
+  async close(): Promise<void> {
+    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);
+      this.#emitEvent({ type: 'progress', payload: cancel });
     }
 
-    log('info', 'Closing down server');
-    await new Promise(r => {
-      this.#server.close(r);
-      this.#emitEvent({ type: 'state', payload: { state: 'close' } });
-      this.#server.unref();
-      setImmediate(() => {
-        this.#server.closeAllConnections();
-        this.#shutdown.abort();
+    try {
+      await new Promise((resolve, reject) => {
+        setTimeout(reject, 2000).unref(); // 2s max wait
+        this.#server.close(resolve);
+        this.#emitEvent({ type: 'state', payload: { state: 'close' } });
+        setImmediate(() => {
+          this.#server.closeAllConnections();
+          this.#shutdown.abort();
+        });
       });
-    });
-    return { closing: true };
+    } catch { // Timeout or other error
+      // Force shutdown
+      this.#server.closeAllConnections();
+      if (this.info.compilerPid) { // Ensure its killed
+        try {
+          process.kill(this.info.compilerPid);
+        } catch { }
+      }
+    }
+
+    log('info', 'Closed down server');
   }
 
   /**
@@ -203,7 +231,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.workspace && 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

@@ -1,20 +1,19 @@
 export type CompilerMode = 'build' | 'watch';
-export type CompilerOp = CompilerMode | 'run';
 
 export type CompilerStateType = 'startup' | 'init' | 'compile-start' | 'compile-end' | 'watch-start' | 'watch-end' | 'reset' | 'close';
-export type CompilerChangeEvent = { file: string, action: 'create' | 'update' | 'delete', folder: string, output: string, module: string, time: number };
+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 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];
   }
 
   /**
@@ -66,25 +58,28 @@ 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');
     outer: while (!parent.aborted) {
       const controller = new AbortController();
+      setMaxListeners(1000, controller.signal);
       // Chain
       parent.addEventListener('abort', () => controller.abort());
 
       const comp = src(controller.signal);
 
-      LogUtil.log('event-stream', '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');
           controller.abort(); // Ensure terminated of process
           continue outer;
         }
       }
 
-      LogUtil.log('event-stream', 'debug', 'Finished event stream');
+      log('debug', 'Finished event stream');
 
       // Natural exit, we done
       if (!controller.signal.aborted) { // Shutdown source if still running
@@ -100,8 +95,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
     };
   }