@travetto/compiler 3.0.0-rc.14 → 3.0.0-rc.16

package/support/launcher.ts

@@ -2,7 +2,10 @@ import fs from 'fs/promises';
 import path from 'path';
 
 import type { ManifestContext } from '@travetto/manifest';
-import { TranspileUtil } from './transpile';
+
+import { TranspileUtil, CompileResult } from './transpile';
+import { LockManager } from './lock';
+import { LogUtil } from './log';
 
 const SOURCE_SEED = ['package.json', 'index.ts', '__index__.ts', 'src', 'support', 'bin'];
 const PRECOMPILE_MODS = ['@travetto/terminal', '@travetto/manifest', '@travetto/transformer', '@travetto/compiler'];
@@ -10,59 +13,31 @@ const PRECOMPILE_MODS = ['@travetto/terminal', '@travetto/manifest', '@travetto/
 const importManifest = (ctx: ManifestContext): Promise<typeof import('@travetto/manifest')> =>
   import(path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', '@travetto/manifest/__index__.js'));
 
-/**
- * Recompile folder if stale
- */
-async function compileIfStale(ctx: ManifestContext, scope: string, mod: string, seed: string[]): Promise<string[]> {
-  const files = await TranspileUtil.getModuleSources(ctx, mod, seed);
-  const changes = files.filter(x => x.stale).map(x => x.input);
-  const out: string[] = [];
-
-  try {
-    await TranspileUtil.withLogger(scope, async log => {
-      if (files.some(f => f.stale)) {
-        log('debug', 'Starting');
-        for (const file of files.filter(x => x.stale)) {
-          await TranspileUtil.transpileFile(ctx, file.input, file.output);
-        }
-        if (changes.length) {
-          out.push(...changes.map(x => `${mod}/${x}`));
-          log('debug', `Source changed: ${changes.join(', ')}`);
-        }
-        log('debug', 'Completed');
-      } else {
-        log('debug', 'Skipped');
-      }
-    }, false, [mod]);
-  } catch (err) {
-    console.error(err);
-  }
-  return out;
-}
-
 /**
  * Run the compiler
  */
-async function compile(ctx: ManifestContext, op?: 'watch' | 'build'): Promise<void> {
+async function compile(ctx: ManifestContext, op: 'watch' | 'build' | undefined, onMessage: (msg: unknown) => void): Promise<CompileResult> {
   let changes = 0;
 
-  await TranspileUtil.withLogger('precompile', async () => {
+  await LogUtil.withLogger('precompile', async () => {
     for (const mod of PRECOMPILE_MODS) {
-      changes += (await compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
+      changes += (await TranspileUtil.compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
     }
   });
 
-  const { ManifestUtil, ManifestDeltaUtil } = await importManifest(ctx);
+  const { ManifestUtil, ManifestDeltaUtil, PackageUtil } = await importManifest(ctx);
 
-  const manifest = await TranspileUtil.withLogger('manifest', async () => ManifestUtil.buildManifest(ctx));
+  PackageUtil.clearCache();
 
-  await TranspileUtil.withLogger('transformers', async () => {
+  const manifest = await LogUtil.withLogger('manifest', async () => ManifestUtil.buildManifest(ctx));
+
+  await LogUtil.withLogger('transformers', async () => {
     for (const mod of Object.values(manifest.modules).filter(m => m.files.$transformer?.length)) {
-      changes += (await compileIfStale(ctx, 'transformers', mod.name, ['package.json', ...mod.files.$transformer!.map(x => x[0])])).length;
+      changes += (await TranspileUtil.compileIfStale(ctx, 'transformers', mod.name, ['package.json', ...mod.files.$transformer!.map(x => x[0])])).length;
     }
   });
 
-  const delta = await TranspileUtil.withLogger('delta', async log => {
+  const delta = await LogUtil.withLogger('delta', async log => {
     if (changes) {
       log('debug', 'Skipping, everything changed');
       return [{ type: 'changed', file: '*', module: ctx.mainModule } as const];
@@ -72,14 +47,14 @@ async function compile(ctx: ManifestContext, op?: 'watch' | 'build'): Promise<vo
   });
 
   if (changes) {
-    await TranspileUtil.withLogger('reset', async log => {
+    await LogUtil.withLogger('reset', async log => {
       await fs.rm(path.resolve(ctx.workspacePath, ctx.outputFolder), { recursive: true, force: true });
       log('info', 'Clearing output due to compiler changes');
     }, false);
   }
 
   // Write manifest
-  await TranspileUtil.withLogger('manifest', async log => {
+  await LogUtil.withLogger('manifest', async log => {
     await ManifestUtil.writeManifest(ctx, manifest);
     log('debug', `Wrote manifest ${ctx.mainModule}`);
 
@@ -91,19 +66,21 @@ async function compile(ctx: ManifestContext, op?: 'watch' | 'build'): Promise<vo
         await ManifestUtil.rewriteManifest(path.resolve(ctx.workspacePath, mod.sourceFolder));
         names.push(mod.name);
       }
-      log('debug', `Changes triggered ${delta.map(x => `${x.type}:${x.module}:${x.file}`)}`);
-      log('debug', `Rewrote monorepo manifests [changes=${delta.length}] ${names.join(', ')}`);
+      log('debug', `Changes triggered ${delta.slice(0, 10).map(x => `${x.type}:${x.module}:${x.file}`)}`);
+      log('debug', `Rewrote monorepo manifests [changes=${delta.length}] ${names.slice(0, 10).join(', ')}`);
     }
   });
 
-  await TranspileUtil.withLogger('compile', async log => {
+  return await LogUtil.withLogger('compile', async log => {
     const changed = delta.filter(x => x.type === 'added' || x.type === 'changed');
-    log('debug', `Started action=${op} changed=${changed.map(x => `${x.module}/${x.file}`)}`);
+    log('debug', `Started action=${op} changed=${changed.slice(0, 10).map(x => `${x.module}/${x.file}`)}`);
     if (changed.length || op === 'watch') {
-      await TranspileUtil.runCompiler(ctx, manifest, changed, op === 'watch');
+      const res = await TranspileUtil.runCompiler(ctx, manifest, changed, op === 'watch', onMessage);
       log('debug', 'Finished');
+      return res;
     } else {
       log('debug', 'Skipped');
+      return 'skipped';
     }
   }, false);
 }
@@ -113,26 +90,15 @@ async function compile(ctx: ManifestContext, op?: 'watch' | 'build'): Promise<vo
  */
 async function exportManifest(ctx: ManifestContext, output?: string, env = 'dev'): Promise<void> {
   const { ManifestUtil } = await importManifest(ctx);
-  const manifest = await ManifestUtil.buildManifest(ctx);
+  let manifest = await ManifestUtil.buildManifest(ctx);
 
   // If in prod mode, only include std modules
   if (/^prod/i.test(env)) {
-    manifest.modules = Object.fromEntries(
-      Object.values(manifest.modules)
-        .filter(x => x.profiles.includes('std'))
-        .map(m => [m.name, m])
-    );
-    // Mark output folder/workspace path as portable
-    manifest.outputFolder = '';
-    manifest.workspacePath = '';
+    manifest = ManifestUtil.createProductionManifest(manifest);
   }
   if (output) {
-    if (!output.endsWith('.json')) {
-      output = path.resolve(output, 'manifest.json');
-    }
-
-    await TranspileUtil.writeTextFile(output, JSON.stringify(manifest));
-    TranspileUtil.log('manifest', [], 'info', `Wrote manifest ${output}`);
+    output = await ManifestUtil.writeManifestToFile(output, manifest);
+    LogUtil.log('manifest', [], 'info', `Wrote manifest ${output}`);
   } else {
     console.log(JSON.stringify(manifest, null, 2));
   }
@@ -141,13 +107,27 @@ async function exportManifest(ctx: ManifestContext, output?: string, env = 'dev'
 /**
  * Launch
  */
-export async function launch(ctx: ManifestContext, op?: 'build' | 'watch' | 'manifest', args: (string | undefined)[] = []): Promise<void> {
-  if (op !== 'manifest') {
-    await compile(ctx, op);
+export async function launch(ctx: ManifestContext, root: ManifestContext, op?: 'build' | 'watch' | 'manifest', args: (string | undefined)[] = []): Promise<void> {
+  if (op !== 'manifest' && await LockManager.getCompileAction(root, op) === 'build') {
+    await LockManager.withLocks(root, async (acquire, release) => {
+      let action: CompileResult;
+      do {
+        acquire(op ?? 'build');
+        if (op === 'watch') {
+          acquire('build');
+        }
+        action = await compile(root, op, msg => {
+          switch (msg) {
+            case 'build-complete': release('build'); break;
+          }
+        });
+      } while (action === 'restart');
+    });
   }
+
   switch (op) {
     case 'manifest': return exportManifest(ctx, ...args);
-    case 'build': return TranspileUtil.log('build', [], 'info', 'Successfully built');
+    case 'build': return LogUtil.log('build', [], 'info', 'Successfully built');
     case undefined: {
       // TODO: Externalize somehow?
       const outputPath = path.resolve(ctx.workspacePath, ctx.outputFolder);

package/support/lock-pinger.ts

@@ -0,0 +1,25 @@
+import { workerData, parentPort } from 'worker_threads';
+import { utimesSync } from 'fs';
+
+const data: { files: string[], interval: number } = workerData;
+const files = data.files;
+
+const interval = setInterval(() => {
+  const now = Date.now() / 1000;
+  for (const file of files) {
+    try {
+      utimesSync(file, now, now);
+    } catch { }
+  }
+}, data.interval);
+
+
+parentPort?.on('message', val => {
+  if (val === 'stop') {
+    files.splice(0, files.length);
+    clearInterval(interval);
+  } else if (val && typeof val === 'object' && 'files' in val && Array.isArray(val.files)) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    files.splice(0, files.length, ...val.files as string[]);
+  }
+});

package/support/lock.ts

@@ -0,0 +1,237 @@
+import { Stats, watchFile, unwatchFile, rmSync, mkdirSync, writeFileSync, existsSync } from 'fs';
+import fs from 'fs/promises';
+import { Worker } from 'worker_threads';
+import path from 'path';
+
+import type { ManifestContext } from '@travetto/manifest';
+
+import { CompilerLogger, LogUtil } from './log';
+
+type LockStatus = 'complete' | 'stale';
+type LockDetails = {
+  pid: number | undefined;
+  file: string;
+};
+
+export type LockType = 'build' | 'watch';
+export type LockCompileAction = 'skip' | 'build';
+type LockAction = LockCompileAction | 'retry';
+
+const STALE_THRESHOLD = 1000;
+
+/**
+ * Manager for all lock activity
+ */
+export class LockManager {
+
+  /**
+   * Get the lock file name
+   */
+  static #getFileName(ctx: ManifestContext, type: LockType): string {
+    return path.resolve(ctx.workspacePath, ctx.toolFolder, `${type}.pid`);
+  }
+
+  /**
+   * Determine if the given stats are stale for modification time
+   */
+  static #isStale(stat?: Stats): boolean {
+    return !!stat && stat.mtimeMs < (Date.now() - STALE_THRESHOLD * 1.1);
+  }
+
+  /**
+   * Get the lock file details
+   */
+  static async #getDetails(ctx: ManifestContext, type: LockType): Promise<LockDetails> {
+    const file = this.#getFileName(ctx, type);
+    const stat = await fs.stat(file).catch(() => undefined);
+    const stale = this.#isStale(stat);
+    let pid: number | undefined;
+    if (stat) {
+      const content = await fs.readFile(file, 'utf8');
+      const filePid = parseInt(content, 10);
+      if (stale) {
+        LogUtil.log('lock', [], 'warn', `${type} file is stale: ${stat.mtimeMs} vs ${Date.now()}`);
+      } else {
+        pid = filePid;
+      }
+    }
+    return { pid, file };
+  }
+
+  /**
+   * Acquire the lock file, and register a cleanup on exit
+   */
+  static #acquireFile(ctx: ManifestContext, type: LockType): void {
+    const file = this.#getFileName(ctx, type);
+    mkdirSync(path.dirname(file), { recursive: true });
+    LogUtil.log('lock', [], 'debug', `Acquiring ${type}`);
+    writeFileSync(file, `${process.pid}`, 'utf8');
+  }
+
+  /**
+   * Release the lock file (i.e. deleting)
+   */
+  static #releaseFile(ctx: ManifestContext, type: LockType): void {
+    const file = this.#getFileName(ctx, type);
+    if (existsSync(file)) {
+      rmSync(file, { force: true });
+      LogUtil.log('lock', [], 'debug', `Releasing ${type}`);
+    }
+  }
+
+  /**
+   * Wait until a lock file is released, or it becomes stale
+   */
+  static async #waitForRelease(ctx: ManifestContext, type: LockType): Promise<LockStatus> {
+    const file = this.#getFileName(ctx, type);
+    let remove: (() => void) | undefined = undefined;
+
+    const prom = new Promise<LockStatus>(resolve => {
+      let timer: NodeJS.Timeout | undefined = undefined;
+      const handler = async (): Promise<void> => {
+        if (timer) {
+          clearTimeout(timer);
+        }
+        const stats = await fs.stat(file).catch(() => undefined);
+        if (!stats) {
+          resolve('complete');
+        } else if (this.#isStale(stats)) {
+          resolve('stale');
+        } else {
+          timer = setTimeout(handler, STALE_THRESHOLD * 1.1);
+        }
+      };
+
+      watchFile(file, handler);
+      handler();
+
+      remove = (): void => {
+        clearInterval(timer);
+        unwatchFile(file, handler);
+      };
+    });
+
+    return prom.finally(remove);
+  }
+
+  /**
+   * Read the watch lock file and determine its result, communicating with the user as necessary
+   */
+  static async #getWatchAction(ctx: ManifestContext, log: CompilerLogger, lockType: LockType | undefined, buildState: LockDetails): Promise<LockAction> {
+    const level = lockType ? 'info' : 'debug';
+    if (lockType === 'watch') {
+      log(level, 'Already running');
+      return 'skip';
+    } else {
+      if (buildState.pid) {
+        log('info', 'Already running, waiting for build to finish');
+        switch (await this.#waitForRelease(ctx, 'build')) {
+          case 'complete': {
+            log(level, 'Completed build');
+            return 'skip';
+          }
+          case 'stale': {
+            log(level, 'Became stale, retrying');
+            return 'retry';
+          }
+        }
+      } else {
+        log(level, 'Already running, and has built');
+        return 'skip';
+      }
+    }
+  }
+
+  /**
+   * Read the build lock file and determine its result, communicating with the user as necessary
+   */
+  static async #getBuildAction(ctx: ManifestContext, log: CompilerLogger, lockType: LockType | undefined): Promise<LockAction> {
+    const level = lockType ? 'info' : 'debug';
+    if (lockType === 'watch') {
+      log('info', 'Build already running, waiting to begin watch');
+      const res = await this.#waitForRelease(ctx, 'build');
+      log(level, `Finished with status of ${res}, retrying`);
+      return 'retry';
+    } else {
+      log('info', 'Already running, waiting for completion');
+      switch (await this.#waitForRelease(ctx, lockType ?? 'build')) {
+        case 'complete': {
+          log(level, 'Completed');
+          return 'skip';
+        }
+        case 'stale': {
+          log(level, 'Became stale, retrying');
+          return 'retry';
+        }
+      }
+    }
+  }
+
+  /**
+   * Run code with support for lock acquire and release
+   */
+  static async withLocks(ctx: ManifestContext, fn: (acquire: (type: LockType) => void, release: (type: LockType) => void) => Promise<unknown>): Promise<void> {
+    const activeLockTypes = new Set<LockType>();
+
+    const pinger = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', '@travetto/compiler/support/lock-pinger.js');
+    const worker = new Worker(pinger, {
+      workerData: {
+        interval: STALE_THRESHOLD,
+        files: []
+      }
+    });
+
+    const notify = (): void => worker.postMessage({ files: [...activeLockTypes].map(t => this.#getFileName(ctx, t)) });
+
+    const stop = (): void => {
+      worker.postMessage('stop');
+      for (const type of activeLockTypes) {
+        this.#releaseFile(ctx, type);
+      }
+      worker.terminate().then(() => { });
+    };
+
+    process.on('SIGINT', stop);
+    process.on('exit', stop);
+
+    try {
+      await new Promise(r => worker.on('online', r));
+      await fn(
+        type => {
+          if (!activeLockTypes.has(type)) {
+            activeLockTypes.add(type);
+            this.#acquireFile(ctx, type);
+            notify();
+          }
+        },
+        type => {
+          if (activeLockTypes.has(type)) {
+            activeLockTypes.delete(type);
+            this.#releaseFile(ctx, type);
+            notify();
+          }
+        }
+      );
+    } finally {
+      stop();
+    }
+  }
+
+  /**
+   * Reads the lock file states (build + watch) to determine what action should be taken for the compiler
+   */
+  static async getCompileAction(ctx: ManifestContext, lockType: LockType | undefined): Promise<LockCompileAction> {
+    let result: LockAction;
+    do {
+      result = 'build';
+      const buildState = await this.#getDetails(ctx, 'build');
+      const watchState = await this.#getDetails(ctx, 'watch');
+      if (watchState.pid) { // Existing watch operation
+        result = await LogUtil.withLogger('lock', log => this.#getWatchAction(ctx, log, lockType, buildState), true, ['watch', `pid=${watchState.pid}`]);
+      } else if (buildState.pid) { // Existing build operation
+        result = await LogUtil.withLogger('lock', log => this.#getBuildAction(ctx, log, lockType), true, ['build', `pid=${buildState.pid}`]);
+      }
+    } while (result === 'retry');
+    return result;
+  }
+}

package/support/log.ts

@@ -0,0 +1,31 @@
+export type CompilerLogEvent = [level: 'info' | 'debug' | 'warn', message: string];
+export type CompilerLogger = (...args: CompilerLogEvent) => void;
+export type WithLogger<T> = (log: CompilerLogger) => Promise<T>;
+
+const LEVELS = { warn: true, debug: /^debug$/.test(process.env.TRV_BUILD ?? ''), info: !/^warn$/.test(process.env.TRV_BUILD ?? '') };
+const SCOPE_MAX = 15;
+
+export class LogUtil {
+
+  /**
+   * Is object a log event
+   */
+  static isLogEvent = (o: unknown): o is CompilerLogEvent => o !== null && o !== undefined && Array.isArray(o);
+
+  /**
+   * Log message with filtering by level
+   */
+  static log(scope: string, args: string[], ...[level, msg]: CompilerLogEvent): void {
+    const message = msg.replaceAll(process.cwd(), '.');
+    LEVELS[level] && console.debug(new Date().toISOString(), `[${scope.padEnd(SCOPE_MAX, ' ')}]`, ...args, message);
+  }
+
+  /**
+   * With logger
+   */
+  static withLogger<T>(scope: string, op: WithLogger<T>, basic = true, args: string[] = []): Promise<T> {
+    const log = this.log.bind(null, scope, args);
+    basic && log('debug', 'Started');
+    return op(log).finally(() => basic && log('debug', 'Completed'));
+  }
+}

package/support/transpile.ts

@@ -6,43 +6,24 @@ import { createRequire } from 'module';
 
 import { DeltaEvent, ManifestContext, ManifestRoot, Package } from '@travetto/manifest';
 
-export type CompilerLogEvent = [level: 'info' | 'debug' | 'warn', message: string];
+import { LogUtil } from './log';
+
 type ModFile = { input: string, output: string, stale: boolean };
-type WithLogger<T> = (log: (...ev: CompilerLogEvent) => void) => Promise<T>;
+export type CompileResult = 'restart' | 'complete' | 'skipped';
 
 const OPT_CACHE: Record<string, import('typescript').CompilerOptions> = {};
 const SRC_REQ = createRequire(path.resolve('node_modules'));
-const LEVELS = { warn: true, debug: /^debug$/.test(process.env.TRV_BUILD ?? ''), info: !/^warn$/.test(process.env.TRV_BUILD ?? '') };
-const SCOPE_MAX = 15;
 const RECENT_STAT = (stat: { ctimeMs: number, mtimeMs: number }): number => Math.max(stat.ctimeMs, stat.mtimeMs);
-const IS_LOG_EV = (o: unknown): o is CompilerLogEvent => o !== null && o !== undefined && Array.isArray(o);
 
 /**
  * Transpile utilities for launching
  */
 export class TranspileUtil {
-  /**
-   * Log message with filtering by level
-   */
-  static log(scope: string, args: string[], ...[level, msg]: CompilerLogEvent): void {
-    const message = msg.replaceAll(process.cwd(), '.');
-    LEVELS[level] && console.debug(new Date().toISOString(), `[${scope.padEnd(SCOPE_MAX, ' ')}]`, ...args, message);
-  }
-
-  /**
-   * With logger
-   */
-  static withLogger<T>(scope: string, op: WithLogger<T>, basic = true, args: string[] = []): Promise<T> {
-    const log = this.log.bind(null, scope, args);
-    basic && log('debug', 'Started');
-    return op(log).finally(() => basic && log('debug', 'Completed'));
-  }
-
   /**
    * Write text file, and ensure folder exists
    */
   static writeTextFile = (file: string, content: string): Promise<void> =>
-    fs.mkdir(path.dirname(file), { recursive: true }).then(() => fs.writeFile(file, content));
+    fs.mkdir(path.dirname(file), { recursive: true }).then(() => fs.writeFile(file, content, 'utf8'));
 
   /**
    * Returns the compiler options
@@ -147,10 +128,40 @@ export class TranspileUtil {
     return out;
   }
 
+  /**
+ * Recompile folder if stale
+ */
+  static async compileIfStale(ctx: ManifestContext, scope: string, mod: string, seed: string[]): Promise<string[]> {
+    const files = await this.getModuleSources(ctx, mod, seed);
+    const changes = files.filter(x => x.stale).map(x => x.input);
+    const out: string[] = [];
+
+    try {
+      await LogUtil.withLogger(scope, async log => {
+        if (files.some(f => f.stale)) {
+          log('debug', 'Starting');
+          for (const file of files.filter(x => x.stale)) {
+            await this.transpileFile(ctx, file.input, file.output);
+          }
+          if (changes.length) {
+            out.push(...changes.map(x => `${mod}/${x}`));
+            log('debug', `Source changed: ${changes.join(', ')}`);
+          }
+          log('debug', 'Completed');
+        } else {
+          log('debug', 'Skipped');
+        }
+      }, false, [mod]);
+    } catch (err) {
+      console.error(err);
+    }
+    return out;
+  }
+
   /**
    * Run compiler
    */
-  static async runCompiler(ctx: ManifestContext, manifest: ManifestRoot, changed: DeltaEvent[], watch = false): Promise<void> {
+  static async runCompiler(ctx: ManifestContext, manifest: ManifestRoot, changed: DeltaEvent[], watch: boolean, onMessage: (msg: unknown) => void): Promise<CompileResult> {
     const compiler = path.resolve(ctx.workspacePath, ctx.compilerFolder);
     const main = path.resolve(compiler, 'node_modules', '@travetto/compiler/support/compiler-entry.js');
     const deltaFile = path.resolve(os.tmpdir(), `manifest-delta.${Date.now()}.${Math.random()}.json`);
@@ -159,18 +170,33 @@ export class TranspileUtil {
       path.resolve(manifest.workspacePath, manifest.modules[ev.module].sourceFolder, ev.file)
     );
 
-    await this.writeTextFile(deltaFile, changedFiles.join('\n'));
-
-    await this.withLogger('compiler-exec', log => new Promise((res, rej) =>
-      cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
-        env: {
-          ...process.env,
-          TRV_MANIFEST: path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule),
-        },
-        stdio: [0, 1, 2, 'ipc'],
-      })
-        .on('message', msg => IS_LOG_EV(msg) && log(...msg))
-        .on('exit', code => (code !== null && code > 0) ? rej() : res(null))
-    )).finally(() => fs.unlink(deltaFile));
+    let proc: cp.ChildProcess | undefined;
+
+    try {
+      await this.writeTextFile(deltaFile, changedFiles.join('\n'));
+
+      return await LogUtil.withLogger('compiler-exec', log => new Promise<CompileResult>((res, rej) => {
+        proc = cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
+          env: {
+            ...process.env,
+            TRV_MANIFEST: path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule),
+          },
+          stdio: [0, 1, 2, 'ipc'],
+        })
+          .on('message', msg => {
+            if (LogUtil.isLogEvent(msg)) {
+              log(...msg);
+            } else if (msg === 'restart') {
+              res(msg);
+            } else {
+              onMessage(msg);
+            }
+          })
+          .on('exit', code => (code !== null && code > 0) ? rej(new Error('Failed during compilation')) : res('complete'));
+      }));
+    } finally {
+      if (proc?.killed === false) { proc.kill('SIGKILL'); }
+      await fs.rm(deltaFile, { force: true });
+    }
   }
 }