@travetto/compiler 7.0.2 → 7.0.4

package/README.md

@@ -22,7 +22,7 @@ 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 compiler cli, [trvc](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trvc.js#L2) is the entry point for compilation-related operations. It 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, the compilation always targets 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) is the entry point for compilation-related operations. It 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, the compilation always targets 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 supports the following operations:
    *  `start|watch` - Run the compiler in watch mode
@@ -42,32 +42,23 @@ In addition to the normal output, the compiler supports an environment variable
 $ TRV_BUILD=debug trvc build
 
 2029-03-14T04:00:00.618Z info  [server         ] Starting server http://127.0.0.1:25539
-2029-03-14T04:00:00.837Z debug [main           ] Start Server
+2029-03-14T04:00:00.837Z debug [compiler-exec  ] Start Server
 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 [precompile     ] Skipped @travetto/manifest
-2029-03-14T04:00:02.947Z debug [precompile     ] Skipped @travetto/transformer
-2029-03-14T04:00:03.093Z debug [precompile     ] Skipped @travetto/compiler
-2029-03-14T04:00:04.003Z debug [precompile     ] Completed
-2029-03-14T04:00:04.495Z debug [manifest       ] Started
-2029-03-14T04:00:05.066Z debug [manifest       ] Completed
-2029-03-14T04:00:05.307Z debug [transformers   ] Started
-2029-03-14T04:00:05.952Z debug [transformers   ] Skipped @travetto/runtime
-2029-03-14T04:00:06.859Z debug [transformers   ] Skipped @travetto/schema
-2029-03-14T04:00:07.720Z debug [transformers   ] Completed
-2029-03-14T04:00:08.179Z debug [delta          ] Started
-2029-03-14T04:00:08.588Z debug [delta          ] Completed
-2029-03-14T04:00:09.493Z debug [manifest       ] Started
-2029-03-14T04:00:10.395Z debug [manifest       ] Wrote manifest @travetto-doc/compiler
-2029-03-14T04:00:10.407Z debug [manifest       ] Completed
-2029-03-14T04:00:10.799Z info  [server         ] State changed: compile-end
-2029-03-14T04:00:11.013Z debug [compiler-exec  ] Skipped
-2029-03-14T04:00:11.827Z debug [event-stream   ] Finished event stream
-2029-03-14T04:00:11.894Z info  [server         ] Closing down server
-2029-03-14T04:00:12.133Z debug [server         ] Server close event
-2029-03-14T04:00:13.123Z info  [server         ] Closed down server
-2029-03-14T04:00:14.014Z debug [server         ] Finished processing events
-2029-03-14T04:00:14.924Z debug [main           ] End Server
+2029-03-14T04:00:02.450Z info  [compiler-exec  ] Launching compiler
+2029-03-14T04:00:02.762Z debug [server         ] Compilation started
+2029-03-14T04:00:02.947Z info  [server         ] State changed: init
+2029-03-14T04:00:03.093Z debug [server         ] Compiler loaded
+2029-03-14T04:00:04.003Z info  [server         ] State changed: compile-start
+2029-03-14T04:00:04.495Z info  [server         ] State changed: compile-end
+2029-03-14T04:00:05.066Z debug [server         ] Compiler process shutdown
+2029-03-14T04:00:05.307Z debug [compiler-exec  ] Finished
+2029-03-14T04:00:05.952Z debug [event-stream   ] Finished event stream
+2029-03-14T04:00:06.859Z debug [compiler-exec  ] Shutting down process
+2029-03-14T04:00:07.720Z info  [server         ] Closing down server
+2029-03-14T04:00:08.179Z debug [server         ] Server close event
+2029-03-14T04:00:08.588Z info  [server         ] Closed down server
+2029-03-14T04:00:09.493Z debug [server         ] Finished processing events
+2029-03-14T04:00:10.395Z debug [compiler-exec  ] End Server
 ```
 
 **Terminal: Sample trv output with default log level**
@@ -77,7 +68,6 @@ $ 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
    *  `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
@@ -86,6 +76,3 @@ The compiler will move through the following phases on a given compilation execu
    *  `Clear all output if needed` - When the compiler source or transformers change, invalidate the entire output
    *  `Persist Manifest(s)` - Ensure the manifest is available for the compiler to leverage. Multiple will be written if in a monorepo
    *  `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 [trvc](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trvc.js#L2) 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#L2) 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/__index__.ts

@@ -1,5 +1,12 @@
+export * from './src/common.ts';
 export * from './src/compiler.ts';
+export * from './src/event.ts';
+export * from './src/log.ts';
 export * from './src/state.ts';
+export * from './src/types.ts';
 export * from './src/util.ts';
 export * from './src/watch.ts';
-export * from './src/types.ts';
+export * from './src/server/client.ts';
+export * from './src/server/server.ts';
+export * from './src/server/manager.ts';
+export * from './src/server/process-handle.ts';

package/bin/hook.js

@@ -0,0 +1,23 @@
+import { registerHooks, stripTypeScriptTypes } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+process.setSourceMapsEnabled(true); // Ensure source map during compilation/development
+process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps`; // Ensure it passes to children
+const ogEmitWarning = process.emitWarning;
+
+registerHooks({
+  load: (url, context, nextLoad) => {
+    if (/[.]tsx?$/.test(url)) {
+      try {
+        process.emitWarning = () => { }; // Suppress ts-node experimental warnings
+        const source = readFileSync(fileURLToPath(url), 'utf8');
+        return { format: 'module', source: stripTypeScriptTypes(source), shortCircuit: true };
+      } finally {
+        process.emitWarning = ogEmitWarning;
+      }
+    } else {
+      return nextLoad(url, context);
+    }
+  }
+});

package/bin/trvc-target.js

@@ -0,0 +1,4 @@
+// @ts-check
+import './hook.js';
+const { Compiler } = await import('../src/compiler.ts');
+Compiler.main();

package/bin/trvc.js

@@ -1,41 +1,5 @@
 #!/usr/bin/env node
-import { load } from './entry.common.js';
-
-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
- * event <log|progress|state> - Watch events in realtime as newline delimited JSON
- * exec <file> [...args]      - Allow for compiling and executing an entrypoint file
- * manifest --prod [output]   - Generate the project manifest
-`;
-
-const toJson = (/** @type {number} */ depth) => value => process.stdout.write(`${JSON.stringify(value, undefined, depth)}\n`) ||
-  new Promise(resolve => process.stdout.once('drain', resolve));
-
-load(operations => {
-  const [operation, ...all] = process.argv.slice(2);
-  const args = all.filter(arg => !arg.startsWith('-'));
-
-  switch (operation) {
-    case undefined:
-    case 'help': return console.log(help);
-    case 'info': return operations.info().then(toJson(2));
-    case 'event': return operations.events(args[0], toJson(0));
-    case 'manifest': return operations.manifest(args[0], all.some(arg => arg === '--prod'));
-    case 'exec': return operations.exec(args[0], all.slice(1));
-    case 'build': return operations.build();
-    case 'clean': return operations.clean();
-    case 'start':
-    case 'watch': return operations.watch();
-    case 'stop': return operations.stop();
-    case 'restart': return operations.restart();
-    default: console.error(`\nUnknown trvc operation: ${operation}\n${help}`);
-  }
-});
+// @ts-check
+import './hook.js';
+const { invoke } = await import('@travetto/compiler/support/invoke.ts');
+invoke();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "7.0.2",
+  "version": "7.0.4",
   "type": "module",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
@@ -30,12 +30,12 @@
     "directory": "module/compiler"
   },
   "dependencies": {
-    "@parcel/watcher": "^2.5.1",
-    "@travetto/manifest": "^7.0.1",
-    "@travetto/transformer": "^7.0.2"
+    "@parcel/watcher": "^2.5.4",
+    "@travetto/manifest": "^7.0.3",
+    "@travetto/transformer": "^7.0.4"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.2"
+    "@travetto/cli": "^7.0.6"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/{support/util.ts → src/common.ts}

@@ -1,30 +1,11 @@
-import fs from 'node:fs/promises';
 import { setMaxListeners } from 'node:events';
 import timers from 'node:timers/promises';
-import posix from 'node:path/posix';
-import native from 'node:path';
 
-import type { ManifestContext } from '@travetto/manifest';
+import { type ManifestContext, path } from '@travetto/manifest';
 
 import { Log } from './log.ts';
 
-const toPosix = (file: string): string => file.replaceAll('\\', '/');
-
 export class CommonUtil {
-  /**
-   * Determine file type
-   */
-  static getFileType(file: string): 'ts' | 'js' | 'package-json' | 'typings' | undefined {
-    return file.endsWith('package.json') ? 'package-json' :
-      (file.endsWith('.js') ? 'js' :
-        (file.endsWith('.d.ts') ? 'typings' : (/[.][cm]?tsx?$/.test(file) ? 'ts' : undefined)));
-  }
-
-  /**
-   * Write text file, and ensure folder exists
-   */
-  static writeTextFile = (file: string, content: string): Promise<void> =>
-    fs.mkdir(native.dirname(file), { recursive: true }).then(() => fs.writeFile(file, content, 'utf8'));
 
   /**
    * Restartable Event Stream
@@ -63,20 +44,6 @@ export class CommonUtil {
     }
   }
 
-  /**
-   * Naive hashing
-   */
-  static naiveHash(text: string): number {
-    let hash = 5381;
-
-    for (let i = 0; i < text.length; i++) {
-      // eslint-disable-next-line no-bitwise
-      hash = (hash * 33) ^ text.charCodeAt(i);
-    }
-
-    return Math.abs(hash);
-  }
-
   /**
    * Non-blocking timeout
    */
@@ -102,7 +69,15 @@ export class CommonUtil {
    * Resolve path for workspace, ensuring posix compliant slashes
    */
   static resolveWorkspace(ctx: ManifestContext, ...args: string[]): string {
-    const all = [process.cwd(), ctx.workspace.path, ...args].map(toPosix);
-    return process.platform === 'win32' ? toPosix(native.resolve(...all)) : posix.resolve(...all);
+    return path.resolve(ctx.workspace.path, ...args);
   }
+
+  /**
+   * Write to stdout with backpressure handling
+   */
+  static async writeStdout(level: number, data: unknown): Promise<void> {
+    if (data === undefined) { return; }
+    process.stdout.write(`${JSON.stringify(data, undefined, level)}\n`) ||
+      await new Promise(resolve => process.stdout.once('drain', resolve));
+  };
 }

package/src/compiler.ts

@@ -1,16 +1,16 @@
 import fs from 'node:fs/promises';
 import { setMaxListeners } from 'node:events';
 
-import { ManifestIndex, ManifestModuleUtil } from '@travetto/manifest';
+import { getManifestContext, ManifestDeltaUtil, ManifestIndex, ManifestUtil, type DeltaEvent } from '@travetto/manifest';
 
 import { CompilerUtil } from './util.ts';
 import { CompilerState } from './state.ts';
 import { CompilerWatcher } from './watch.ts';
-import { CompileEmitEvent, CompileEmitter, CompilerReset } from './types.ts';
+import { type CompileEmitEvent, type CompileEmitter, CompilerReset } from './types.ts';
 import { EventUtil } from './event.ts';
 
-import { IpcLogger } from '../support/log.ts';
-import { CommonUtil } from '../support/util.ts';
+import { IpcLogger } from './log.ts';
+import { CommonUtil } from './common.ts';
 
 const log = new IpcLogger({ level: 'debug' });
 
@@ -23,28 +23,24 @@ export class Compiler {
    * Run compiler as a main entry point
    */
   static async main(): Promise<void> {
-    const [dirty, watch] = process.argv.slice(2);
-    const state = await CompilerState.get(new ManifestIndex());
-    log.debug('Running compiler with dirty file', dirty);
-    const dirtyFiles = ManifestModuleUtil.getFileType(dirty) === 'ts' ? [dirty] :
-      (await fs.readFile(dirty, 'utf8')).split(/\n/).filter(line => !!line);
-    log.debug('Running compiler with dirty file', dirtyFiles);
-    await new Compiler(state, dirtyFiles, watch === 'true').run();
+    const ctx = ManifestUtil.getWorkspaceContext(getManifestContext());
+    const manifest = await ManifestUtil.buildManifest(ctx);
+    const delta = await ManifestDeltaUtil.produceDelta(manifest);
+    const state = await CompilerState.get(new ManifestIndex(manifest));
+    await new Compiler(state, delta, process.env.TRV_COMPILER_WATCH === 'true').run();
   }
 
   #state: CompilerState;
-  #dirtyFiles: string[];
   #watch?: boolean;
   #controller: AbortController;
   #signal: AbortSignal;
   #shuttingDown = false;
+  #deltaEvents: DeltaEvent[];
 
-  constructor(state: CompilerState, dirtyFiles: string[], watch?: boolean) {
+  constructor(state: CompilerState, deltaEvents: DeltaEvent[], watch?: boolean) {
     this.#state = state;
-    this.#dirtyFiles = dirtyFiles[0] === '*' ?
-      this.#state.getAllFiles() :
-      dirtyFiles.map(file => this.#state.getBySource(file)!.sourceFile);
     this.#watch = watch;
+    this.#deltaEvents = deltaEvents;
 
     this.#controller = new AbortController();
     this.#signal = this.#controller.signal;
@@ -169,9 +165,16 @@ export class Compiler {
     EventUtil.sendEvent('state', { state: 'compile-start' });
 
     const metrics: CompileEmitEvent[] = [];
+    const isCompilerChanged = this.#deltaEvents.some(event => this.#state.isCompilerFile(event.sourceFile));
+    const changedFiles = (isCompilerChanged ? this.#state.getAllFiles() : this.#deltaEvents.map(event => event.sourceFile));
 
-    if (this.#dirtyFiles.length) {
-      for await (const event of this.emit(this.#dirtyFiles, emitter)) {
+    if (this.#watch || changedFiles.length) {
+      await ManifestUtil.writeManifest(this.#state.manifestIndex.manifest);
+      await this.#state.initializeTypescript();
+    }
+
+    if (changedFiles.length) {
+      for await (const event of this.emit(changedFiles, emitter)) {
         if (event.error) {
           const compileError = CompilerUtil.buildTranspileError(event.file, event.error);
           failure ??= compileError;
@@ -187,6 +190,12 @@ export class Compiler {
       } else {
         log.debug('Compilation succeeded');
       }
+
+      // Rebuild manifests if dirty
+      const manifest = await ManifestUtil.buildManifest(this.#state.manifestIndex.manifest);
+      await ManifestUtil.writeManifest(manifest);
+      await ManifestUtil.writeDependentManifests(manifest);
+      this.#state.manifestIndex.reinitForModule(this.#state.manifest.main.name); // Reload
     } else if (this.#watch) {
       // Prime compiler before complete
       const resolved = this.#state.getArbitraryInputFile();

package/src/event.ts

@@ -1,6 +1,15 @@
-import type { CompilerEventPayload, CompilerEventType } from '../support/types.ts';
+import type { CompilerEvent, CompilerEventPayload, CompilerEventType } from './types.ts';
+
+const VALID_EVENT_TYPES = new Set<CompilerEventType>(['change', 'log', 'progress', 'state', 'all', 'file']);
 
 export class EventUtil {
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  static isComplilerEventType = (value: string): value is CompilerEventType => VALID_EVENT_TYPES.has(value as CompilerEventType);
+
+  static isCompilerEvent = (value: unknown): value is CompilerEvent =>
+    typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string' && EventUtil.isComplilerEventType(value.type);
+
   static sendEvent<K extends CompilerEventType, T extends CompilerEventPayload<K>>(type: K, payload: T): void {
     process.connected && process.send!({ type, payload }, undefined, undefined, () => { });
   }

package/{support → src}/log.ts

@@ -1,4 +1,4 @@
-import { CompilerLogEvent, CompilerLogLevel, CompilerProgressEvent } from './types.ts';
+import type { CompilerLogEvent, CompilerLogLevel, CompilerProgressEvent } from './types.ts';
 
 const LEVEL_TO_PRIORITY: Record<CompilerLogLevel | 'none', number> = { debug: 1, info: 2, warn: 3, error: 4, none: 5 };
 const SCOPE_MAX = 15;

package/{support → src}/server/client.ts

@@ -1,12 +1,13 @@
 import rl from 'node:readline/promises';
 import timers from 'node:timers/promises';
+import fs from 'node:fs/promises';
 import http, { Agent } from 'node:http';
 
-import { ManifestContext } from '@travetto/manifest';
+import type { ManifestContext } from '@travetto/manifest';
 
 import type { CompilerEventPayload, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types.ts';
 import type { LogShape } from '../log.ts';
-import { CommonUtil } from '../util.ts';
+import { CommonUtil } from '../common.ts';
 import { ProcessHandle } from './process-handle.ts';
 
 type FetchEventsConfig<T> = {
@@ -29,8 +30,10 @@ export class CompilerClient {
   #url: string;
   #log: LogShape;
   #handle: Record<'compiler' | 'server', ProcessHandle>;
+  #ctx: ManifestContext;
 
   constructor(ctx: ManifestContext, log: LogShape) {
+    this.#ctx = ctx;
     this.#url = ctx.build.compilerUrl.replace('localhost', '127.0.0.1');
     this.#log = log;
     this.#handle = { compiler: new ProcessHandle(ctx, 'compiler'), server: new ProcessHandle(ctx, 'server') };
@@ -71,8 +74,16 @@ export class CompilerClient {
   }
 
   /** Clean the server */
-  clean(): Promise<boolean> {
-    return this.#fetch('/clean', { timeout: 300 }).then(response => response.ok, () => false);
+  async clean(forceOnFailure?: boolean): Promise<boolean> {
+    const result = await this.#fetch('/clean', { timeout: 300 }).then(response => response.ok, () => false);
+    if (!result && forceOnFailure) {
+      this.#log.warn('Clean request failed, forcing cleanup');
+      try {
+        await Promise.all([this.#ctx.build.outputFolder, this.#ctx.build.typesFolder]
+          .map(file => fs.rm(CommonUtil.resolveWorkspace(this.#ctx, file), { force: true, recursive: true })));
+      } catch { }
+    }
+    return result;
   }
 
   /** Stop server and wait for shutdown */

package/src/server/manager.ts

@@ -0,0 +1,90 @@
+import { spawn } from 'node:child_process';
+
+import type { ManifestContext } from '@travetto/manifest';
+
+import type { CompilerEvent, CompilerLogLevel } from '../types.ts';
+import { AsyncQueue } from '../queue.ts';
+import { Log } from '../log.ts';
+import { CommonUtil } from '../common.ts';
+import { EventUtil } from '../event.ts';
+import type { CompilerClient } from './client.ts';
+import { CompilerServer } from './server.ts';
+
+const log = Log.scoped('compiler-exec');
+
+/**
+ * Running the compiler
+ */
+export class CompilerManager {
+  /** Run compile process */
+  static async * #runTarget(ctx: ManifestContext, watching: boolean, signal: AbortSignal): AsyncIterable<CompilerEvent> {
+    if (signal.aborted) {
+      log.debug('Skipping, shutting down');
+      return;
+    }
+
+    const queue = new AsyncQueue<CompilerEvent>();
+
+    log.info('Launching compiler');
+    const subProcess = spawn(process.argv0, ['-e', 'import("@travetto/compiler/bin/trvc-target.js")'], {
+      env: {
+        ...process.env,
+        TRV_COMPILER_WATCH: String(watching),
+        TRV_MANIFEST: CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', ctx.workspace.name),
+      },
+      detached: true,
+      stdio: ['pipe', 1, 2, 'ipc'],
+    })
+      .on('message', message => EventUtil.isCompilerEvent(message) && queue.add(message))
+      .on('exit', () => queue.close());
+
+    const kill = (): unknown => {
+      log.debug('Shutting down process');
+      return (subProcess.connected ? subProcess.send('shutdown', () => subProcess.kill()) : subProcess.kill());
+    };
+
+    process.once('SIGINT', kill);
+    signal.addEventListener('abort', kill);
+
+    yield* queue;
+
+    if (subProcess.exitCode !== 0) {
+      log.error(`Terminated during compilation, code=${subProcess.exitCode}, killed=${subProcess.killed}`);
+    }
+    process.off('SIGINT', kill);
+
+    log.debug('Finished');
+  }
+
+  /** Main entry point for compilation */
+  static async compile(ctx: ManifestContext, client: CompilerClient, config: { watch?: boolean, logLevel?: CompilerLogLevel, forceRestart?: boolean }): Promise<void> {
+    Log.initLevel(config.logLevel ?? 'info');
+    const watch = !!config.watch;
+
+    if (config.forceRestart && await client.stop()) {
+      log.info('Stopped existing server');
+    }
+
+    const server = await new CompilerServer(ctx, watch).listen();
+
+    // Wait for build to be ready
+    if (server) {
+      log.debug('Start Server');
+      await server.processEvents(signal => this.#runTarget(ctx, watch, signal));
+      log.debug('End Server');
+    } else {
+      log.info('Server already running, waiting for initial compile to complete');
+      const controller = new AbortController();
+      Log.consumeProgressEvents(() => client.fetchEvents('progress', { until: event => !!event.complete, signal: controller.signal }));
+      await client.waitForState(['compile-end', 'watch-start'], 'Successfully built');
+      controller.abort();
+    }
+  }
+
+  /** Compile only if necessary */
+  static async compileIfNecessary(ctx: ManifestContext, client: CompilerClient): Promise<void> {
+    if (!(await client.isWatching())) { // Short circuit if we can
+      await this.compile(ctx, client, { watch: false, logLevel: 'error' });
+    }
+  }
+}

package/{support → src}/server/process-handle.ts

@@ -3,8 +3,8 @@ import path from 'node:path';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import { Log, Logger } from '../log.ts';
-import { CommonUtil } from '../util.ts';
+import { Log, type Logger } from '../log.ts';
+import { CommonUtil } from '../common.ts';
 
 export class ProcessHandle {
 

package/{support → src}/server/server.ts

@@ -4,14 +4,12 @@ import { setMaxListeners } from 'node:events';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import {
-  type CompilerMode, type CompilerProgressEvent, type CompilerEvent,
-  type CompilerEventType, type CompilerServerInfo, isComplilerEventType
-} from '../types.ts';
+import type { CompilerProgressEvent, CompilerEvent, CompilerEventType, CompilerServerInfo } from '../types.ts';
 import { Log } from '../log.ts';
-import { CommonUtil } from '../util.ts';
+import { CommonUtil } from '../common.ts';
 import { CompilerClient } from './client.ts';
 import { ProcessHandle } from './process-handle.ts';
+import { EventUtil } from '../event.ts';
 
 const log = Log.scoped('server');
 
@@ -30,7 +28,7 @@ export class CompilerServer {
   #url: string;
   #handle: Record<'compiler' | 'server', ProcessHandle>;
 
-  constructor(ctx: ManifestContext, mode: CompilerMode) {
+  constructor(ctx: ManifestContext, watching: boolean) {
     this.#ctx = ctx;
     this.#client = new CompilerClient(ctx, Log.scoped('server.client'));
     this.#url = this.#client.url;
@@ -39,7 +37,7 @@ export class CompilerServer {
     this.info = {
       state: 'startup',
       iteration: Date.now(),
-      mode,
+      watching,
       serverProcessId: process.pid,
       compilerProcessId: -1,
       path: ctx.workspace.path,
@@ -59,8 +57,8 @@ export class CompilerServer {
     return this.#shutdown.signal;
   }
 
-  get mode(): CompilerMode {
-    return this.info.mode;
+  get watching(): boolean {
+    return this.info.watching;
   }
 
   isResetEvent(event: CompilerEvent): boolean {
@@ -74,7 +72,7 @@ export class CompilerServer {
         .on('error', async error => {
           if ('code' in error && error.code === 'EADDRINUSE') {
             const info = await this.#client.info();
-            resolve((info && info.mode === 'build' && this.mode === 'watch') ? 'retry' : 'running');
+            resolve((info && !info.watching && this.watching) ? 'retry' : 'running');
           } else {
             log.warn('Failed in running server', error);
             reject(error);
@@ -153,7 +151,7 @@ export class CompilerServer {
   }
 
   async #clean(): Promise<{ clean: boolean }> {
-    await Promise.all([this.#ctx.build.compilerFolder, this.#ctx.build.outputFolder]
+    await Promise.all([this.#ctx.build.outputFolder, this.#ctx.build.typesFolder]
       .map(folder => fs.rm(CommonUtil.resolveWorkspace(this.#ctx, folder), { recursive: true, force: true })));
     return { clean: true };
   }
@@ -170,7 +168,7 @@ export class CompilerServer {
     let close = false;
     switch (action) {
       case 'event': {
-        if (isComplilerEventType(subAction)) {
+        if (EventUtil.isComplilerEventType(subAction)) {
           this.#addListener(subAction, response);
         }
         return;
@@ -200,7 +198,7 @@ export class CompilerServer {
       if (event.type === 'state') {
         this.info.state = event.payload.state;
         if (event.payload.state === 'init' && event.payload.extra && 'processId' in event.payload.extra && typeof event.payload.extra.processId === 'number') {
-          if (this.info.mode === 'watch' && !this.info.compilerProcessId) {
+          if (this.info.watching && !this.info.compilerProcessId) {
             // Ensure we are killing in watch mode on first set
             await this.#handle.compiler.kill();
           }