@travetto/compiler 3.0.0-rc.8 → 3.0.0

package/README.md

@@ -1,28 +1,82 @@
 <!-- This file was generated by @travetto/doc and should not be modified directly -->
 <!-- Please modify https://github.com/travetto/travetto/tree/main/module/compiler/DOC.ts and execute "npx trv doc" to rebuild -->
 # Compiler
-## Compiler
+## The compiler infrastructure for the Travetto framework
 
 **Install: @travetto/compiler**
 ```bash
 npm install @travetto/compiler
+
+# or
+
+yarn add @travetto/compiler
 ```
 
-This module expands upon [Typescript](https://typescriptlang.org), with supplemental functionality:
+This module expands upon the [Typescript](https://typescriptlang.org) compiler, with the additional features:
    
-   *  Read `tsconfig.json` from the project directory to provide 
-   *  Supports on-the-fly compilation, nothing needs to be compiled ahead of time
-   *  Enhanced AST transformations, and transformer registration [object Object]
-   *  Intelligent caching of source files to minimize recompilation
-   *  Support for detecting changes in sources files at runtime
-   *  Allows for hot-reloading of classes during development    
-      *  Utilizes `es2015` `Proxy`s to allow for swapping out implementation at runtime
-Additionally, there is support for common AST transformations via [Transformation](https://github.com/travetto/travetto/tree/main/module/transformer#readme "Functionality for AST transformations, with transformer registration, and general utils")
-## Debugging
-When dealing with transformers, logging is somewhat tricky as the compiler executes before the code is loaded.  To that end, the file `compiler.log` is created in the cache directory during the compilation process. This is a location that transformers should be free to log to, for debugging, and any additional feedback.
+   *  Integration with the [Transformation](https://github.com/travetto/travetto/tree/main/module/transformer#readme "Functionality for AST transformations, with transformer registration, and general utils") module, allowing for rich, type-aware transformations
+   *  Automatic conversion to either [Ecmascript Module](https://nodejs.org/api/esm.html) or [CommonJS](https://nodejs.org/api/modules.html) based on the [Package JSON](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) `type` value
+   *  Removal of type only imports which can break [Ecmascript Module](https://nodejs.org/api/esm.html)-style output
+   *  Automatic addition of `.js` extension to imports to also support  [Ecmascript Module](https://nodejs.org/api/esm.html)-style output
+
+Beyond the [Typescript](https://typescriptlang.org) compiler functionality, the module provides the primary entry point into the development process.  
 
 ## CLI
 
-The module provides the ability to clear the compilation cache to handle any inconsistencies that may arise.
+The cli, [trv](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trv.js#L60) is a compilation aware entry point, that has the ability to check for active builds, and ongoing watch operations to ensure only one process is building at a time.  Within the framework, regardless of mono-repo or not, always builds the entire project.  With the efficient caching behavior, this leads to generally a minimal overhead but allows for centralization of all operations.
+
+The CLI supports the following operations:
+
+   
+   *  `clean` - Removes the output folder, and if `-a` is also passed, will also clean out the compiler folder
+   *  `build` - Will attempt to build the project.  If the project is already built, will return immediately.  If the project is being built somewhere else, will wait until a build is completed.
+   *  `watch` - If nothing else is watching, will start the watch operation.  Otherwise will return immediately.
+   *  `manifest` - Will produce a manifest. If no file is passed in the command line arguments, will output to stdout
+   *  `<other>` - Will be delegated to the [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") entry point after a successful build.
+
+In addition to the normal output, the compiler supports an environment variable `TRV_BUILD` that supports the following values: `debug`, `info`, `warn` or `none`.  This provides different level of logging during the build process which is helpful to diagnose any odd behaviors.  When invoking an unknown command (e.g. `<other>` from above), the default level is `warn`.  Otherwise the default logging level is `info`.
+
+**Terminal: Sample trv output with debug logging**
+```bash
+$ TRV_BUILD=debug trv build
+
+2029-03-14T04:00:00.618Z [lock           ] watch pid=000000 Started
+2029-03-14T04:00:00.837Z [lock           ] watch pid=000000 Already running, and has built
+2029-03-14T04:00:01.510Z [lock           ] watch pid=000000 Completed
+2029-03-14T04:00:02.450Z [build          ] Successfully built
+```
+
+**Terminal: Sample trv output with default log level**
+```bash
+$ trv build
+```
+
+## Compilation Architecture
+
+The compiler will move through the following phases on a given compilation execution:
+   
+   *  `Bootstrapping` - Initial compilation of [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework")'s `support/*.ts` files
+   *  `Lock Management` - Manages cross-process interaction to ensure single compiler
+   *  `Build Compiler` - Leverages [Typescript](https://typescriptlang.org) to build files needed to execute compiler
+   *  `Build Manifest` - Produces the manifest for the given execution
+   *  `Build Transformers` - Leverages [Typescript](https://typescriptlang.org) to compile all transformers defined in the manifest
+   *  `Produce Manifest Delta` - Compare the output file system with the manifest to determine what needs to be compiled
+   *  `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 [trv](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trv.js#L60) entrypoint, along with a small context utility in [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching") are the only [Javascript](https://developer.mozilla.org/en-US/docs/Web/JavaScript) files needed to run the project.  The [trv](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trv.js#L60) entry point will compile `@travetto/compiler/support/*` files as the set that is used at startup.  These files are also accessible to the compiler as they get re-compiled after the fact.  
+
+### Lock Management
+
+The compiler supports invocation from multiple locations at the same time, and provides a layer of orchestration to ensure a single process is building at a time.  For a given project, there are four main states:
+
+   
+   *  No Watch - Building
+   *  Watch    - No Build
+   *  Watch    - Building
+   *  Inactive / Stale
 
-TODO: Describe cli behavior
+Depending on what state the project is in (depending on various processes), will influence what the supporting tooling should do. [LockManager](https://github.com/travetto/travetto/tree/main/module/compiler/support/lock.ts#L25) represents the majority of the logic for tracking various states, and informing what action should happen when in the above states.

package/__index__.ts

@@ -1,3 +1,6 @@
 export * from './src/compiler';
 export * from './src/state';
-export * from './src/util';
+export * from './src/util';
+export * from './src/watch';
+export * from './src/log';
+export * from './src/types';

package/bin/trv.js

@@ -1,81 +1,75 @@
 #!/usr/bin/env node
 
 // @ts-check
+import fs from 'fs/promises';
+import path from 'path';
+import { createRequire } from 'module';
 
-/**
- * @param {import('@travetto/manifest').ManifestContext} ctx
- * @return {Promise<import('../support/bin/compiler-bootstrap')>}
- */
-async function $getBootstrap(ctx) {
-  const path = require('path');
-  const { buildPackage } = require('./transpile');
+import { getManifestContext } from '@travetto/manifest/bin/context.js';
 
-  const root = path.resolve(__dirname, '..');
+const VALID_OPS = { watch: 'watch', build: 'build', clean: 'clean', manifest: 'manifest' };
 
-  const loc = await buildPackage(
-    ctx, '__compiler_bootstrap__', root, 'support/bin/compiler-bootstrap.ts',
-    ['support/bin/utils.ts', 'bin/transpile.js', 'package.json']
-  );
-
-  try { return require(loc); } catch { return import(loc); }
-}
+const COMPILER_FILES = [...['launcher', 'transpile', 'lock', 'log', 'lock-pinger'].map(x => `support/${x}.js`), 'package.json'];
 
 /**
  * @param {import('@travetto/manifest').ManifestContext} ctx
- * @param {boolean} [watch]
+ * @return {Promise<import('@travetto/compiler/support/launcher').launch>}
  */
-const compile = (ctx, watch) => $getBootstrap(ctx).then(({ compile: go }) => go(ctx, watch));
-
-/** @param {string[]} args */
-async function exec(args) {
-  const { getContext } = require('./transpile');
-  const op = args.find(x => !x.startsWith('-'));
-  /** @type {{clean?: boolean, quiet?: boolean}} */
-  const flags = Object.fromEntries(args.filter(x => x.startsWith('-')).map(x => x.split('-').pop()).map(x => [x, true]));
+const $getLauncher = async (ctx) => {
+  const tsconfigFile = path.resolve(ctx.workspacePath, 'tsconfig.json');
+  if (!(await fs.stat(tsconfigFile).catch(() => undefined))) {
+    await fs.writeFile(tsconfigFile, JSON.stringify({ extends: '@travetto/compiler/tsconfig.trv.json' }), 'utf8');
+  }
+  const compPkg = createRequire(path.resolve(ctx.workspacePath, 'node_modules')).resolve('@travetto/compiler/package.json');
+  const files = [];
 
-  const ctx = await getContext();
-  const message = flags.quiet ? () => { } : console.log.bind(console);
+  for (const file of COMPILER_FILES) {
+    const target = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', '@travetto/compiler', file);
+    const src = compPkg.replace('package.json', file.replace(/[.]js$/, '.ts'));
 
-  // Clean if needed
-  if (op === 'clean' || (op && flags.clean)) {
-    const fs = require('fs/promises');
-    await Promise.all([ctx.outputFolder, ctx.compilerFolder].map(folder =>
-      fs.rm(`${ctx.workspacePath}/${folder}`, { force: true, recursive: true })));
-    if (op === 'clean') {
-      message(`Cleaned ${ctx.workspacePath}: [${ctx.outputFolder}, ${ctx.compilerFolder}]`);
+    const targetTime = await fs.stat(target).then(s => Math.max(s.mtimeMs, s.ctimeMs)).catch(() => 0);
+    const srcTime = await fs.stat(src).then(s => Math.max(s.mtimeMs, s.ctimeMs));
+    // If stale
+    if (srcTime > targetTime) {
+      const ts = (await import('typescript')).default;
+      const module = ctx.moduleType === 'module' ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      const text = await fs.readFile(src, 'utf8');
+      if (file.endsWith('.js')) {
+        const content = ts.transpile(
+          text,
+          { target: ts.ScriptTarget.ES2020, module, esModuleInterop: true, allowSyntheticDefaultImports: true }
+        )
+          .replace(/^((?:im|ex)port .*from '[.][^']+)(')/mg, (_, a, b) => `${a}.js${b}`)
+          .replace(/^(import [^\n]*from '[^.][^\n/]+[/][^\n/]+[/][^\n']+)(')/mg, (_, a, b) => `${a}.js${b}`);
+        await fs.writeFile(target, content, 'utf8');
+      } else {
+        const pkg = JSON.parse(text);
+        pkg.type = ctx.moduleType;
+        await fs.writeFile(target, JSON.stringify(pkg, null, 2), 'utf8');
+      }
+      // Compile
     }
+    files.push(target);
   }
 
-  switch (op) {
-    case 'clean': break;
-    case 'manifest': {
-      const { writeManifest, buildManifest } = await $getBootstrap(ctx);
-      const manifest = (await buildManifest(ctx)).manifest;
-      await writeManifest(ctx, manifest);
-      const output = `${ctx.workspacePath}/${ctx.outputFolder}/${ctx.manifestFile}`;
-      message(`Wrote manifest ${output}`);
-      break;
-    }
-    case 'watch':
-      message(`Watching ${ctx.workspacePath} for changes...`);
-      await compile(ctx, true);
-      return;
-    case 'build':
-      await compile(ctx);
-      message(`Built to ${ctx.workspacePath}/${ctx.outputFolder}`);
-      break;
-    default: {
-      const path = require('path/posix');
-      const { manifest } = await compile(ctx);
-      const out = path.join(ctx.workspacePath, ctx.outputFolder);
-      // TODO: Externalize somehow?
-      const cliMain = path.join(out, manifest.modules['@travetto/cli'].output, 'support', 'main.cli.js');
-      process.env.TRV_MANIFEST = ctx.mainModule;
-      process.env.TRV_OUTPUT = out;
-      await import(process.env.TRV_MAIN = cliMain);
-      return;
+  try { return require(files[0]).launch; }
+  catch { return import(files[0]).then(x => x.launch); }
+};
+
+(async () => {
+  const ctx = await getManifestContext();
+  const [op, args] = [VALID_OPS[process.argv[2]], process.argv.slice(3)];
+
+  if (op === 'clean') {
+    const folders = process.argv.find(x => x === '--all' || x === '-a') ? [ctx.outputFolder, ctx.compilerFolder] : [ctx.outputFolder];
+    for (const f of folders) {
+      await fs.rm(path.resolve(ctx.workspacePath, f), { force: true, recursive: true });
     }
+    return console.log(`Cleaned ${ctx.workspacePath}: [${folders.join(', ')}]`);
   }
-}
 
-exec(process.argv.slice(2));
+  const rootCtx = ctx.monoRepo ? await getManifestContext(ctx.workspacePath) : ctx;
+
+  return (await $getLauncher(ctx))(ctx, rootCtx, op, args);
+})();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/compiler",
-  "version": "3.0.0-rc.8",
-  "description": "Compiler",
+  "version": "3.0.0",
+  "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
     "travetto",
@@ -13,6 +13,7 @@
     "email": "travetto.framework@gmail.com",
     "name": "Travetto Framework"
   },
+  "type": "module",
   "files": [
     "__index__.ts",
     "src",
@@ -29,12 +30,13 @@
     "directory": "module/compiler"
   },
   "dependencies": {
-    "@travetto/manifest": "^3.0.0-rc.4",
-    "@travetto/terminal": "^3.0.0-rc.4",
-    "@travetto/transformer": "^3.0.0-rc.8"
+    "@parcel/watcher": "^2.1.0",
+    "@travetto/manifest": "^3.0.0",
+    "@travetto/terminal": "^3.0.0",
+    "@travetto/transformer": "^3.0.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.0-rc.6"
+    "@travetto/cli": "^3.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -1,127 +1,72 @@
+import { install } from 'source-map-support';
 import ts from 'typescript';
 import fs from 'fs/promises';
-import path from 'path';
 
-import { ManifestState } from '@travetto/manifest';
 import { GlobalTerminal, TerminalProgressEvent } from '@travetto/terminal';
+import { RootIndex } from '@travetto/manifest';
 
 import { CompilerUtil } from './util';
 import { CompilerState } from './state';
-
-export type TransformerProvider = {
-  init(checker: ts.TypeChecker): void;
-  get(): ts.CustomTransformers | undefined;
-};
-
-type EmitError = Error | readonly ts.Diagnostic[];
-type Emitter = (file: string, newProgram?: boolean) => EmitError | undefined;
-type EmitEvent = { file: string, i: number, total: number, err?: EmitError };
+import { CompilerWatcher } from './watch';
+import { Log } from './log';
+import { CompileEmitError, CompileEmitEvent, CompileEmitter } from './types';
 
 /**
  * Compilation support
  */
 export class Compiler {
 
-  #bootTsconfig: string;
-  #state: CompilerState;
-  #transformers: string[];
-
-  init(manifestState: ManifestState): this {
-    this.#state = new CompilerState(manifestState);
-    this.#bootTsconfig = this.#state.resolveModuleFile('@travetto/compiler', 'tsconfig.trv.json');
-
-    this.#transformers = this.state.modules.flatMap(
-      x => (x.files.support ?? [])
-        .filter(([f, type]) => type === 'ts' && f.startsWith('support/transformer.'))
-        .map(([f]) =>
-          path.resolve(
-            this.#state.manifest.workspacePath,
-            this.#state.manifest.compilerFolder,
-            x.output,
-            f.replace(/[.][tj]s$/, '.js')
-          )
-        )
-    );
-
-    return this;
+  /**
+   * Run compiler as a main entry point
+   */
+  static async main(): Promise<void> {
+    const [dirty, watch] = process.argv.slice(2);
+    const state = await CompilerState.get(RootIndex);
+    const dirtyFiles = (await fs.readFile(dirty, 'utf8')).split(/\n/).filter(x => !!x);
+    await new Compiler(state, dirtyFiles, watch === 'true').run();
+    process.exit(0);
   }
 
-  get state(): CompilerState {
-    return this.#state;
+  #state: CompilerState;
+  #dirtyFiles: string[];
+  #watch?: boolean;
+
+  constructor(state: CompilerState, dirtyFiles: string[], watch?: boolean) {
+    this.#state = state;
+    this.#dirtyFiles = dirtyFiles[0] === '*' ?
+      this.#state.getAllFiles() :
+      dirtyFiles.map(f => this.#state.getBySource(f)!.input);
+    this.#watch = watch;
   }
 
   /**
    * Watches local modules
    */
-  async #watchLocalModules(emit: Emitter): Promise<() => Promise<void>> {
-    const folders = this.state.modules.filter(x => x.local).map(x => x.source);
-    const emitWithError = (file: string): void => {
-      const err = emit(file, true);
+  #watchLocalModules(emit: CompileEmitter): Promise<() => Promise<void>> {
+    return new CompilerWatcher(this.#state).watchFiles(async file => {
+      const err = await emit(file, true);
       if (err) {
-        console.error(CompilerUtil.buildTranspileError(file, err));
+        Log.info('Compilation Error', CompilerUtil.buildTranspileError(file, err));
       } else {
-        console.error('Compiled', file.split('node_modules/')[1]);
+        Log.info(`Compiled ${file.split('node_modules/')[1]}`);
       }
-    };
-    const watcher = this.state.getWatcher({
-      create: (inputFile) => emitWithError(inputFile),
-      update: (inputFile) => emitWithError(inputFile),
-      delete: (outputFile) => fs.unlink(outputFile).catch(() => { })
+      return err;
     });
-    return CompilerUtil.fileWatcher(folders, watcher);
-  }
-
-  async createTransformerProvider(): Promise<TransformerProvider> {
-    const { TransformerManager } = await import('@travetto/transformer');
-    return TransformerManager.create(this.#transformers, this.state.manifest);
-  }
-
-  async writeRawFile(file: string, contents: string, mode?: string): Promise<void> {
-    const outFile = path.resolve(
-      this.#state.manifest.workspacePath,
-      this.#state.manifest.outputFolder,
-      file
-    );
-    await fs.mkdir(path.dirname(outFile), { recursive: true });
-    await fs.writeFile(outFile, contents, { encoding: 'utf8', mode });
-  }
-
-  async outputInit(): Promise<void> {
-    // Write manifest
-    await this.writeRawFile(this.#state.manifest.manifestFile, JSON.stringify(this.state.manifest));
-    // TODO: This needs to be isolated, just like in the bootstrap
-    await this.writeRawFile('trv', '#!/bin/sh\nnode node_modules/@travetto/cli/support/main.cli.js $@\n', '755');
-    await this.writeRawFile('trv.cmd', 'node node_modules/@travetto/cli/support/main.cli.js %*\n', '755');
   }
 
   /**
    * Compile in a single pass, only emitting dirty files
    */
-  async getCompiler(): Promise<Emitter> {
+  async getCompiler(): Promise<CompileEmitter> {
     let program: ts.Program;
 
-    const transformers = await this.createTransformerProvider();
-    const options = await CompilerUtil.getCompilerOptions(
-      path.resolve(
-        this.#state.manifest.workspacePath,
-        this.#state.manifest.outputFolder,
-      ),
-      this.#bootTsconfig,
-      this.#state.manifest.workspacePath
-    );
-    const host = this.state.getCompilerHost(options);
-
-    const emit = (file: string, needsNewProgram = program === undefined): EmitError | undefined => {
-      if (needsNewProgram) {
-        program = ts.createProgram({ rootNames: this.#state.getAllFiles(), host, options, oldProgram: program });
-        transformers.init(program.getTypeChecker());
-      }
+    const emit = async (inputFile: string, needsNewProgram = program === undefined): Promise<CompileEmitError | undefined> => {
       try {
-        const result = program.emit(
-          program.getSourceFile(file)!, host.writeFile, undefined, false, transformers.get()
-        );
-
-        if (result.diagnostics?.length) {
+        if (needsNewProgram) {
+          program = this.#state.createProgram(program);
+        }
+        const result = this.#state.writeInputFile(program, inputFile);
+        if (result?.diagnostics?.length) {
           return result.diagnostics;
         }
       } catch (err) {
@@ -139,49 +84,65 @@ export class Compiler {
   /**
    * Emit all files as a stream
    */
-  async * emit(files: string[], emitter: Emitter): AsyncIterable<EmitEvent> {
+  async * emit(files: string[], emitter: CompileEmitter): AsyncIterable<CompileEmitEvent> {
     let i = 0;
-    const manifest = this.#state.manifest;
     for (const file of files) {
-      const err = emitter(file);
-      const outputFile = file
-        .replace(/[.]ts$/, '.js')
-        .replace(manifest.compilerFolder, manifest.outputFolder);
-      yield { file: outputFile, i: i += 1, err, total: files.length };
+      const err = await emitter(file);
+      const imp = file.replace(/.*node_modules\//, '');
+      yield { file: imp, i: i += 1, err, total: files.length };
     }
+    Log.debug(`Compiled ${i} files`);
   }
 
   /**
    * Run the compiler
    */
-  async run(watch?: boolean): Promise<void> {
-    await this.outputInit();
+  async run(): Promise<void> {
+    await GlobalTerminal.init();
+    install();
+
+    Log.debug('Compilation started');
+
+    process.on('disconnect', () => process.exit(0));
+
     const emitter = await this.getCompiler();
     let failed = false;
 
-    const resolveEmittedFile = ({ file, total, i, err }: EmitEvent): TerminalProgressEvent => {
+    Log.debug('Compiler loaded');
+
+    const resolveEmittedFile = ({ file, total, i, err }: CompileEmitEvent): TerminalProgressEvent => {
       if (err) {
         failed = true;
         console.error(CompilerUtil.buildTranspileError(file, err));
       }
-      return { idx: i, total, text: `Compiling [%idx/%total] -- ${file.split('node_modules/')[1]}` };
+      return { idx: i, total, text: `Compiling [%idx/%total] -- ${file}` };
     };
 
-    let files = this.state.getDirtyFiles();
-    if (!watch && !files.length) {
-      files = this.state.getAllFiles();
-    }
-
-    if (files.length) {
-      await GlobalTerminal.trackProgress(this.emit(files, emitter), resolveEmittedFile, { position: 'bottom' });
+    if (this.#dirtyFiles.length) {
+      await GlobalTerminal.trackProgress(this.emit(this.#dirtyFiles, emitter), resolveEmittedFile, { position: 'bottom' });
       if (failed) {
+        Log.debug('Compilation failed');
         process.exit(1);
+      } else {
+        Log.debug('Compilation succeeded');
       }
+    } else if (this.#watch) {
+      // Prime compiler before complete
+      const resolved = this.#state.getArbitraryInputFile();
+      await emitter(resolved, true);
     }
 
-    if (watch) {
+    process.send?.('build-complete');
+
+    if (this.#watch) {
+      Log.info('Watch is ready');
       await this.#watchLocalModules(emitter);
-      await new Promise(r => setTimeout(r, 1000 * 60 * 60 * 24));
+      const output = this.#state.resolveOutputFile('.');
+      for await (const _ of fs.watch(output)) {
+        if (!await fs.stat(output).catch(() => false)) {
+          process.send?.('restart');
+        }
+      }
     }
   }
-}
+}

package/src/log.ts

@@ -0,0 +1,18 @@
+import util from 'util';
+
+import type { CompilerLogEvent } from '../support/log';
+
+function log(level: 'info' | 'debug', message: string, ...args: unknown[]): void {
+  if (process.send) {
+    const ev: CompilerLogEvent = [level, util.format(message, ...args)];
+    process.send(ev);
+  } else {
+    // eslint-disable-next-line no-console
+    console[level](message, ...args);
+  }
+}
+
+export const Log = {
+  debug: log.bind(null, 'debug'),
+  info: log.bind(null, 'info')
+};