@travetto/compiler 3.3.1 → 3.4.0-rc.0

package/README.md

@@ -21,56 +21,62 @@ This module expands upon the [Typescript](https://typescriptlang.org) compiler,
 Beyond the [Typescript](https://typescriptlang.org) compiler functionality, the module provides the primary entry point into the development process.
 
 ## CLI
-The cli, [trv](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trv.js#L60) is a compilation aware entry point, that has the ability to check for active builds, and ongoing watch operations to ensure only one process is building at a time.  Within the framework, regardless of mono-repo or not, always builds the entire project.  With the efficient caching behavior, this leads to generally a minimal overhead but allows for centralization of all operations. 
+The compiler cli, [trvc](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trvc.js#L7) is a compilation aware entry point, that has the ability to check for active builds, and ongoing watch operations to ensure only one process is building at a time.  Within the framework, regardless of mono-repo or not, always builds the entire project.  With the efficient caching behavior, this leads to generally a minimal overhead but allows for centralization of all operations. 
 
-The CLI supports the following operations:
-   *  `clean` - Removes the output folder, and if `-a` is also passed, will also clean out the compiler folder
-   *  `build` - Will attempt to build the project.  If the project is already built, will return immediately.  If the project is being built somewhere else, will wait until a build is completed.
-   *  `watch` - If nothing else is watching, will start the watch operation.  Otherwise will return immediately.
-   *  `manifest` - Will produce a manifest. If no file is passed in the command line arguments, will output to stdout.
-   *  `<other>` - Will be delegated to the [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") entry point after a successful build.
+The compiler cli supports the following operations:
+   *  `start|watch` - Run the compiler in watch mode
+   *  `stop` - Stop the compiler if running
+   *  `restart` - Restart the compiler in watch mode
+   *  `build` - Ensure the project is built and upto date
+   *  `clean` - Clean out the output and compiler caches
+   *  `info` - Retrieve the compiler information, if running
+   *  `manifest` - Generate the project manifest
 In addition to the normal output, the compiler supports an environment variable `TRV_BUILD` that supports the following values: `debug`, `info`, `warn` or `none`.  This provides different level of logging during the build process which is helpful to diagnose any odd behaviors.  When invoking an unknown command (e.g. `<other>` from above), the default level is `warn`.  Otherwise the default logging level is `info`.
 
 **Terminal: Sample trv output with debug logging**
 ```bash
-$ TRV_BUILD=debug trv build
+$ TRV_BUILD=debug trvc build
 
-2029-03-14T04:00:00.618Z [lock           ] Acquiring build
-2029-03-14T04:00:00.837Z [precompile     ] Started
-2029-03-14T04:00:01.510Z [precompile     ] @travetto/terminal Skipped
-2029-03-14T04:00:02.450Z [precompile     ] @travetto/manifest Skipped
-2029-03-14T04:00:02.762Z [precompile     ] @travetto/transformer Skipped
-2029-03-14T04:00:02.947Z [precompile     ] @travetto/compiler Skipped
-2029-03-14T04:00:03.093Z [precompile     ] Completed
-2029-03-14T04:00:04.003Z [manifest       ] Started
-2029-03-14T04:00:04.495Z [manifest       ] Completed
-2029-03-14T04:00:05.066Z [transformers   ] Started
-2029-03-14T04:00:05.307Z [transformers   ] @travetto/base Skipped
-2029-03-14T04:00:05.952Z [transformers   ] @travetto/cli Skipped
-2029-03-14T04:00:06.859Z [transformers   ] @travetto/manifest Skipped
-2029-03-14T04:00:07.720Z [transformers   ] @travetto/registry Skipped
-2029-03-14T04:00:08.179Z [transformers   ] @travetto/schema Skipped
-2029-03-14T04:00:08.588Z [transformers   ] Completed
-2029-03-14T04:00:09.493Z [delta          ] Started
-2029-03-14T04:00:10.395Z [delta          ] Completed
-2029-03-14T04:00:10.407Z [manifest       ] Started
-2029-03-14T04:00:10.799Z [manifest       ] Wrote manifest @travetto-doc/compiler
-2029-03-14T04:00:11.013Z [manifest       ] Completed
-2029-03-14T04:00:11.827Z [compile        ] Started action=build changed=
-2029-03-14T04:00:11.894Z [compile        ] Skipped
-2029-03-14T04:00:12.133Z [lock           ] Releasing build
-2029-03-14T04:00:13.123Z [build          ] Successfully built
+2029-03-14T04:00:00.618Z info  [compiler-server] Starting server http://127.0.0.1:29222
+2029-03-14T04:00:00.837Z debug [compiler-client] Starting watch for events of type "log"
+2029-03-14T04:00:01.510Z debug [event-stream   ] Started event stream
+2029-03-14T04:00:02.450Z debug [precompile     ] Started
+2029-03-14T04:00:02.762Z debug [compiler-server] Receive request { action: 'event', subAction: 'log' }
+2029-03-14T04:00:02.947Z debug [precompile     ] Skipped @travetto/terminal
+2029-03-14T04:00:03.093Z debug [precompile     ] Skipped @travetto/manifest
+2029-03-14T04:00:04.003Z debug [precompile     ] Skipped @travetto/transformer
+2029-03-14T04:00:04.495Z debug [precompile     ] Skipped @travetto/compiler
+2029-03-14T04:00:05.066Z debug [precompile     ] Completed
+2029-03-14T04:00:05.307Z debug [manifest       ] Started
+2029-03-14T04:00:05.952Z debug [manifest       ] Completed
+2029-03-14T04:00:06.859Z debug [transformers   ] Started
+2029-03-14T04:00:07.720Z debug [transformers   ] Skipped @travetto/base
+2029-03-14T04:00:08.179Z debug [transformers   ] Skipped @travetto/cli
+2029-03-14T04:00:08.588Z debug [transformers   ] Skipped @travetto/manifest
+2029-03-14T04:00:09.493Z debug [transformers   ] Skipped @travetto/registry
+2029-03-14T04:00:10.395Z debug [transformers   ] Skipped @travetto/schema
+2029-03-14T04:00:10.407Z debug [transformers   ] Completed
+2029-03-14T04:00:10.799Z debug [delta          ] Started
+2029-03-14T04:00:11.013Z debug [delta          ] Completed
+2029-03-14T04:00:11.827Z debug [manifest       ] Started
+2029-03-14T04:00:11.894Z debug [manifest       ] Wrote manifest @travetto-doc/compiler
+2029-03-14T04:00:12.133Z debug [manifest       ] Completed
+2029-03-14T04:00:13.123Z info  [compiler-server] State changed: compile-end
+2029-03-14T04:00:14.014Z debug [compiler-exec  ] Skipped
+2029-03-14T04:00:14.924Z debug [event-stream   ] Finished event stream
+2029-03-14T04:00:15.690Z info  [compiler-server] Closing down server
+2029-03-14T04:00:15.865Z debug [compiler-client] Stopping watch for events of type "log"
 ```
 
 **Terminal: Sample trv output with default log level**
 ```bash
-$ trv build
+$ trvc build
 ```
 
 ## Compilation Architecture
 The compiler will move through the following phases on a given compilation execution:
    *  `Bootstrapping` - Initial compilation of [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework")'s `support/*.ts` files
-   *  `Lock Management` - Manages cross-process interaction to ensure single compiler
+   *  `Compiler Server` - Provides a simple HTTP interface to watching compiler file and state changes, and synchronizing multiple processes
    *  `Build Compiler` - Leverages [Typescript](https://typescriptlang.org) to build files needed to execute compiler
    *  `Build Manifest` - Produces the manifest for the given execution
    *  `Build Transformers` - Leverages [Typescript](https://typescriptlang.org) to compile all transformers defined in the manifest
@@ -80,12 +86,4 @@ The compiler will move through the following phases on a given compilation execu
    *  `Invoke Compiler` - Run [Typescript](https://typescriptlang.org) compiler with the aforementioned enhancements
 
 ### Bootstrapping
-Given that the framework is distributed as [Typescript](https://typescriptlang.org) only files, there is a bootstrapping problem that needs to be mitigated.  The [trv](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trv.js#L60) entrypoint, along with a small context utility in [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching") are the only [Javascript](https://developer.mozilla.org/en-US/docs/Web/JavaScript) files needed to run the project.  The [trv](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trv.js#L60) entry point will compile `@travetto/compiler/support/*` files as the set that is used at startup.  These files are also accessible to the compiler as they get re-compiled after the fact.
-
-### Lock Management
-The compiler supports invocation from multiple locations at the same time, and provides a layer of orchestration to ensure a single process is building at a time.  For a given project, there are four main states:
-   *  No Watch - Building
-   *  Watch    - No Build
-   *  Watch    - Building
-   *  Inactive / Stale
-Depending on what state the project is in (depending on various processes), will influence what the supporting tooling should do. [LockManager](https://github.com/travetto/travetto/tree/main/module/compiler/support/lock.ts#L25) represents the majority of the logic for tracking various states, and informing what action should happen when in the above states.
+Given that the framework is distributed as [Typescript](https://typescriptlang.org) only files, there is a bootstrapping problem that needs to be mitigated.  The [trvc](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trvc.js#L7) entrypoint, along with a small context utility in [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching") are the only [Javascript](https://developer.mozilla.org/en-US/docs/Web/JavaScript) files needed to run the project.  The [trvc](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trvc.js#L7) entry point will compile `@travetto/compiler/support/*` files as the set that is used at startup.  These files are also accessible to the compiler as they get re-compiled after the fact.

package/bin/{trv.js → common.js}

@@ -1,21 +1,18 @@
-#!/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' };
+const COMPILER_FILES = [...['entry.trvc', 'log', 'queue', 'server/client', 'server/runner', 'server/server', 'setup', 'util'].map(x => `support/${x}.ts`), 'package.json'];
 
-const COMPILER_FILES = [...['launcher', 'transpile', 'lock', 'log', 'lock-pinger'].map(x => `support/${x}.ts`), 'package.json'];
+/** @typedef {import('@travetto/manifest/src/types').ManifestContext} Ctx */
+/** @typedef {import('@travetto/compiler/support/types').EntryOp} EntryOp */
 
-/**
- * @param {import('@travetto/manifest').ManifestContext} ctx
- * @return {Promise<import('@travetto/compiler/support/launcher').launch>}
- */
-const $getLauncher = async (ctx) => {
+/** @return {Promise<import('@travetto/compiler/support/entry.trvc').main>} */
+const $getEntry = async (/** @type {Ctx} */ ctx) => {
   const tsconfigFile = path.resolve(ctx.workspacePath, 'tsconfig.json');
   if (!(await fs.stat(tsconfigFile).catch(() => undefined))) {
     await fs.writeFile(tsconfigFile, JSON.stringify({ extends: '@travetto/compiler/tsconfig.trv.json' }), 'utf8');
@@ -38,7 +35,7 @@ const $getLauncher = async (ctx) => {
       if (/[.]tsx?$/.test(file)) {
         const content = ts.transpile(
           text,
-          { target: ts.ScriptTarget.ES2020, module, esModuleInterop: true, allowSyntheticDefaultImports: true }
+          { target: ts.ScriptTarget.ES2022, module, esModuleInterop: true, allowSyntheticDefaultImports: true }
         )
           .replace(/^((?:im|ex)port .*from '[.][^']+)(')/mg, (_, a, b) => `${a}.js${b}`)
           .replace(/^(import [^\n]*from '[^.][^\n/]+[/][^\n/]+[/][^\n']+)(')/mg, (_, a, b) => `${a}.js${b}`);
@@ -53,23 +50,21 @@ const $getLauncher = async (ctx) => {
     files.push(target);
   }
 
-  try { return require(files[0]).launch; }
-  catch { return import(files[0]).then(x => x.launch); }
+  try { return require(files[0]).main; }
+  catch { return import(files[0]).then(x => x.main); }
 };
 
-(async () => {
-  const ctx = await getManifestContext();
-  const [op, args] = [VALID_OPS[process.argv[2]], process.argv.slice(3)];
-
-  if (op === 'clean') {
-    const folders = process.argv.find(x => x === '--all' || x === '-a') ? [ctx.outputFolder, ctx.compilerFolder] : [ctx.outputFolder];
-    for (const f of folders) {
-      await fs.rm(path.resolve(ctx.workspacePath, f), { force: true, recursive: true });
-    }
-    return console.log(`Cleaned ${ctx.workspacePath}: [${folders.join(', ')}]`);
-  }
-
-  const rootCtx = ctx.monoRepo ? await getManifestContext(ctx.workspacePath) : ctx;
+async function $compile(/** @type {Ctx} ctx*/ ctx, /** @type {EntryOp} op */ op) {
+  const rootCtx = await (ctx.monoRepo ? getManifestContext(ctx.workspacePath) : ctx);
+  return (await $getEntry(ctx))(ctx, rootCtx, op, process.argv.slice(3));
+}
 
-  return (await $getLauncher(ctx))(ctx, rootCtx, op, args);
-})();
+/**
+ * @template T
+ * @param {(ctx: Ctx, compile: typeof $compile)  => Promise<T>} fn
+ * @returns {Promise<T>}
+ */
+export async function withContext(fn) {
+  const ctx = await getManifestContext();
+  return fn(ctx, $compile);
+}

package/bin/trvc.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+// @ts-check
+import fs from 'fs/promises';
+import path from 'path';
+
+import { withContext } from './common.js';
+
+/** @typedef {import('@travetto/manifest/src/types').ManifestContext} Ctx */
+
+const stop = async (/** @typedef {Ctx} */ ctx) => {
+  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}]`);
+  }
+};
+
+const info = async (/** @typedef {Ctx} */ctx) => console.log(
+  JSON.stringify(await fetch(ctx.compilerUrl).then(v => v.json(), () => undefined) ?? { state: 'Server not running' }, null, 2)
+);
+
+const clean = async (/** @typedef {Ctx} */ctx) => {
+  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);
+  }
+};
+
+const help = () => [
+  'npx trvc [command]',
+  '',
+  'Available Commands:',
+  ' * start|watch - Run the compiler in watch mode',
+  ' * stop        - Stop the compiler if running',
+  ' * restart     - Restart the compiler in watch mode',
+  ' * build       - Ensure the project is built and upto date',
+  ' * clean       - Clean out the output and compiler caches',
+  ' * info        - Retrieve the compiler information, if running',
+  ' * manifest    - Generate the project manifest',
+].join('\n');
+
+withContext(async (ctx, compile) => {
+  const op = process.argv[2];
+
+  switch (op) {
+    case 'restart': return stop(ctx).then(() => compile(ctx, 'watch'));
+    case 'stop': return stop(ctx);
+    case 'info': return info(ctx);
+    case 'clean': return clean(ctx);
+    case 'watch':
+    case 'start': return compile(ctx, 'watch');
+    case 'build':
+    case 'manifest': return compile(ctx, op);
+    case undefined:
+    case 'help': return console.log(`\n${help()}\n`);
+    default: console.error(`Unknown trvc operation: ${op}\n`); return console.error(help());
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "3.3.1",
+  "version": "3.4.0-rc.0",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -23,7 +23,7 @@
   ],
   "main": "__index__.ts",
   "bin": {
-    "trv": "bin/trv.js"
+    "trvc": "bin/trvc.js"
   },
   "repository": {
     "url": "https://github.com/travetto/travetto.git",
@@ -31,12 +31,13 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.3.0",
-    "@travetto/manifest": "^3.3.1",
-    "@travetto/terminal": "^3.3.1",
-    "@travetto/transformer": "^3.3.1"
+    "@travetto/manifest": "^3.4.0-rc.0",
+    "@travetto/terminal": "^3.4.0-rc.0",
+    "@travetto/transformer": "^3.4.0-rc.0",
+    "@types/node": "^20.8.9"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.3.3"
+    "@travetto/cli": "^3.4.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -2,7 +2,6 @@ import { install } from 'source-map-support';
 import ts from 'typescript';
 import fs from 'fs/promises';
 
-import { GlobalTerminal, TerminalProgressEvent } from '@travetto/terminal';
 import { ManifestModuleUtil, RootIndex } from '@travetto/manifest';
 
 import { CompilerUtil } from './util';
@@ -10,6 +9,7 @@ import { CompilerState } from './state';
 import { CompilerWatcher } from './watch';
 import { Log } from './log';
 import { CompileEmitError, CompileEmitEvent, CompileEmitter } from './types';
+import { EventUtil } from './event';
 
 /**
  * Compilation support
@@ -39,7 +39,6 @@ export class Compiler {
     this.#watch = watch;
   }
 
-
   /**
    * Compile in a single pass, only emitting dirty files
    */
@@ -79,9 +78,10 @@ export class Compiler {
       yield { file: imp, i: i += 1, err, total: files.length };
       if ((Date.now() - lastSent) > 50) { // Limit to 1 every 50ms
         lastSent = Date.now();
-        process.send?.({ type: 'status', total: files.length, idx: i });
+        EventUtil.sendEvent('progress', { total: files.length, idx: i, message: imp, operation: 'compile' });
       }
     }
+    EventUtil.sendEvent('progress', { total: files.length, idx: files.length, message: 'Complete', operation: 'compile', complete: true });
     Log.debug(`Compiled ${i} files`);
   }
 
@@ -89,11 +89,12 @@ export class Compiler {
    * Run the compiler
    */
   async run(): Promise<void> {
-    await GlobalTerminal.init();
     install();
 
     Log.debug('Compilation started');
 
+    EventUtil.sendEvent('state', { state: 'init', extra: { pid: process.pid } });
+
     if (process.send) {
       process.on('disconnect', () => process.exit(0));
     }
@@ -103,18 +104,16 @@ export class Compiler {
 
     Log.debug('Compiler loaded');
 
-    const resolveEmittedFile = ({ file, total, i, err }: CompileEmitEvent): TerminalProgressEvent => {
-      if (err) {
-        failed = true;
-        console.error(CompilerUtil.buildTranspileError(file, err));
-      }
-      return { idx: i, total, text: `Compiling [%idx/%total] -- ${file}` };
-    };
-
-    process.send?.({ type: 'start' });
+    EventUtil.sendEvent('state', { state: 'compile-start' });
 
     if (this.#dirtyFiles.length) {
-      await GlobalTerminal.trackProgress(this.emit(this.#dirtyFiles, emitter), resolveEmittedFile, { position: 'bottom', minDelay: 50 });
+      for await (const ev of this.emit(this.#dirtyFiles, emitter)) {
+        if (ev.err) {
+          failed = true;
+          const compileError = CompilerUtil.buildTranspileError(ev.file, ev.err);
+          EventUtil.sendEvent('log', { level: 'error', message: compileError.toString(), time: Date.now() });
+        }
+      }
       if (failed) {
         Log.debug('Compilation failed');
         process.exit(1);
@@ -127,28 +126,45 @@ export class Compiler {
       await emitter(resolved, true);
     }
 
-    process.send?.({ type: 'complete' });
+    EventUtil.sendEvent('state', { state: 'compile-end' });
 
     if (this.#watch) {
       Log.info('Watch is ready');
-      for await (const { file, action } of CompilerWatcher.watch(this.#state)) {
-        if (action === 'restart') {
-          Log.info(`Triggering restart due to change in ${file}`);
-          process.send?.({ type: 'restart' });
+
+      EventUtil.sendEvent('state', { state: 'watch-start' });
+
+      for await (const ev of CompilerWatcher.watch(this.#state)) {
+        if (ev.action === 'reset') {
+          Log.info(`Triggering reset due to change in ${ev.file}`);
+          EventUtil.sendEvent('state', { state: 'reset' });
           return;
         }
-        const module = file.split('node_modules/')[1];
+        const { action, entry } = ev;
         if (action !== 'delete') {
-          const err = await emitter(file, true);
+          const err = await emitter(entry.input, true);
           if (err) {
-            Log.info('Compilation Error', CompilerUtil.buildTranspileError(file, err));
+            Log.info('Compilation Error', CompilerUtil.buildTranspileError(entry.input, err));
           } else {
-            Log.info(`Compiled ${module}`);
+            Log.info(`Compiled ${entry.source}`);
           }
         } else {
-          Log.info(`Removed ${module}`);
+          // Remove output
+          Log.info(`Removed ${entry.source}, ${entry.output}`);
+          await fs.rm(entry.output!, { force: true }); // Ensure output is deleted
         }
+
+        // Send change events
+        EventUtil.sendEvent('change', {
+          action: ev.action,
+          time: Date.now(),
+          file: ev.file,
+          folder: ev.folder,
+          output: ev.entry.output!,
+          module: ev.entry.module.name
+        });
       }
+
+      EventUtil.sendEvent('state', { state: 'watch-end' });
     }
   }
 }

package/src/event.ts

@@ -0,0 +1,7 @@
+import type { CompilerServerEvent, CompilerServerEventType } from '../support/types';
+
+export class EventUtil {
+  static sendEvent<K extends CompilerServerEventType, T extends CompilerServerEvent & { type: K }>(type: K, payload: T['payload']): void {
+    process.send?.({ type, payload });
+  }
+}

package/src/internal/watch-core.ts

@@ -0,0 +1,104 @@
+import fs from 'fs/promises';
+
+import { IndexedModule, ManifestContext, ManifestModuleUtil, RootIndex, path } from '@travetto/manifest';
+
+import { AsyncQueue } from '../../support/queue';
+
+export type WatchEvent<T = {}> =
+  ({ action: 'create' | 'update' | 'delete', file: string, folder: string } & T) |
+  { action: 'reset', file: string };
+
+const CREATE_THRESHOLD = 50;
+const VALID_TYPES = new Set(['ts', 'typings', 'js', 'package-json']);
+type ToWatch = { file: string, actions: string[] };
+
+/** Watch file for reset */
+async function watchForReset(q: AsyncQueue<WatchEvent>, root: string, files: ToWatch[], signal: AbortSignal): Promise<void> {
+  const watchers: Record<string, { folder: string, files: Map<string, (ToWatch & { name: string, actionSet: Set<string> })> }> = {};
+  // Group by base path
+  for (const el of files) {
+    const full = path.resolve(root, el.file);
+    const folder = path.dirname(full);
+    const tgt = { ...el, name: path.basename(el.file), actionSet: new Set(el.actions) };
+    const watcher = (watchers[folder] ??= { folder, files: new Map() });
+    watcher.files.set(tgt.name, tgt);
+  }
+
+  // Fire them all off
+  Object.values(watchers).map(async (watcher) => {
+    for await (const ev of fs.watch(watcher.folder, { persistent: true, encoding: 'utf8', signal })) {
+      const toWatch = watcher.files.get(ev.filename!);
+      if (toWatch) {
+        const stat = await fs.stat(path.resolve(root, ev.filename!)).catch(() => undefined);
+        const action = !stat ? 'delete' : ((Date.now() - stat.ctimeMs) < CREATE_THRESHOLD) ? 'create' : 'update';
+        if (toWatch.actionSet.has(action)) {
+          q.add({ action: 'reset', file: ev.filename! });
+        }
+      }
+    }
+  });
+}
+
+/** Watch recursive files for a given folder */
+async function watchFolder(ctx: ManifestContext, q: AsyncQueue<WatchEvent>, src: string, target: string, signal: AbortSignal): Promise<void> {
+  const lib = await import('@parcel/watcher');
+  const ignore = [
+    'node_modules', '**/.trv',
+    ...((!ctx.monoRepo || src === ctx.workspacePath) ? [ctx.compilerFolder, ctx.outputFolder, ctx.toolFolder] : []),
+    ...(await fs.readdir(src)).filter(x => x.startsWith('.'))
+  ];
+
+  const cleanup = await lib.subscribe(src, async (err, events) => {
+    if (err) {
+      console.error('Watch Error', err);
+    }
+    for (const ev of events) {
+      const finalEv = { action: ev.type, file: path.toPosix(ev.path), folder: target };
+      if (ev.type !== 'delete') {
+        const stats = await fs.stat(finalEv.file);
+        if ((Date.now() - stats.ctimeMs) < CREATE_THRESHOLD) {
+          ev.type = 'create'; // Force create on newly stated files
+        }
+      }
+
+      if (ev.type === 'delete' && finalEv.file === src) {
+        return q.close();
+      }
+
+      const matches = !finalEv.file.includes('/.') && VALID_TYPES.has(ManifestModuleUtil.getFileType(finalEv.file));
+      if (matches) {
+        q.add(finalEv);
+      }
+    }
+  }, { ignore });
+  signal.addEventListener('abort', () => cleanup.unsubscribe());
+}
+
+/** Watch files */
+export async function* fileWatchEvents(manifest: ManifestContext, modules: IndexedModule[], signal: AbortSignal): AsyncIterable<WatchEvent> {
+  const q = new AsyncQueue<WatchEvent>(signal);
+
+  for (const m of modules.filter(x => !manifest.monoRepo || x.sourcePath !== manifest.workspacePath)) {
+    watchFolder(manifest, q, m.sourcePath, m.sourcePath, signal);
+  }
+
+  // Add monorepo folders
+  if (manifest.monoRepo) {
+    const mono = modules.find(x => x.sourcePath === manifest.workspacePath)!;
+    for (const folder of Object.keys(mono.files)) {
+      if (!folder.startsWith('$')) {
+        watchFolder(manifest, q, path.resolve(mono.sourcePath, folder), mono.sourcePath, signal);
+      }
+    }
+  }
+
+  watchForReset(q, RootIndex.manifest.workspacePath, [
+    { file: RootIndex.manifest.outputFolder, actions: ['delete'] },
+    { file: RootIndex.manifest.compilerFolder, actions: ['delete'] },
+    { file: RootIndex.manifest.toolFolder, actions: ['delete'] },
+    { file: 'package-lock.json', actions: ['delete', 'update', 'create'] },
+    { file: 'package.json', actions: ['delete', 'update', 'create'] }
+  ], signal);
+
+  yield* q;
+}

package/src/log.ts

@@ -1,18 +1,17 @@
-import util from 'util';
+import type { CompilerLogLevel } from '../support/types';
+import { EventUtil } from './event';
 
-import type { CompilerLogEvent } from '../support/log';
-
-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 {
+function log(level: CompilerLogLevel, message: string, ...args: unknown[]): void {
+  EventUtil.sendEvent('log', { level, message, args, time: Date.now(), scope: 'compiler-exec' });
+  if (!process.send) {
     // eslint-disable-next-line no-console
     console[level](message, ...args);
   }
 }
 
 export const Log = {
+  warn: log.bind(null, 'warn'),
   debug: log.bind(null, 'debug'),
-  info: log.bind(null, 'info')
+  info: log.bind(null, 'info'),
+  error: log.bind(null, 'error'),
 };

package/src/state.ts

@@ -4,8 +4,8 @@ import { path, ManifestModuleUtil, ManifestModule, ManifestRoot, ManifestIndex }
 import { TransformerManager } from '@travetto/transformer';
 
 import { CompilerUtil } from './util';
-import { TranspileUtil } from '../support/transpile';
 import { CompileStateEntry } from './types';
+import { CommonUtil } from '../support/util';
 
 function folderMapper(root: string, prefix: string): { dir: string, translate: (val: string) => string } {
   let matched: string = '~~';
@@ -74,7 +74,7 @@ export class CompilerState implements ts.CompilerHost {
     this.#transformerManager = await TransformerManager.create(this.#manifestIndex);
 
     this.#compilerOptions = {
-      ...await TranspileUtil.getCompilerOptions(this.#manifest),
+      ...await CommonUtil.getCompilerOptions(this.#manifest),
       rootDir: this.#rootDir,
       outDir: this.#outputPath
     };
@@ -123,7 +123,7 @@ export class CompilerState implements ts.CompilerHost {
     return this.#sourceToEntry.get(sourceFile);
   }
 
-  registerInput(module: ManifestModule, moduleFile: string): string {
+  registerInput(module: ManifestModule, moduleFile: string): CompileStateEntry {
     const relativeInput = `${module.outputFolder}/${moduleFile}`;
     const sourceFile = path.resolve(this.#manifest.workspacePath, module.sourceFolder, moduleFile);
     const sourceFolder = path.dirname(sourceFile);
@@ -146,7 +146,7 @@ export class CompilerState implements ts.CompilerHost {
 
     this.#inputFiles.add(inputFile);
 
-    return inputFile;
+    return entry;
   }
 
   removeInput(inputFile: string): void {

package/src/types.ts

@@ -6,9 +6,3 @@ export type CompileEmitError = Error | readonly ts.Diagnostic[];
 export type CompileEmitter = (file: string, newProgram?: boolean) => Promise<CompileEmitError | undefined>;
 export type CompileEmitEvent = { file: string, i: number, total: number, err?: CompileEmitError };
 export type CompileStateEntry = { source: string, input: string, relativeInput: string, output?: string, module: ManifestModule };
-
-export type CompileWatcherHandler = {
-  create: (inputFile: string) => void;
-  update: (inputFile: string) => void;
-  delete: (outputFile: string) => void;
-};