@travetto/compiler 3.0.0-rc.11 → 3.0.0-rc.12

package/bin/trv.js

@@ -1,81 +1,96 @@
 #!/usr/bin/env node
 
 // @ts-check
+import fs from 'fs/promises';
+import path from 'path';
+import { createRequire } from 'module';
+
+import { getManifestContext } from '@travetto/manifest/bin/context.js';
+
+const VALID_OPS = { watch: 'watch', build: 'build', clean: 'clean', manifest: 'manifest' };
 
 /**
  * @param {import('@travetto/manifest').ManifestContext} ctx
- * @return {Promise<import('../support/bin/compiler-bootstrap')>}
+ * @return {Promise<import('@travetto/compiler/support/launcher')>}
  */
-async function $getBootstrap(ctx) {
-  const path = require('path');
-  const { buildPackage } = require('./transpile');
+const $getLauncher = async (ctx) => {
+  const compPkg = createRequire(path.resolve('node_modules')).resolve('@travetto/compiler/package.json');
+  const files = [];
 
-  const root = path.resolve(__dirname, '..');
+  for (const file of ['support/launcher.js', 'support/transpile.js', 'package.json']) {
+    const target = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', '@travetto/compiler', file);
+    const src = compPkg.replace('package.json', file.replace(/[.]js$/, '.ts'));
 
-  const loc = await buildPackage(
-    ctx, '__compiler_bootstrap__', root, 'support/bin/compiler-bootstrap.ts',
-    ['support/bin/utils.ts', 'bin/transpile.js', 'package.json']
-  );
+    const targetTime = await fs.stat(target).then(s => Math.max(s.mtimeMs, s.ctimeMs)).catch(() => 0);
+    const srcTime = await fs.stat(src).then(s => Math.max(s.mtimeMs, s.ctimeMs));
+    // If stale
+    if (srcTime > targetTime) {
+      const ts = (await import('typescript')).default;
+      const module = ctx.moduleType === 'module' ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      const text = await fs.readFile(src, 'utf8');
+      if (file.endsWith('.js')) {
+        let content = ts.transpile(text, {
+          target: ts.ScriptTarget.ES2020, module, esModuleInterop: true, allowSyntheticDefaultImports: true
+        });
+        if (ctx.moduleType === 'module') {
+          content = content.replace(/^((?:im|ex)port .*from '[.][^']+)(')/mg, (_, a, b) => `${a}.js${b}`)
+            .replace(/^(import [^\n]*from '[^.][^\n/]+[/][^\n/]+[/][^\n']+)(')/mg, (_, a, b) => `${a}.js${b}`);
+        }
+        await fs.writeFile(target, content, 'utf8');
+      } else {
+        const pkg = JSON.parse(text);
+        pkg.type = ctx.moduleType;
+        await fs.writeFile(target, JSON.stringify(pkg, null, 2), 'utf8');
+      }
+      // Compile
+    }
+    files.push(target);
+  }
 
-  try { return require(loc); } catch { return import(loc); }
-}
+  try { return await require(files[0]); }
+  catch { return import(files[0]); }
+};
 
 /**
- * @param {import('@travetto/manifest').ManifestContext} ctx
- * @param {boolean} [watch]
+ * Parse arguments
+ * @param {string[]} args
+ * @returns {{ op?: keyof typeof VALID_OPS, clean?: boolean, outputPath?: string, env?: string }}
  */
-const compile = (ctx, watch) => $getBootstrap(ctx).then(({ compile: go }) => go(ctx, watch));
-
-/** @param {string[]} args */
-async function exec(args) {
-  const { getContext } = require('./transpile');
-  const op = args.find(x => !x.startsWith('-'));
-  /** @type {{clean?: boolean, quiet?: boolean}} */
-  const flags = Object.fromEntries(args.filter(x => x.startsWith('-')).map(x => x.split('-').pop()).map(x => [x, true]));
+function parseArgs(args) {
+  const op = VALID_OPS[args.find(x => !x.startsWith('-')) ?? ''];
+  return {
+    op,
+    clean: args.includes('--clean') || args.includes('-c'),
+    ...(op === 'manifest' ? { outputPath: args[1], env: args[2] } : {})
+  };
+}
 
-  const ctx = await getContext();
-  const message = flags.quiet ? () => { } : console.log.bind(console);
+const exec = async () => {
+  const ctx = await getManifestContext();
+  const { op, outputPath, env, ...flags } = parseArgs(process.argv.slice(2));
 
   // Clean if needed
   if (op === 'clean' || (op && flags.clean)) {
-    const fs = require('fs/promises');
-    await Promise.all([ctx.outputFolder, ctx.compilerFolder].map(folder =>
-      fs.rm(`${ctx.workspacePath}/${folder}`, { force: true, recursive: true })));
-    if (op === 'clean') {
-      message(`Cleaned ${ctx.workspacePath}: [${ctx.outputFolder}, ${ctx.compilerFolder}]`);
+    for (const f of [ctx.outputFolder, ctx.compilerFolder]) {
+      await fs.rm(path.resolve(ctx.workspacePath, f), { force: true, recursive: true });
     }
   }
 
+  if (op === 'clean') { // Clean needs to not attempt to compile/load launcher
+    return console.log(`Cleaned ${ctx.workspacePath}: [${ctx.outputFolder}, ${ctx.compilerFolder}]`);
+  }
+
+  const { compile, launchMain, exportManifest } = await $getLauncher(ctx);
+
   switch (op) {
-    case 'clean': break;
-    case 'manifest': {
-      const { writeManifest, buildManifest } = await $getBootstrap(ctx);
-      const manifest = (await buildManifest(ctx)).manifest;
-      await writeManifest(ctx, manifest);
-      const output = `${ctx.workspacePath}/${ctx.outputFolder}/${ctx.manifestFile}`;
-      message(`Wrote manifest ${output}`);
-      break;
-    }
+    case 'manifest': return exportManifest(ctx, outputPath ?? '', env);
     case 'watch':
-      message(`Watching ${ctx.workspacePath} for changes...`);
-      await compile(ctx, true);
-      return;
-    case 'build':
-      await compile(ctx);
-      message(`Built to ${ctx.workspacePath}/${ctx.outputFolder}`);
-      break;
-    default: {
-      const path = require('path/posix');
-      const { manifest } = await compile(ctx);
-      const out = path.join(ctx.workspacePath, ctx.outputFolder);
-      // TODO: Externalize somehow?
-      const cliMain = path.join(out, manifest.modules['@travetto/cli'].output, 'support', 'main.cli.js');
-      process.env.TRV_MANIFEST = ctx.mainModule;
-      process.env.TRV_OUTPUT = out;
-      await import(process.env.TRV_MAIN = cliMain);
-      return;
-    }
+    case 'build': return compile(ctx, op);
+    default:
+      await compile(ctx, op);
+      return launchMain(ctx);
   }
-}
+};
 
-exec(process.argv.slice(2));
+exec();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "3.0.0-rc.11",
+  "version": "3.0.0-rc.12",
   "description": "Compiler",
   "keywords": [
     "compiler",
@@ -13,6 +13,7 @@
     "email": "travetto.framework@gmail.com",
     "name": "Travetto Framework"
   },
+  "type": "module",
   "files": [
     "__index__.ts",
     "src",
@@ -29,13 +30,13 @@
     "directory": "module/compiler"
   },
   "dependencies": {
-    "@travetto/manifest": "^3.0.0-rc.6",
-    "@travetto/terminal": "^3.0.0-rc.5",
-    "@travetto/transformer": "^3.0.0-rc.9",
-    "@parcel/watcher": "^2.1.0"
+    "@parcel/watcher": "^2.1.0",
+    "@travetto/manifest": "^3.0.0-rc.7",
+    "@travetto/terminal": "^3.0.0-rc.6",
+    "@travetto/transformer": "^3.0.0-rc.10"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.0-rc.8"
+    "@travetto/cli": "^3.0.0-rc.9"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -1,12 +1,15 @@
+import util from 'util';
+import { install } from 'source-map-support';
 import ts from 'typescript';
 import fs from 'fs/promises';
-import path from 'path';
 
-import { ManifestState } from '@travetto/manifest';
 import { GlobalTerminal, TerminalProgressEvent } from '@travetto/terminal';
+import { RootIndex, watchFolders } from '@travetto/manifest';
+import { TransformerManager } from '@travetto/transformer';
 
 import { CompilerUtil } from './util';
 import { CompilerState } from './state';
+import type { CompilerLogEvent } from '../support/transpile';
 
 export type TransformerProvider = {
   init(checker: ts.TypeChecker): void;
@@ -14,36 +17,45 @@ export type TransformerProvider = {
 };
 
 type EmitError = Error | readonly ts.Diagnostic[];
-type Emitter = (file: string, newProgram?: boolean) => EmitError | undefined;
+type Emitter = (file: string, newProgram?: boolean) => Promise<EmitError | undefined>;
 type EmitEvent = { file: string, i: number, total: number, err?: EmitError };
 
+function log(level: 'info' | 'debug', message: string, ...args: unknown[]): void {
+  if (process.send) {
+    const ev: CompilerLogEvent = [level, util.format(message, ...args)];
+    process.send(ev);
+  } else {
+    // eslint-disable-next-line no-console
+    console[level](message, ...args);
+  }
+}
+
+const debug = log.bind(null, 'debug');
+const info = log.bind(null, 'info');
+
 /**
  * Compilation support
  */
 export class Compiler {
 
-  #bootTsconfig: string;
+  /**
+   * Run compiler as a main entry point
+   */
+  static async main(): Promise<void> {
+    const [dirty, watch] = process.argv.slice(2);
+    install();
+    const dirtyFiles = (await fs.readFile(dirty, 'utf8')).split(/\n/).filter(x => !!x);
+    return new Compiler(dirtyFiles).run(watch === 'true');
+  }
+
   #state: CompilerState;
-  #transformers: string[];
-
-  init(manifestState: ManifestState): this {
-    this.#state = new CompilerState(manifestState);
-    this.#bootTsconfig = this.#state.resolveModuleFile('@travetto/compiler', 'tsconfig.trv.json');
-
-    this.#transformers = this.state.modules.flatMap(
-      x => (x.files.support ?? [])
-        .filter(([f, type]) => type === 'ts' && f.startsWith('support/transformer.'))
-        .map(([f]) =>
-          path.resolve(
-            this.#state.manifest.workspacePath,
-            this.#state.manifest.compilerFolder,
-            x.output,
-            f.replace(/[.][tj]s$/, '.js')
-          )
-        )
-    );
-
-    return this;
+  #dirtyFiles: string[];
+
+  constructor(dirtyFiles: string[]) {
+    this.#state = new CompilerState(RootIndex.manifest);
+    this.#dirtyFiles = dirtyFiles[0] === '*' ?
+      this.#state.getAllFiles() :
+      dirtyFiles.map(f => this.#state.resolveInput(f));
   }
 
   get state(): CompilerState {
@@ -54,44 +66,27 @@ export class Compiler {
    * Watches local modules
    */
   async #watchLocalModules(emit: Emitter): Promise<() => Promise<void>> {
-    const folders = this.state.modules.filter(x => x.local).map(x => x.source);
-    const emitWithError = (file: string): void => {
-      const err = emit(file, true);
+    const emitWithError = async (file: string): Promise<void> => {
+      const err = await emit(file, true);
       if (err) {
-        console.error(CompilerUtil.buildTranspileError(file, err));
+        info('Compilation Error', CompilerUtil.buildTranspileError(file, err));
       } else {
-        console.error('Compiled', file.split('node_modules/')[1]);
+        info(`Compiled ${file.split('node_modules/')[1]}`);
       }
     };
     const watcher = this.state.getWatcher({
-      create: (inputFile) => emitWithError(inputFile),
-      update: (inputFile) => emitWithError(inputFile),
+      create: emitWithError,
+      update: emitWithError,
       delete: (outputFile) => fs.unlink(outputFile).catch(() => { })
     });
-    return CompilerUtil.fileWatcher(folders, watcher);
+    return watchFolders(RootIndex.getLocalInputFolders(), watcher, {
+      filter: ev => ev.file.endsWith('.ts') || ev.file.endsWith('.js'),
+      ignore: ['node_modules']
+    });
   }
 
   async createTransformerProvider(): Promise<TransformerProvider> {
-    const { TransformerManager } = await import('@travetto/transformer');
-    return TransformerManager.create(this.#transformers, this.state.manifest);
-  }
-
-  async writeRawFile(file: string, contents: string, mode?: string): Promise<void> {
-    const outFile = path.resolve(
-      this.#state.manifest.workspacePath,
-      this.#state.manifest.outputFolder,
-      file
-    );
-    await fs.mkdir(path.dirname(outFile), { recursive: true });
-    await fs.writeFile(outFile, contents, { encoding: 'utf8', mode });
-  }
-
-  async outputInit(): Promise<void> {
-    // Write manifest
-    await this.writeRawFile(this.#state.manifest.manifestFile, JSON.stringify(this.state.manifest));
-    // TODO: This needs to be isolated, just like in the bootstrap
-    await this.writeRawFile('trv', '#!/bin/sh\nnode node_modules/@travetto/cli/support/main.cli.js $@\n', '755');
-    await this.writeRawFile('trv.cmd', 'node node_modules/@travetto/cli/support/main.cli.js %*\n', '755');
+    return TransformerManager.create(this.state.transformers);
   }
 
   /**
@@ -101,28 +96,27 @@ export class Compiler {
     let program: ts.Program;
 
     const transformers = await this.createTransformerProvider();
-    const options = await CompilerUtil.getCompilerOptions(
-      path.resolve(
-        this.#state.manifest.workspacePath,
-        this.#state.manifest.outputFolder,
-      ),
-      this.#bootTsconfig,
-      this.#state.manifest.workspacePath
-    );
+    const options = await this.state.getCompilerOptions();
     const host = this.state.getCompilerHost(options);
 
-    const emit = (file: string, needsNewProgram = program === undefined): EmitError | undefined => {
-      if (needsNewProgram) {
-        program = ts.createProgram({ rootNames: this.#state.getAllFiles(), host, options, oldProgram: program });
-        transformers.init(program.getTypeChecker());
-      }
+    const emit = async (file: string, needsNewProgram = program === undefined): Promise<EmitError | undefined> => {
       try {
-        const result = program.emit(
-          program.getSourceFile(file)!, host.writeFile, undefined, false, transformers.get()
-        );
+        if (needsNewProgram) {
+          program = ts.createProgram({ rootNames: this.#state.getAllFiles(), host, options, oldProgram: program });
+          transformers.init(program.getTypeChecker());
+        }
+        if (file.endsWith('.json')) {
+          host.writeFile(file, host.readFile(file)!, false);
+        } else if (file.endsWith('.js')) {
+          host.writeFile(file, ts.transpile(host.readFile(file)!, options), false);
+        } else {
+          const result = program.emit(
+            program.getSourceFile(file)!, host.writeFile, undefined, false, transformers.get()
+          );
 
-        if (result.diagnostics?.length) {
-          return result.diagnostics;
+          if (result.diagnostics?.length) {
+            return result.diagnostics;
+          }
         }
       } catch (err) {
         if (err instanceof Error) {
@@ -141,45 +135,49 @@ export class Compiler {
    */
   async * emit(files: string[], emitter: Emitter): AsyncIterable<EmitEvent> {
     let i = 0;
-    const manifest = this.#state.manifest;
     for (const file of files) {
-      const err = emitter(file);
-      const outputFile = file
-        .replace(/[.]ts$/, '.js')
-        .replace(manifest.compilerFolder, manifest.outputFolder);
-      yield { file: outputFile, i: i += 1, err, total: files.length };
+      const err = await emitter(file);
+      const imp = file.replace(/.*node_modules\//, '');
+      yield { file: imp, i: i += 1, err, total: files.length };
     }
+    debug(`Compiled ${i} files`);
   }
 
   /**
    * Run the compiler
    */
   async run(watch?: boolean): Promise<void> {
-    await this.outputInit();
+    debug('Compilation started');
+
     const emitter = await this.getCompiler();
     let failed = false;
 
+    debug('Compiler loaded');
+
     const resolveEmittedFile = ({ file, total, i, err }: EmitEvent): TerminalProgressEvent => {
       if (err) {
         failed = true;
         console.error(CompilerUtil.buildTranspileError(file, err));
       }
-      return { idx: i, total, text: `Compiling [%idx/%total] -- ${file.split('node_modules/')[1]}` };
+      return { idx: i, total, text: `Compiling [%idx/%total] -- ${file}` };
     };
 
-    let files = this.state.getDirtyFiles();
-    if (!watch && !files.length) {
-      files = this.state.getAllFiles();
-    }
-
-    if (files.length) {
-      await GlobalTerminal.trackProgress(this.emit(files, emitter), resolveEmittedFile, { position: 'bottom' });
+    if (this.#dirtyFiles.length) {
+      await GlobalTerminal.trackProgress(this.emit(this.#dirtyFiles, emitter), resolveEmittedFile, { position: 'bottom' });
       if (failed) {
+        debug('Compilation failed');
         process.exit(1);
+      } else {
+        debug('Compilation succeeded');
       }
     }
 
     if (watch) {
+      if (!this.#dirtyFiles.length) {
+        const resolved = this.state.resolveInput(RootIndex.getModule('@travetto/manifest')!.files.src[0].sourceFile);
+        await emitter(resolved, true);
+      }
+      info('Watch is ready');
       await this.#watchLocalModules(emitter);
       await new Promise(r => setTimeout(r, 1000 * 60 * 60 * 24));
     }

package/src/state.ts

@@ -1,36 +1,32 @@
 import ts from 'typescript';
-import { mkdirSync, readFileSync, writeFile } from 'fs';
+import { readFileSync } from 'fs';
 
-import {
-  path,
-  ManifestModuleUtil, ManifestDelta, ManifestModule,
-  ManifestModuleFileType, ManifestRoot, ManifestState
-} from '@travetto/manifest';
+import { path, ManifestModuleUtil, ManifestModule, ManifestModuleFileType, ManifestRoot, WatchEvent } from '@travetto/manifest';
 
-import { CompilerUtil, FileWatchEvent } from './util';
+import { CompilerUtil } from './util';
+import { TranspileUtil } from '../support/transpile';
 
 const validFile = (type: ManifestModuleFileType): boolean => type === 'ts' || type === 'package-json' || type === 'js';
 
 export class CompilerState {
 
   #inputFiles: Set<string>;
-  #relativeInputToSource = new Map<string, { source: string, module: ManifestModule }>();
   #inputToSource = new Map<string, string>();
+  #stagedOutputToOutput = new Map<string, string>();
   #inputToOutput = new Map<string, string | undefined>();
   #inputDirectoryToSource = new Map<string, string>();
-  #sourceInputOutput = new Map<string, { input: string, output?: string, relativeInput: string, module: ManifestModule }>();
+  #sourceInputOutput = new Map<string, { source: string, input: string, stagedOutput?: string, output?: string, module: ManifestModule }>();
 
   #sourceContents = new Map<string, string | undefined>();
   #sourceFileObjects = new Map<string, ts.SourceFile>();
   #sourceHashes = new Map<string, number>();
 
   #manifest: ManifestRoot;
-  #delta: ManifestDelta;
   #modules: ManifestModule[];
+  #transformers: string[];
 
-  constructor({ manifest, delta }: ManifestState) {
+  constructor(manifest: ManifestRoot) {
     this.#manifest = manifest;
-    this.#delta = delta;
     this.#modules = Object.values(this.#manifest.modules);
     this.#inputFiles = new Set(this.#modules.flatMap(
       x => [
@@ -46,14 +42,29 @@ export class CompilerState {
         .map(([f]) => this.registerInput(x, f))
     ));
 
-    return this;
+    this.#transformers = this.#modules.flatMap(
+      x => (x.files.$transformer ?? []).map(([f]) =>
+        path.resolve(manifest.workspacePath, x.sourceFolder, f)
+      )
+    );
+  }
+
+  async getCompilerOptions(): Promise<ts.CompilerOptions> {
+    return {
+      ...await TranspileUtil.getCompilerOptions(this.#manifest),
+      outDir: this.#manifest.workspacePath, // Force to root
+    };
+  }
+
+  resolveInput(file: string): string {
+    return this.#sourceInputOutput.get(file)!.input;
   }
 
   registerInput(module: ManifestModule, moduleFile: string): string {
-    const relativeInput = `${module.output}/${moduleFile}`;
-    const sourceFile = `${module.source}/${moduleFile}`;
+    const relativeInput = `${module.outputFolder}/${moduleFile}`;
+    const sourceFile = path.toPosix(path.resolve(this.#manifest.workspacePath, module.sourceFolder, moduleFile));
     const sourceFolder = path.dirname(sourceFile);
-    const inputFile = path.resolve(relativeInput);
+    const inputFile = path.resolve(this.#manifest.workspacePath, '##', relativeInput); // Ensure input is isolated
     const inputFolder = path.dirname(inputFile);
     const fileType = ManifestModuleUtil.getFileType(moduleFile);
     const outputFile = fileType === 'typings' ?
@@ -61,25 +72,32 @@ export class CompilerState {
       path.resolve(
         this.#manifest.workspacePath,
         this.#manifest.outputFolder,
-        (fileType === 'ts' ? relativeInput.replace(/[.]ts$/, '.js') : relativeInput)
+        CompilerUtil.inputToOutput(relativeInput)
       );
 
+    // Rewrite stagedOutput to final output form
+    const stagedOutputFile = CompilerUtil.inputToOutput(inputFile);
+
     this.#inputToSource.set(inputFile, sourceFile);
-    this.#sourceInputOutput.set(sourceFile, { input: inputFile, output: outputFile, relativeInput, module });
+    this.#sourceInputOutput.set(sourceFile, { source: sourceFile, input: inputFile, stagedOutput: stagedOutputFile, output: outputFile, module });
     this.#inputToOutput.set(inputFile, outputFile);
     this.#inputDirectoryToSource.set(inputFolder, sourceFolder);
-    this.#relativeInputToSource.set(relativeInput, { source: sourceFile, module });
+
+    if (stagedOutputFile) {
+      this.#stagedOutputToOutput.set(stagedOutputFile, outputFile!);
+      this.#stagedOutputToOutput.set(`${stagedOutputFile}.map`, `${outputFile!}.map`);
+    }
 
     return inputFile;
   }
 
   removeInput(inputFile: string): void {
     const source = this.#inputToSource.get(inputFile)!;
-    const { relativeInput } = this.#sourceInputOutput.get(source)!;
+    const { stagedOutput } = this.#sourceInputOutput.get(source)!;
+    this.#stagedOutputToOutput.delete(stagedOutput!);
     this.#sourceInputOutput.delete(source);
     this.#inputToSource.delete(inputFile);
     this.#inputToOutput.delete(inputFile);
-    this.#relativeInputToSource.delete(relativeInput);
     this.#inputFiles.delete(inputFile);
   }
 
@@ -88,51 +106,29 @@ export class CompilerState {
     this.#sourceContents.delete(inputFile);
   }
 
-  get manifest(): ManifestRoot {
-    return this.#manifest;
-  }
-
   get modules(): ManifestModule[] {
     return this.#modules;
   }
 
-  getDirtyFiles(): string[] {
-    if (this.#delta && Object.keys(this.#delta).length) { // If we have any changes
-      const files: string[] = [];
-      for (const [modName, events] of Object.entries(this.#delta)) {
-        const mod = this.#manifest.modules[modName];
-        for (const { file } of events) {
-          const fileType = ManifestModuleUtil.getFileType(file);
-          if (validFile(fileType)) {
-            files.push(path.resolve(mod.output, file));
-          }
-        }
-      }
-      return files;
-    } else {
-      return [];
-    }
+  get transformers(): string[] {
+    return this.#transformers;
   }
 
   getAllFiles(): string[] {
     return [...this.#inputFiles];
   }
 
-  resolveModuleFile(module: string, file: string): string {
-    return `${this.modules.find(m => m.name === module)!.source}/${file}`;
-  }
-
   // Build watcher
   getWatcher(handler: {
     create: (inputFile: string) => void;
     update: (inputFile: string) => void;
     delete: (outputFile: string) => void;
-  }): (ev: FileWatchEvent, folder: string) => void {
-    const mods = Object.fromEntries(this.modules.map(x => [x.source, x]));
-    return ({ path: sourceFile, type }: FileWatchEvent, folder: string): void => {
+  }): (ev: WatchEvent, folder: string) => void {
+    const mods = Object.fromEntries(this.modules.map(x => [path.resolve(this.#manifest.workspacePath, x.sourceFolder), x]));
+    return ({ file: sourceFile, action }: WatchEvent, folder: string): void => {
       const mod = mods[folder];
-      const moduleFile = sourceFile.replace(`${mod.source}/`, '');
-      switch (type) {
+      const moduleFile = sourceFile.includes(mod.sourceFolder) ? sourceFile.split(`${mod.sourceFolder}/`)[1] : sourceFile;
+      switch (action) {
         case 'create': {
           const fileType = ManifestModuleUtil.getFileType(moduleFile);
           if (validFile(fileType)) {
@@ -165,16 +161,6 @@ export class CompilerState {
           }
         }
       }
-
-      // Update manifest on every change
-      writeFile(
-        path.resolve(
-          this.#manifest.workspacePath,
-          this.#manifest.outputFolder,
-          this.#manifest.manifestFile
-        ),
-        JSON.stringify(this.#manifest),
-        () => { });
     };
   }
 
@@ -202,14 +188,14 @@ export class CompilerState {
         sourceFiles?: readonly ts.SourceFile[],
         data?: ts.WriteFileCallbackData
       ): void => {
-        mkdirSync(path.dirname(outputFile), { recursive: true });
         if (outputFile.endsWith('package.json')) {
-          text = CompilerUtil.rewritePackageJSON(this.manifest, text, options);
+          text = CompilerUtil.rewritePackageJSON(this.#manifest, text, options);
         } else if (!options.inlineSourceMap && options.sourceMap && outputFile.endsWith('.map')) {
-          text = CompilerUtil.rewriteSourceMap(text, f => this.#relativeInputToSource.get(f));
+          text = CompilerUtil.rewriteSourceMap(this.#manifest.workspacePath, text, f => this.#sourceInputOutput.get(this.#inputToSource.get(f)!));
         } else if (options.inlineSourceMap && CompilerUtil.isSourceMapUrlPosData(data)) {
-          text = CompilerUtil.rewriteInlineSourceMap(text, f => this.#relativeInputToSource.get(f), data);
+          text = CompilerUtil.rewriteInlineSourceMap(this.#manifest.workspacePath, text, f => this.#sourceInputOutput.get(this.#inputToSource.get(f)!), data);
         }
+        outputFile = this.#stagedOutputToOutput.get(outputFile) ?? outputFile;
         ts.sys.writeFile(outputFile, text, bom);
       },
       getSourceFile: (inputFile: string, language: ts.ScriptTarget, __onErr?: unknown): ts.SourceFile => {