@travetto/compiler 3.4.4 → 4.0.0-rc.1

package/src/state.ts

@@ -3,9 +3,10 @@ import ts from 'typescript';
 import { path, ManifestModuleUtil, ManifestModule, ManifestRoot, ManifestIndex } from '@travetto/manifest';
 import { TransformerManager } from '@travetto/transformer';
 
+import { CommonUtil } from '../support/util';
+
 import { CompilerUtil } from './util';
 import { CompileStateEntry } from './types';
-import { CommonUtil } from '../support/util';
 
 function folderMapper(root: string, prefix: string): { dir: string, translate: (val: string) => string } {
   let matched: string = '~~';
@@ -26,7 +27,7 @@ export class CompilerState implements ts.CompilerHost {
   private constructor() { }
 
   #rootDir: string;
-  #inputPathToSource: (file: string) => string;
+  #inputPathToSourcePath: (file: string) => string;
   #outputPath: string;
   #inputFiles = new Set<string>();
   #inputDirectoryToSource = new Map<string, string>();
@@ -36,6 +37,7 @@ export class CompilerState implements ts.CompilerHost {
 
   #sourceContents = new Map<string, string | undefined>();
   #sourceFileObjects = new Map<string, ts.SourceFile>();
+  #sourceHashes = new Map<string, number>();
 
   #manifestIndex: ManifestIndex;
   #manifest: ManifestRoot;
@@ -43,14 +45,18 @@ export class CompilerState implements ts.CompilerHost {
   #transformerManager: TransformerManager;
   #compilerOptions: ts.CompilerOptions;
 
+  #readFile(inputFile: string): string | undefined {
+    return ts.sys.readFile(this.#inputToEntry.get(inputFile)?.sourceFile ?? this.#inputPathToSourcePath(inputFile));
+  }
+
   async init(idx: ManifestIndex): Promise<this> {
     this.#manifestIndex = idx;
     this.#manifest = idx.manifest;
-    const mapper = folderMapper(this.#manifest.workspacePath, '##');
+    const mapper = folderMapper(this.#manifest.workspace.path, '##');
     this.#rootDir = mapper.dir;
-    this.#inputPathToSource = mapper.translate;
+    this.#inputPathToSourcePath = mapper.translate;
 
-    this.#outputPath = path.resolve(this.#manifest.workspacePath, this.#manifest.outputFolder);
+    this.#outputPath = path.resolve(this.#manifest.workspace.path, this.#manifest.build.outputFolder);
     this.#modules = Object.values(this.#manifest.modules);
 
     // Register all inputs
@@ -91,11 +97,11 @@ export class CompilerState implements ts.CompilerHost {
   }
 
   resolveOutputFile(file: string): string {
-    return path.resolve(this.#manifest.workspacePath, this.#manifest.outputFolder, file);
+    return path.resolve(this.#manifest.workspace.path, this.#manifest.build.outputFolder, file);
   }
 
   getArbitraryInputFile(): string {
-    return this.getBySource(this.#manifestIndex.getModule('@travetto/manifest')!.files.src[0].sourceFile)!.input;
+    return this.getBySource(this.#manifestIndex.getModule('@travetto/manifest')!.files.src[0].sourceFile)!.inputFile;
   }
 
   createProgram(oldProgram?: ts.Program): ts.Program {
@@ -107,9 +113,9 @@ export class CompilerState implements ts.CompilerHost {
   writeInputFile(program: ts.Program, inputFile: string): ts.EmitResult | undefined | void {
     switch (ManifestModuleUtil.getFileType(inputFile)) {
       case 'package-json':
-        return this.writeFile(this.#inputToEntry.get(inputFile)!.output!, this.readFile(inputFile)!, false);
+        return this.writeFile(this.#inputToEntry.get(inputFile)!.outputFile!, this.readFile(inputFile)!, false);
       case 'js':
-        return this.writeFile(this.#inputToEntry.get(inputFile)!.output!, ts.transpile(this.readFile(inputFile)!, this.#compilerOptions), false);
+        return this.writeFile(this.#inputToEntry.get(inputFile)!.outputFile!, ts.transpile(this.readFile(inputFile)!, this.#compilerOptions), false);
       case 'ts':
         return program.emit(
           program.getSourceFile(inputFile)!,
@@ -125,7 +131,7 @@ export class CompilerState implements ts.CompilerHost {
 
   registerInput(module: ManifestModule, moduleFile: string): CompileStateEntry {
     const relativeInput = `${module.outputFolder}/${moduleFile}`;
-    const sourceFile = path.resolve(this.#manifest.workspacePath, module.sourceFolder, moduleFile);
+    const sourceFile = path.resolve(this.#manifest.workspace.path, module.sourceFolder, moduleFile);
     const sourceFolder = path.dirname(sourceFile);
     const inputFile = path.resolve(this.#rootDir, relativeInput); // Ensure input is isolated
     const inputFolder = path.dirname(inputFile);
@@ -134,7 +140,7 @@ export class CompilerState implements ts.CompilerHost {
       undefined :
       path.resolve(this.#outputPath, ManifestModuleUtil.sourceToOutputExt(relativeInput));
 
-    const entry = { source: sourceFile, input: inputFile, output: outputFile, module, relativeInput };
+    const entry = { sourceFile, inputFile, outputFile, module };
 
     this.#inputToEntry.set(inputFile, entry);
     this.#sourceToEntry.set(sourceFile, entry);
@@ -145,23 +151,37 @@ export class CompilerState implements ts.CompilerHost {
     }
 
     this.#inputFiles.add(inputFile);
-
+    this.#sourceHashes.set(sourceFile, -1); // Unknown
     return entry;
   }
 
-  removeInput(inputFile: string): void {
-    const { output, source } = this.#inputToEntry.get(inputFile)!;
-    if (output) {
-      this.#outputToEntry.delete(output);
+  checkIfSourceChanged(inputFile: string): boolean {
+    const contents = this.#readFile(inputFile);
+    const prevHash = this.#sourceHashes.get(inputFile);
+    if (!contents || (contents.length === 0 && prevHash)) {
+      return false; // Ignore empty file
     }
-    this.#sourceToEntry.delete(source);
-    this.#inputToEntry.delete(inputFile);
-    this.#inputFiles.delete(inputFile);
+    const currentHash = CompilerUtil.naiveHash(contents);
+    const changed = prevHash !== currentHash;
+    if (changed) {
+      this.#sourceHashes.set(inputFile, currentHash);
+      this.#sourceContents.set(inputFile, contents);
+      this.#sourceFileObjects.delete(inputFile);
+    }
+    return changed;
   }
 
-  resetInputSource(inputFile: string): void {
+  removeInput(inputFile: string): void {
+    const { outputFile, sourceFile } = this.#inputToEntry.get(inputFile)!;
+    if (outputFile) {
+      this.#outputToEntry.delete(outputFile);
+    }
     this.#sourceFileObjects.delete(inputFile);
     this.#sourceContents.delete(inputFile);
+    this.#sourceHashes.delete(inputFile);
+    this.#sourceToEntry.delete(sourceFile);
+    this.#inputToEntry.delete(inputFile);
+    this.#inputFiles.delete(inputFile);
   }
 
   getAllFiles(): string[] {
@@ -177,11 +197,11 @@ export class CompilerState implements ts.CompilerHost {
   getDefaultLibLocation(): string { return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions)); }
 
   fileExists(inputFile: string): boolean {
-    return this.#inputToEntry.has(inputFile) || ts.sys.fileExists(this.#inputPathToSource(inputFile));
+    return this.#inputToEntry.has(inputFile) || ts.sys.fileExists(this.#inputPathToSourcePath(inputFile));
   }
 
   directoryExists(inputDir: string): boolean {
-    return this.#inputDirectoryToSource.has(inputDir) || ts.sys.directoryExists(this.#inputPathToSource(inputDir));
+    return this.#inputDirectoryToSource.has(inputDir) || ts.sys.directoryExists(this.#inputPathToSourcePath(inputDir));
   }
 
   writeFile(
@@ -203,9 +223,7 @@ export class CompilerState implements ts.CompilerHost {
   }
 
   readFile(inputFile: string): string | undefined {
-    const res = this.#sourceContents.get(inputFile) ?? ts.sys.readFile(
-      this.#inputToEntry.get(inputFile)?.source ?? this.#inputPathToSource(inputFile)
-    );
+    const res = this.#sourceContents.get(inputFile) ?? this.#readFile(inputFile);
     this.#sourceContents.set(inputFile, res);
     return res;
   }

package/src/types.ts

@@ -5,4 +5,4 @@ import type { ManifestModule } from '@travetto/manifest';
 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 CompileStateEntry = { sourceFile: string, inputFile: string, outputFile?: string, module: ManifestModule };

package/src/util.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 
 import { ManifestContext, ManifestModuleFileType, ManifestModuleUtil, ManifestRoot, Package, path } from '@travetto/manifest';
 
-type OutputToSource = (outputFile: string) => ({ source: string } | undefined);
+type OutputToSource = (outputFile: string) => ({ sourceFile: string } | undefined);
 
 const nativeCwd = process.cwd();
 
@@ -31,12 +31,12 @@ export class CompilerUtil {
    */
   static rewriteSourceMap(ctx: ManifestContext, text: string, outputToSource: OutputToSource): string {
     const data: { sourceRoot?: string, sources: string[] } = JSON.parse(text);
-    const output = ManifestModuleUtil.sourceToOutputExt(path.resolve(ctx.workspacePath, ctx.outputFolder, data.sources[0]));
-    const { source: file } = outputToSource(output) ?? {};
+    const output = ManifestModuleUtil.sourceToOutputExt(path.resolve(ctx.workspace.path, ctx.build.outputFolder, data.sources[0]));
+    const { sourceFile } = outputToSource(output) ?? {};
 
-    if (file) {
+    if (sourceFile) {
       delete data.sourceRoot;
-      data.sources = [file];
+      data.sources = [sourceFile];
       text = JSON.stringify(data);
     }
     return text;
@@ -81,7 +81,7 @@ export class CompilerUtil {
     if (pkg.main) {
       pkg.main = ManifestModuleUtil.sourceToOutputExt(pkg.main);
     }
-    pkg.type = manifest.moduleType;
+    pkg.type = manifest.workspace.type;
     for (const key of ['devDependencies', 'dependencies', 'peerDependencies'] as const) {
       if (key in pkg) {
         for (const dep of Object.keys(pkg[key] ?? {})) {

package/src/watch.ts

@@ -1,95 +1,96 @@
-import { readFileSync } from 'fs';
-import { setMaxListeners } from 'events';
-
-import {
-  ManifestContext, ManifestModuleUtil, ManifestUtil, ManifestModuleFolderType, ManifestModuleFileType,
-  path, ManifestModule,
-} from '@travetto/manifest';
-import { getManifestContext } from '@travetto/manifest/bin/context';
+import { ManifestContext, ManifestModuleUtil, ManifestUtil, RuntimeIndex, path } from '@travetto/manifest';
 
 import type { CompileStateEntry } from './types';
 import { CompilerState } from './state';
 import { CompilerUtil } from './util';
 
-import { WatchEvent, fileWatchEvents } from './internal/watch-core';
+import { AsyncQueue } from '../support/queue';
 
-type DirtyFile = { modFolder: string, mod: string, remove?: boolean, moduleFile: string, folderKey: ManifestModuleFolderType, type: ManifestModuleFileType };
+type WatchAction = 'create' | 'update' | 'delete';
+type WatchEvent = { action: WatchAction, file: string };
+type CompilerWatchEvent = WatchEvent & { entry: CompileStateEntry };
 
 /**
  * Watch support, based on compiler state and manifest details
  */
 export class CompilerWatcher {
+  #state: CompilerState;
+  #signal: AbortSignal;
 
-  /**
-   * Watch state
-   * @param state
-   * @returns
-   */
-  static watch(state: CompilerState): AsyncIterable<WatchEvent<{ entry: CompileStateEntry }>> {
-    return new CompilerWatcher(state).watchChanges();
+  constructor(state: CompilerState, signal: AbortSignal) {
+    this.#state = state;
+    this.#signal = signal;
   }
 
-  #sourceHashes = new Map<string, number>();
-  #manifestContexts = new Map<string, ManifestContext>();
-  #dirtyFiles: DirtyFile[] = [];
-  #state: CompilerState;
+  /** Watch files */
+  async * #watchFolder(rootPath: string): AsyncIterable<WatchEvent> {
+    const q = new AsyncQueue<WatchEvent>(this.#signal);
+    const lib = await import('@parcel/watcher');
 
-  constructor(state: CompilerState) {
-    this.#state = state;
+    const cleanup = await lib.subscribe(rootPath, (err, events) => {
+      if (err) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        q.throw(err instanceof Error ? err : new Error((err as Error).message));
+        return;
+      }
+      for (const ev of events) {
+        q.add({ action: ev.type, file: path.toPosix(ev.path) });
+      }
+    }, {
+      // TODO: Read .gitignore?
+      ignore: [
+        'node_modules', '**/node_modules', '.git', '**/.git',
+        `${this.#state.manifest.build.outputFolder}/node_modules/**`,
+        `${this.#state.manifest.build.compilerFolder}/node_modules/**`,
+        `${this.#state.manifest.build.toolFolder}/**`
+      ]
+    });
+
+    if (this.#signal.aborted) { // If already aborted, can happen async
+      cleanup.unsubscribe();
+      return;
+    }
+
+    this.#signal.addEventListener('abort', () => cleanup.unsubscribe());
+
+    yield* q;
   }
 
-  async #rebuildManifestsIfNeeded(): Promise<void> {
-    if (!this.#dirtyFiles.length) {
+  async #rebuildManifestsIfNeeded(event: CompilerWatchEvent, moduleFile: string): Promise<void> {
+    if (!event.entry.outputFile || event.action === 'update') {
       return;
     }
-    const mods = [...new Set(this.#dirtyFiles.map(x => x.modFolder))];
-    const contexts = await Promise.all(mods.map(async folder => {
-      if (!this.#manifestContexts.has(folder)) {
-        const ctx = await getManifestContext(folder);
-        this.#manifestContexts.set(folder, ctx);
-      }
-      return this.#manifestContexts.get(folder)!;
-    }));
 
-    const files = this.#dirtyFiles.slice(0);
-    this.#dirtyFiles = [];
+    const toUpdate: ManifestContext[] = RuntimeIndex.getDependentModules(event.entry.module.name, 'parents')
+      .map(el => ManifestUtil.getModuleContext(this.#state.manifest, el.sourceFolder));
 
-    for (const ctx of [...contexts, this.#state.manifest]) {
+    toUpdate.push(this.#state.manifest);
+
+    const mod = event.entry.module;
+    const folderKey = ManifestModuleUtil.getFolderKey(moduleFile);
+    const fileType = ManifestModuleUtil.getFileType(moduleFile);
+
+    for (const ctx of toUpdate) {
       const newManifest = await ManifestUtil.buildManifest(ctx);
-      for (const file of files) {
-        if (file.mod in newManifest.modules) {
-          const modFiles = newManifest.modules[file.mod].files[file.folderKey] ??= [];
-          const idx = modFiles.findIndex(x => x[0] === file.moduleFile);
-
-          if (!file.remove && idx < 0) {
-            modFiles.push([file.moduleFile, file.type, Date.now()]);
-          } else if (idx >= 0) {
-            if (file.remove) {
-              modFiles.splice(idx, 1);
-            } else {
-              modFiles[idx] = [file.moduleFile, file.type, Date.now()];
-            }
+      if (mod.name in newManifest.modules) {
+        const modFiles = newManifest.modules[mod.name].files[folderKey] ??= [];
+        const idx = modFiles.findIndex(x => x[0] === moduleFile);
+
+        if (event.action === 'create' && idx < 0) {
+          modFiles.push([moduleFile, fileType, Date.now()]);
+        } else if (idx >= 0) {
+          if (event.action === 'delete') {
+            modFiles.splice(idx, 1);
+          } else {
+            modFiles[idx] = [moduleFile, fileType, Date.now()];
           }
         }
       }
-      await ManifestUtil.writeManifest(ctx, newManifest);
+      await ManifestUtil.writeManifest(newManifest);
     }
-    // Reindex
-    this.#state.manifestIndex.init(this.#state.manifestIndex.manifestFile);
-  }
-
-  #getModuleMap(): Record<string, ManifestModule> {
-    return Object.fromEntries(
-      Object.values(this.#state.manifest.modules).map(x => [path.resolve(this.#state.manifest.workspacePath, x.sourceFolder), x])
-    );
-  }
 
-  #addDirtyFile(mod: ManifestModule, folder: string, moduleFile: string, remove = false): void {
-    this.#dirtyFiles.push({
-      mod: mod.name, modFolder: folder, remove, moduleFile,
-      folderKey: ManifestModuleUtil.getFolderKey(moduleFile),
-      type: ManifestModuleUtil.getFileType(moduleFile),
-    });
+    // Reindex at workspace root
+    this.#state.manifestIndex.init(ManifestUtil.getManifestLocation(this.#state.manifest));
   }
 
   /**
@@ -98,67 +99,56 @@ export class CompilerWatcher {
    * @param handler
    * @returns
    */
-  async * watchChanges(): AsyncIterable<WatchEvent<{ entry: CompileStateEntry }>> {
-    const mods = this.#getModuleMap();
-    const ctrl = new AbortController();
-    setMaxListeners(1000, ctrl.signal);
-
-    const modules = [...this.#state.manifestIndex.getModuleList('all')].map(x => this.#state.manifestIndex.getModule(x)!);
-
-    const stream = fileWatchEvents(this.#state.manifest, modules, ctrl.signal);
-    for await (const ev of stream) {
+  async * watchChanges(): AsyncIterable<CompilerWatchEvent> {
+    if (this.#signal.aborted) {
+      return;
+    }
 
-      if (ev.action === 'reset') {
-        yield ev;
-        ctrl.abort();
-        return;
+    const manifest = this.#state.manifest;
+    const ROOT_LOCK = path.resolve(manifest.workspace.path, 'package-lock.json');
+    const ROOT_PKG = path.resolve(manifest.workspace.path, 'package.json');
+    const OUTPUT_PATH = path.resolve(manifest.workspace.path, manifest.build.outputFolder);
+    const COMPILER_PATH = path.resolve(manifest.workspace.path, manifest.build.compilerFolder);
+
+    for await (const ev of this.#watchFolder(this.#state.manifest.workspace.path)) {
+      const { action, file: sourceFile } = ev;
+
+      if (
+        sourceFile === ROOT_LOCK ||
+        sourceFile === ROOT_PKG ||
+        (action === 'delete' && (sourceFile === OUTPUT_PATH || sourceFile === COMPILER_PATH))
+      ) {
+        throw new Error('RESET');
       }
 
-      const { action, file: sourceFile, folder } = ev;
-      const mod = mods[folder];
-      const moduleFile = mod.sourceFolder ?
-        (sourceFile.includes(mod.sourceFolder) ? sourceFile.split(`${mod.sourceFolder}/`)[1] : sourceFile) :
-        sourceFile.replace(`${this.#state.manifest.workspacePath}/`, '');
+      const fileType = ManifestModuleUtil.getFileType(sourceFile);
+      if (!CompilerUtil.validFile(fileType)) {
+        continue;
+      }
 
       let entry = this.#state.getBySource(sourceFile);
 
-      switch (action) {
-        case 'create': {
-          const fileType = ManifestModuleUtil.getFileType(moduleFile);
-          this.#addDirtyFile(mod, folder, moduleFile);
-          if (CompilerUtil.validFile(fileType)) {
-            const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
-            entry = this.#state.registerInput(mod, moduleFile);
-            this.#sourceHashes.set(sourceFile, hash);
-          }
-          break;
-        }
-        case 'update': {
-          if (entry) {
-            const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
-            if (this.#sourceHashes.get(sourceFile) !== hash) {
-              this.#state.resetInputSource(entry.input);
-              this.#sourceHashes.set(sourceFile, hash);
-            } else {
-              entry = undefined;
-            }
-          }
-          break;
-        }
-        case 'delete': {
-          if (entry) {
-            this.#state.removeInput(entry.input);
-            if (entry.output) {
-              this.#addDirtyFile(mod, folder, moduleFile, true);
-            }
-          }
-        }
+      const mod = entry?.module ?? this.#state.manifestIndex.findModuleForArbitraryFile(sourceFile);
+      if (!mod) { // Unknown module
+        continue;
       }
 
-      if (entry) {
-        await this.#rebuildManifestsIfNeeded();
-        yield { action, file: entry.source, folder, entry };
+      const modRoot = mod.sourceFolder || this.#state.manifest.workspace.path;
+      const moduleFile = sourceFile.includes(modRoot) ? sourceFile.split(`${modRoot}/`)[1] : sourceFile;
+
+      if (action === 'create') {
+        entry = this.#state.registerInput(mod, moduleFile);
+      } else if (!entry) {
+        continue;
+      } else if (action === 'update' && !this.#state.checkIfSourceChanged(entry.inputFile)) {
+        continue;
+      } else if (action === 'delete') {
+        this.#state.removeInput(entry.inputFile);
       }
+
+      const result: CompilerWatchEvent = { action, file: entry.sourceFile, entry };
+      await this.#rebuildManifestsIfNeeded(result, moduleFile);
+      yield result;
     }
   }
 }

package/support/entry.trvc.ts

@@ -1,73 +1,103 @@
-import fs from 'fs/promises';
-import path from 'path';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 
 import type { ManifestContext } from '@travetto/manifest';
 
+import type { CompilerLogLevel, CompilerMode, CompilerServerInfo } from './types';
 import { LogUtil } from './log';
+import { CommonUtil } from './util';
 import { CompilerSetup } from './setup';
 import { CompilerServer } from './server/server';
 import { CompilerRunner } from './server/runner';
-import type { CompilerOp, CompilerServerInfo } from './types';
-import { CompilerClientUtil } from './server/client';
-import { CommonUtil } from './util';
+import { CompilerClient } from './server/client';
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export const main = (root: ManifestContext, ctx: ManifestContext) => {
+export const main = (ctx: ManifestContext) => {
+  const log = LogUtil.logger('client.main');
+  const client = new CompilerClient(ctx, log);
+  const buildFolders = [ctx.build.outputFolder, ctx.build.compilerFolder];
+
+  /** Main entry point for compilation */
+  const compile = async (op: CompilerMode, logLevel: CompilerLogLevel, setupOnly = false): Promise<void> => {
+    LogUtil.initLogs(ctx, logLevel ?? 'info');
+
+    const server = await new CompilerServer(ctx, op).listen();
+
+    // Wait for build to be ready
+    if (server) {
+      log('debug', 'Start Server');
+      await server.processEvents(async function* (signal) {
+        const changed = await CompilerSetup.setup(ctx);
+        if (!setupOnly) {
+          yield* CompilerRunner.runProcess(ctx, changed, op, signal);
+        }
+      });
+      log('debug', 'End Server');
+    } else {
+      log('info', 'Server already running, waiting for initial compile to complete');
+      const ctrl = new AbortController();
+      LogUtil.consumeProgressEvents(() => client.fetchEvents('progress', { until: ev => !!ev.complete, signal: ctrl.signal }));
+      await client.waitForState(['compile-end', 'watch-start'], 'Successfully built');
+      ctrl.abort();
+    }
+  };
+
   const ops = {
     /** Stop the server */
     async stop(): Promise<void> {
-      if (await fetch(`${ctx.compilerUrl}/stop`).then(v => v.ok, () => false)) {
-        console.log(`Stopped server ${ctx.workspacePath}: [${ctx.compilerUrl}]`);
+      if (await client.stop()) {
+        console.log(`Stopped server ${ctx.workspace.path}: ${client}`);
       } else {
-        console.log(`Server not running ${ctx.workspacePath}: [${ctx.compilerUrl}]`);
+        console.log(`Server not running ${ctx.workspace.path}: ${client}`);
       }
     },
 
+    /** Restart the server */
+    async restart(): Promise<void> { await client.stop().then(() => ops.watch()); },
+
     /** Get server info */
-    info(): Promise<CompilerServerInfo> {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return fetch(ctx.compilerUrl).then(v => v.json(), () => ({ state: 'Server not running' })) as Promise<CompilerServerInfo>;
-    },
+    info: (): Promise<CompilerServerInfo | undefined> => client.info(),
 
     /** Clean the server */
     async clean(): Promise<void> {
-      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);
+      if (await client.clean()) {
+        return console.log(`Clean triggered ${ctx.workspace.path}:`, buildFolders);
+      } else {
+        await Promise.all(buildFolders.map(f => fs.rm(path.resolve(ctx.workspace.path, f), { force: true, recursive: true })));
+        return console.log(`Cleaned ${ctx.workspace.path}:`, buildFolders);
+      }
+    },
+
+    /** Stream events */
+    events: async (type: string, handler: (ev: unknown) => unknown): Promise<void> => {
+      LogUtil.initLogs(ctx, 'error');
+      if (type === 'change' || type === 'log' || type === 'progress' || type === 'state') {
+        for await (const ev of client.fetchEvents(type)) { await handler(ev); }
       } 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);
+        throw new Error(`Unknown event type: ${type}`);
       }
     },
 
-    /** Main entry point for compilation */
-    async compile(op: CompilerOp, setupOnly = false): Promise<(mod: string) => Promise<unknown>> {
-      LogUtil.initLogs(ctx, op === 'run' ? 'error' : 'info');
+    /** Build the project */
+    async build(): Promise<void> { await compile('build', 'info'); },
 
-      const server = await new CompilerServer(root, op).listen();
+    /** Build and watch the project */
+    async watch(): Promise<void> { await compile('watch', 'info'); },
 
-      // Wait for build to be ready
-      if (server) {
-        await server.processEvents(async function* (signal) {
-          const { changed, manifest } = await CompilerSetup.setup(root);
-          if (!setupOnly) {
-            yield* CompilerRunner.runProcess(root, manifest, changed, op, signal);
-          } else {
-            yield* [];
-          }
-        });
-      } else {
-        await CompilerClientUtil.waitForBuild(root);
+    /** Build and return a loader */
+    async getLoader(): Promise<(mod: string) => Promise<unknown>> {
+      // Short circuit if we can
+      if (!(await client.isWatching())) {
+        await compile('build', 'error');
       }
       return CommonUtil.moduleLoader(ctx);
     },
 
     /** Manifest entry point */
     async manifest(output?: string, prod?: boolean): Promise<void> {
-      await ops.compile('run', true);
+      await compile('build', 'error', true);
       await CompilerSetup.exportManifest(ctx, output, prod); return;
     }
   };
   return ops;
-};
-
+};