@travetto/compiler 3.3.1 → 3.4.0-rc.0

package/support/launcher.ts

@@ -1,160 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-
-import type { ManifestContext } from '@travetto/manifest';
-
-import { TranspileUtil, CompileResult, BuildEvent } 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'];
-
-const importManifest = (ctx: ManifestContext): Promise<typeof import('@travetto/manifest')> =>
-  import(path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', '@travetto/manifest/__index__.js'));
-
-/**
- * Run the compiler
- */
-async function compile(ctx: ManifestContext, op: 'watch' | 'build' | undefined, onMessage: (msg: BuildEvent) => void): Promise<CompileResult> {
-  let changes = 0;
-
-  await LogUtil.withLogger('precompile', async () => {
-    for (const mod of PRECOMPILE_MODS) {
-      const count = (await TranspileUtil.compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
-      if (mod !== '@travetto/terminal') {
-        changes += count;
-      }
-    }
-  });
-
-  const { ManifestUtil, ManifestDeltaUtil, PackageUtil } = await importManifest(ctx);
-
-  PackageUtil.clearCache();
-
-  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 TranspileUtil.compileIfStale(ctx, 'transformers', mod.name, ['package.json', ...mod.files.$transformer!.map(x => x[0])])).length;
-    }
-  });
-
-  const delta = await LogUtil.withLogger('delta', async log => {
-    if (changes) {
-      log('debug', 'Skipping, everything changed');
-      return [{ type: 'changed', file: '*', module: ctx.mainModule } as const];
-    } else {
-      return ManifestDeltaUtil.produceDelta(ctx, manifest);
-    }
-  });
-
-  if (changes) {
-    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 LogUtil.withLogger('manifest', async log => {
-    await ManifestUtil.writeManifest(ctx, manifest);
-    log('debug', `Wrote manifest ${ctx.mainModule}`);
-
-    // Update all manifests
-    if (delta.length && ctx.monoRepo && !ctx.mainFolder) {
-      const names: string[] = [];
-      const mods = Object.values(manifest.modules).filter(x => x.local && x.name !== ctx.mainModule);
-      for (const mod of mods) {
-        await ManifestUtil.rewriteManifest(path.resolve(ctx.workspacePath, mod.sourceFolder));
-        names.push(mod.name);
-      }
-      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(', ')}`);
-    }
-  });
-
-  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.slice(0, 10).map(x => `${x.module}/${x.file}`)}`);
-    if (changed.length || 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);
-}
-
-/**
- * Export manifests
- */
-async function exportManifest(ctx: ManifestContext, output?: string, env = 'dev'): Promise<void> {
-  const { ManifestUtil } = await importManifest(ctx);
-  let manifest = await ManifestUtil.buildManifest(ctx);
-
-  // If in prod mode, only include std modules
-  if (/^prod/i.test(env)) {
-    manifest = ManifestUtil.createProductionManifest(manifest);
-  }
-  if (output) {
-    output = await ManifestUtil.writeManifestToFile(output, manifest);
-    LogUtil.log('manifest', [], 'info', `Wrote manifest ${output}`);
-  } else {
-    console.log(JSON.stringify(manifest, null, 2));
-  }
-}
-
-/**
- * Launch
- */
-export async function launch(ctx: ManifestContext, root: ManifestContext, op?: 'build' | 'watch' | 'manifest', args: (string | undefined)[] = []): Promise<void> {
-  // If quiet enabled, turn off all output by default
-  LogUtil.level = process.env.TRV_BUILD ?? (process.env.TRV_QUIET ? 'none' : (!op ? 'warn' : 'info'));
-
-  if (op !== 'manifest' && await LockManager.getCompileAction(root, op) === 'build') {
-
-    // Ready signal
-    if (process.send) {
-      process.send('ready');
-      process.on('disconnect', () => process.exit(0));
-    }
-
-    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.type) {
-            case 'complete': {
-              release('build');
-              break;
-            }
-          }
-        });
-      } while (action === 'restart');
-    });
-  }
-
-  // Disconnect for non-cli operations
-  if (op && process.send) {
-    process.disconnect();
-  }
-
-  switch (op) {
-    case 'manifest': return exportManifest(ctx, ...args);
-    case 'build': return LogUtil.log('build', [], 'info', 'Successfully built');
-    case undefined: {
-      // TODO: Externalize somehow?
-      const outputPath = path.resolve(ctx.workspacePath, ctx.outputFolder);
-      process.env.TRV_MANIFEST = path.resolve(outputPath, 'node_modules', ctx.mainModule);
-      const cliMain = path.join(outputPath, 'node_modules', '@travetto/cli/support/entry.cli.js');
-      return import(cliMain);
-    }
-  }
-}

package/support/lock-pinger.ts

@@ -1,25 +0,0 @@
-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

@@ -1,234 +0,0 @@
-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}.lock`);
-  }
-
-  /**
-   * 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 { pid: filePid } = JSON.parse(await fs.readFile(file, 'utf8'));
-      if (stale) {
-        LogUtil.log('lock', [], 'debug', `${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, JSON.stringify({ pid: 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 => {
-        clearTimeout(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> {
-    if (lockType === 'watch') {
-      log('info', 'Already running');
-      return 'skip';
-    } else {
-      if (buildState.pid) {
-        log('warn', 'Already running, waiting for build to finish');
-        switch (await this.#waitForRelease(ctx, 'build')) {
-          case 'complete': {
-            log('info', 'Completed build');
-            return 'skip';
-          }
-          case 'stale': {
-            log('info', 'Became stale, retrying');
-            return 'retry';
-          }
-        }
-      } else {
-        log('info', '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> {
-    if (lockType === 'watch') {
-      log('warn', 'Build already running, waiting to begin watch');
-      const res = await this.#waitForRelease(ctx, 'build');
-      log('info', `Finished with status of ${res}, retrying`);
-      return 'retry';
-    } else {
-      log('warn', 'Already running, waiting for completion');
-      switch (await this.#waitForRelease(ctx, lockType ?? 'build')) {
-        case 'complete': {
-          log('info', 'Completed');
-          return 'skip';
-        }
-        case 'stale': {
-          log('info', '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/transpile.ts

@@ -1,256 +0,0 @@
-import path from 'path';
-import fs from 'fs/promises';
-import os from 'os';
-import timers from 'timers/promises';
-import cp from 'child_process';
-import { createRequire } from 'module';
-
-import { DeltaEvent, ManifestContext, ManifestRoot, Package } from '@travetto/manifest';
-
-import { LogUtil } from './log';
-
-type ModFile = { input: string, output: string, stale: boolean };
-export type CompileResult = 'restart' | 'complete' | 'skipped';
-export type BuildEvent = { type: 'restart' | 'start' | 'complete' } | { type: 'status', idx: number, total: number };
-
-const OPT_CACHE: Record<string, import('typescript').CompilerOptions> = {};
-const SRC_REQ = createRequire(path.resolve('node_modules'));
-const RECENT_STAT = (stat: { ctimeMs: number, mtimeMs: number }): number => Math.max(stat.ctimeMs, stat.mtimeMs);
-
-const isBuildEvent = (ev: unknown): ev is BuildEvent =>
-  ev !== undefined && ev !== null && typeof ev === 'object' && 'type' in ev && typeof ev.type === 'string';
-
-/**
- * Transpile utilities for launching
- */
-export class TranspileUtil {
-  /**
-   * 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' : (/[.]tsx?$/.test(file) ? 'ts' : undefined)));
-  }
-
-  /**  Convert a file to a given ext */
-  static #sourceToExtension(inputFile: string, ext: string): string {
-    return inputFile.replace(/[.][tj]sx?$/, ext);
-  }
-
-  /**
-   * Get the output file name for a given input
-   */
-  static sourceToOutputExt(inputFile: string): string {
-    return this.#sourceToExtension(inputFile, '.js');
-  }
-
-  /**
-   * 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, 'utf8'));
-
-  /**
-   * Returns the compiler options
-   */
-  static async getCompilerOptions(ctx: ManifestContext): Promise<{}> {
-    if (!(ctx.workspacePath in OPT_CACHE)) {
-      let tsconfig = path.resolve(ctx.workspacePath, 'tsconfig.json');
-
-      if (!await fs.stat(tsconfig).then(_ => true, _ => false)) {
-        tsconfig = SRC_REQ.resolve('@travetto/compiler/tsconfig.trv.json');
-      }
-
-      const ts = (await import('typescript')).default;
-
-      const { options } = ts.parseJsonSourceFileConfigFileContent(
-        ts.readJsonConfigFile(tsconfig, ts.sys.readFile), ts.sys, ctx.workspacePath
-      );
-
-      OPT_CACHE[ctx.workspacePath] = {
-        ...options,
-        allowJs: true,
-        resolveJsonModule: true,
-        sourceRoot: ctx.workspacePath,
-        rootDir: ctx.workspacePath,
-        outDir: path.resolve(ctx.workspacePath),
-        module: ctx.moduleType === 'commonjs' ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext,
-      };
-    }
-    return OPT_CACHE[ctx.workspacePath];
-  }
-
-  /**
-   * Output a file, support for ts, js, and package.json
-   */
-  static async transpileFile(ctx: ManifestContext, inputFile: string, outputFile: string): Promise<void> {
-    const type = this.getFileType(inputFile);
-    if (type === 'js' || type === 'ts') {
-      const compilerOut = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules');
-
-      const text = (await fs.readFile(inputFile, 'utf8'))
-        .replace(/from '([.][^']+)'/g, (_, i) => `from '${i.replace(/[.]js$/, '')}.js'`)
-        .replace(/from '(@travetto\/(.*?))'/g, (_, i, s) => `from '${path.resolve(compilerOut, `${i}${s.includes('/') ? '.js' : '/__index__.js'}`)}'`);
-
-      const ts = (await import('typescript')).default;
-      const content = ts.transpile(text, {
-        ...await this.getCompilerOptions(ctx),
-        sourceMap: false,
-        inlineSourceMap: true,
-      }, inputFile);
-      await this.writeTextFile(outputFile, content);
-    } else if (type === 'package-json') {
-      const pkg: Package = JSON.parse(await fs.readFile(inputFile, 'utf8'));
-      const main = pkg.main ? this.sourceToOutputExt(pkg.main) : undefined;
-      const files = pkg.files?.map(x => this.sourceToOutputExt(x));
-
-      const content = JSON.stringify({ ...pkg, main, type: ctx.moduleType, files }, null, 2);
-      await this.writeTextFile(outputFile, content);
-    }
-  }
-
-  /**
-   * Scan directory to find all project sources for comparison
-   */
-  static async getModuleSources(ctx: ManifestContext, module: string, seed: string[]): Promise<ModFile[]> {
-    const inputFolder = (ctx.mainModule === module) ?
-      process.cwd() :
-      path.dirname(SRC_REQ.resolve(`${module}/package.json`));
-
-    const folders = seed.filter(x => !/[.]/.test(x)).map(x => path.resolve(inputFolder, x));
-    const files = seed.filter(x => /[.]/.test(x)).map(x => path.resolve(inputFolder, x));
-
-    while (folders.length) {
-      const sub = folders.pop();
-      if (!sub) {
-        continue;
-      }
-
-      for (const file of await fs.readdir(sub).catch(() => [])) {
-        if (file.startsWith('.')) {
-          continue;
-        }
-        const resolvedInput = path.resolve(sub, file);
-        const stat = await fs.stat(resolvedInput);
-
-        if (stat.isDirectory()) {
-          folders.push(resolvedInput);
-        } else {
-          switch (this.getFileType(file)) {
-            case 'js':
-            case 'ts':
-              files.push(resolvedInput);
-          }
-        }
-      }
-    }
-
-    const outputFolder = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', module);
-    const out: ModFile[] = [];
-    for (const input of files) {
-      const output = this.sourceToOutputExt(input.replace(inputFolder, outputFolder));
-      const inputTs = await fs.stat(input).then(RECENT_STAT, () => 0);
-      if (inputTs) {
-        const outputTs = await fs.stat(output).then(RECENT_STAT, () => 0);
-        await fs.mkdir(path.dirname(output), { recursive: true, });
-        out.push({ input, output, stale: inputTs > outputTs });
-      }
-    }
-
-    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: boolean, onMessage: (msg: BuildEvent) => 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.${process.pid}.${process.ppid}.${Date.now()}.json`);
-
-    const changedFiles = changed[0]?.file === '*' ? ['*'] : changed.map(ev =>
-      path.resolve(manifest.workspacePath, manifest.modules[ev.module].sourceFolder, ev.file)
-    );
-
-    let proc: cp.ChildProcess | undefined;
-    let kill: (() => void) | undefined;
-
-    try {
-      await this.writeTextFile(deltaFile, changedFiles.join('\n'));
-
-      const result = 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 (isBuildEvent(msg)) {
-              // Send to parent if exists
-              process.send?.(msg);
-              if (msg.type === 'restart') {
-                res('restart');
-              } else {
-                onMessage(msg);
-              }
-            }
-          })
-          .on('exit', code => (code !== null && code > 0) ? rej(new Error('Failed during compilation')) : res('complete'));
-        kill = (): void => { proc?.kill('SIGKILL'); };
-        process.on('exit', kill);
-      }));
-
-      if (result === 'restart') {
-        await timers.setTimeout(150 + 100 * Math.random());
-      }
-
-      LogUtil.log('compiler-exec', [], 'info', `Result ${result}, exit code: ${proc?.exitCode}`);
-
-      return result;
-    } finally {
-      if (proc?.killed === false) { proc.kill('SIGKILL'); }
-      if (kill) {
-        process.off('exit', kill);
-      }
-      if (process.stdout.isTTY) {
-        process.stdout.write('\x1b[s\x1b[?25h\x1b[r\x1b[u');
-      }
-      await fs.rm(deltaFile, { force: true });
-    }
-  }
-}