@travetto/compiler 3.0.0-rc.2 → 3.0.0-rc.21

package/src/state.ts

@@ -0,0 +1,213 @@
+import ts from 'typescript';
+import os from 'os';
+
+import { path, ManifestModuleUtil, ManifestModule, ManifestRoot, ManifestIndex } from '@travetto/manifest';
+import { TransformerManager } from '@travetto/transformer';
+
+import { CompilerUtil } from './util';
+import { TranspileUtil } from '../support/transpile';
+import { CompileStateEntry } from './types';
+
+export class CompilerState implements ts.CompilerHost {
+
+  static async get(idx: ManifestIndex): Promise<CompilerState> {
+    return new CompilerState().init(idx);
+  }
+
+  private constructor() { }
+
+  #rootDir = path.resolve(os.tmpdir(), '_');
+  #outputPath: string;
+  #inputFiles = new Set<string>();
+  #inputDirectoryToSource = new Map<string, string>();
+  #inputToEntry = new Map<string, CompileStateEntry>();
+  #sourceToEntry = new Map<string, CompileStateEntry>();
+  #outputToEntry = new Map<string, CompileStateEntry>();
+
+  #sourceContents = new Map<string, string | undefined>();
+  #sourceFileObjects = new Map<string, ts.SourceFile>();
+
+  #manifestIndex: ManifestIndex;
+  #manifest: ManifestRoot;
+  #modules: ManifestModule[];
+  #transformerManager: TransformerManager;
+  #compilerOptions: ts.CompilerOptions;
+
+  async init(idx: ManifestIndex): Promise<this> {
+    this.#manifestIndex = idx;
+    this.#manifest = idx.manifest;
+    this.#outputPath = path.resolve(this.#manifest.workspacePath, this.#manifest.outputFolder);
+    this.#modules = Object.values(this.#manifest.modules);
+
+    // Register all inputs
+    for (const x of this.#modules) {
+      const files = [
+        ...x.files.bin ?? [],
+        ...x.files.src ?? [],
+        ...x.files.support ?? [],
+        ...x.files.doc ?? [],
+        ...x.files.test ?? [],
+        ...x.files.$index ?? [],
+        ...x.files.$package ?? []
+      ];
+      for (const [file, type] of files) {
+        if (CompilerUtil.validFile(type) || type === 'typings') {
+          this.registerInput(x, file);
+        }
+      }
+    }
+
+    this.#transformerManager = await TransformerManager.create(this.#manifestIndex);
+
+    this.#compilerOptions = {
+      ...await TranspileUtil.getCompilerOptions(this.#manifest),
+      rootDir: this.#rootDir,
+      outDir: this.#outputPath
+    };
+
+    return this;
+  }
+
+  get manifest(): ManifestRoot {
+    return this.#manifest;
+  }
+
+  get manifestIndex(): ManifestIndex {
+    return this.#manifestIndex;
+  }
+
+  resolveOutputFile(file: string): string {
+    return path.resolve(this.#manifest.workspacePath, this.#manifest.outputFolder, file);
+  }
+
+  getArbitraryInputFile(): string {
+    return this.getBySource(this.#manifestIndex.getModule('@travetto/manifest')!.files.src[0].sourceFile)!.input;
+  }
+
+  createProgram(oldProgram?: ts.Program): ts.Program {
+    const prog = ts.createProgram({ rootNames: this.getAllFiles(), host: this, options: this.#compilerOptions, oldProgram });
+    this.#transformerManager.init(prog.getTypeChecker());
+    return prog;
+  }
+
+  writeInputFile(program: ts.Program, inputFile: string): ts.EmitResult | undefined {
+    if (inputFile.endsWith('.json')) {
+      this.writeFile(this.#inputToEntry.get(inputFile)!.output!, this.readFile(inputFile)!, false);
+    } else if (inputFile.endsWith('.js')) {
+      this.writeFile(this.#inputToEntry.get(inputFile)!.output!, ts.transpile(this.readFile(inputFile)!, this.#compilerOptions), false);
+    } else if (inputFile.endsWith('.ts')) {
+      return program.emit(
+        program.getSourceFile(inputFile)!,
+        (...args) => this.writeFile(...args), undefined, false,
+        this.#transformerManager.get()
+      );
+    }
+  }
+
+  getBySource(sourceFile: string): CompileStateEntry | undefined {
+    return this.#sourceToEntry.get(sourceFile);
+  }
+
+  registerInput(module: ManifestModule, moduleFile: string): string {
+    const relativeInput = `${module.outputFolder}/${moduleFile}`;
+    const sourceFile = path.toPosix(path.resolve(this.#manifest.workspacePath, module.sourceFolder, moduleFile));
+    const sourceFolder = path.dirname(sourceFile);
+    const inputFile = path.resolve(this.#rootDir, relativeInput); // Ensure input is isolated
+    const inputFolder = path.dirname(inputFile);
+    const fileType = ManifestModuleUtil.getFileType(moduleFile);
+    const outputFile = fileType === 'typings' ?
+      undefined :
+      path.resolve(this.#outputPath, CompilerUtil.inputToOutput(relativeInput));
+
+    const entry = { source: sourceFile, input: inputFile, output: outputFile, module, relativeInput };
+
+    this.#inputToEntry.set(inputFile, entry);
+    this.#sourceToEntry.set(sourceFile, entry);
+    this.#inputDirectoryToSource.set(inputFolder, sourceFolder);
+
+    if (outputFile) {
+      this.#outputToEntry.set(outputFile, entry);
+    }
+
+    this.#inputFiles.add(inputFile);
+
+    return inputFile;
+  }
+
+  removeInput(inputFile: string): void {
+    const { output, source } = this.#inputToEntry.get(inputFile)!;
+    if (output) {
+      this.#outputToEntry.delete(output);
+    }
+    this.#sourceToEntry.delete(source);
+    this.#inputToEntry.delete(inputFile);
+    this.#inputFiles.delete(inputFile);
+  }
+
+  resetInputSource(inputFile: string): void {
+    this.#sourceFileObjects.delete(inputFile);
+    this.#sourceContents.delete(inputFile);
+  }
+
+  getAllFiles(): string[] {
+    return [...this.#inputFiles];
+  }
+
+  /**
+   * Used for translating non-project files (e.g. dependencies/node_modules) to the faux-root
+   * that is used during compilation.
+   */
+  translateRawInput(input: string): string {
+    return input.replace(this.#rootDir, this.#manifest.workspacePath);
+  }
+
+  /* Start Compiler Host */
+  getCanonicalFileName(file: string): string { return file; }
+  getCurrentDirectory(): string { return path.cwd(); }
+  getDefaultLibFileName(opts: ts.CompilerOptions): string { return ts.getDefaultLibFileName(opts); }
+  getNewLine(): string { return ts.sys.newLine; }
+  useCaseSensitiveFileNames(): boolean { return ts.sys.useCaseSensitiveFileNames; }
+  getDefaultLibLocation(): string { return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions)); }
+
+  fileExists(inputFile: string): boolean {
+    return this.#inputToEntry.has(inputFile) || ts.sys.fileExists(this.translateRawInput(inputFile));
+  }
+
+  directoryExists(inputDir: string): boolean {
+    return this.#inputDirectoryToSource.has(inputDir) || ts.sys.directoryExists(this.translateRawInput(inputDir));
+  }
+
+  writeFile(
+    outputFile: string,
+    text: string,
+    bom: boolean,
+    onError?: (message: string) => void,
+    sourceFiles?: readonly ts.SourceFile[],
+    data?: ts.WriteFileCallbackData
+  ): void {
+    if (outputFile.endsWith('package.json')) {
+      text = CompilerUtil.rewritePackageJSON(this.#manifest, text);
+    } else if (!this.#compilerOptions.inlineSourceMap && this.#compilerOptions.sourceMap && outputFile.endsWith('.map')) {
+      text = CompilerUtil.rewriteSourceMap(this.#manifest, text, f => this.#outputToEntry.get(f.replace(/[.]map$/, ''))!);
+    } else if (this.#compilerOptions.inlineSourceMap && CompilerUtil.isSourceMapUrlPosData(data)) {
+      text = CompilerUtil.rewriteInlineSourceMap(this.#manifest, text, f => this.#outputToEntry.get(f)!, data);
+    }
+    ts.sys.writeFile(outputFile, text, bom);
+  }
+
+  readFile(inputFile: string): string | undefined {
+    const res = this.#sourceContents.get(inputFile) ?? ts.sys.readFile(
+      this.#inputToEntry.get(inputFile)?.source ?? this.translateRawInput(inputFile)
+    );
+    this.#sourceContents.set(inputFile, res);
+    return res;
+  }
+
+  getSourceFile(inputFile: string, language: ts.ScriptTarget): ts.SourceFile {
+    if (!this.#sourceFileObjects.has(inputFile)) {
+      const content = this.readFile(inputFile)!;
+      this.#sourceFileObjects.set(inputFile, ts.createSourceFile(inputFile, content ?? '', language));
+    }
+    return this.#sourceFileObjects.get(inputFile)!;
+  }
+}

package/src/types.ts

@@ -0,0 +1,14 @@
+import type ts from 'typescript';
+
+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 CompileWatcherHandler = {
+  create: (inputFile: string) => void;
+  update: (inputFile: string) => void;
+  delete: (outputFile: string) => void;
+};

package/src/util.ts

@@ -0,0 +1,147 @@
+import ts from 'typescript';
+
+import { ManifestContext, ManifestModuleFileType, ManifestRoot, Package, path } from '@travetto/manifest';
+
+type OutputToSource = (outputFile: string) => ({ source: string } | undefined);
+export type FileWatchEvent = { type: 'create' | 'delete' | 'update', path: string };
+
+const nativeCwd = process.cwd();
+
+/**
+ * Standard utilities for compiler
+ */
+export class CompilerUtil {
+
+  /**
+   * Determine if this is a manifest file we care about
+   */
+  static validFile = (type: ManifestModuleFileType): boolean => type === 'ts' || type === 'package-json' || type === 'js';
+
+  /**
+   * Map input file to output format, generally converting ts extensions to js
+   * @param file
+   * @returns
+   */
+  static inputToOutput(file: string): string {
+    return file.replace(/[.][tj]s$/, '.js');
+  }
+
+  /**
+   * Determines if write callback data has sourcemap information
+   * @param data
+   * @returns
+   */
+  static isSourceMapUrlPosData(data?: ts.WriteFileCallbackData): data is { sourceMapUrlPos: number } {
+    return data !== undefined && data !== null && typeof data === 'object' && ('sourceMapUrlPos' in data);
+  }
+
+  /**
+   * Rewrite's sourcemap locations to real folders
+   * @returns
+   */
+  static rewriteSourceMap(ctx: ManifestContext, text: string, outputToSource: OutputToSource): string {
+    const data: { sourceRoot?: string, sources: string[] } = JSON.parse(text);
+    const output = this.inputToOutput(path.resolve(ctx.workspacePath, ctx.outputFolder, data.sources[0]));
+    const { source: file } = outputToSource(output) ?? {};
+
+    if (file) {
+      delete data.sourceRoot;
+      data.sources = [file];
+      text = JSON.stringify(data);
+    }
+    return text;
+  }
+
+  /**
+   * Rewrite's inline sourcemap locations to real folders
+   * @param text
+   * @param outputToSource
+   * @param writeData
+   * @returns
+   */
+  static rewriteInlineSourceMap(
+    ctx: ManifestContext,
+    text: string,
+    outputToSource: OutputToSource,
+    { sourceMapUrlPos }: ts.WriteFileCallbackData & { sourceMapUrlPos: number }
+  ): string {
+    const sourceMapUrl = text.substring(sourceMapUrlPos);
+    const [prefix, sourceMapData] = sourceMapUrl.split('base64,');
+    const rewritten = this.rewriteSourceMap(ctx, Buffer.from(sourceMapData, 'base64url').toString('utf8'), outputToSource);
+    return [
+      text.substring(0, sourceMapUrlPos),
+      prefix,
+      'base64,',
+      Buffer.from(rewritten, 'utf8').toString('base64url')
+    ].join('');
+  }
+
+  /**
+   * Rewrites the package.json to target .js files instead of .ts files, and pins versions
+   * @param manifest
+   * @param file
+   * @param text
+   * @returns
+   */
+  static rewritePackageJSON(manifest: ManifestRoot, text: string): string {
+    const pkg: Package = JSON.parse(text);
+    if (pkg.files) {
+      pkg.files = pkg.files.map(x => this.inputToOutput(x));
+    }
+    if (pkg.main) {
+      pkg.main = this.inputToOutput(pkg.main);
+    }
+    pkg.type = manifest.moduleType;
+    for (const key of ['devDependencies', 'dependencies', 'peerDependencies'] as const) {
+      if (key in pkg) {
+        for (const dep of Object.keys(pkg[key] ?? {})) {
+          if (dep in manifest.modules) {
+            pkg[key]![dep] = manifest.modules[dep].version;
+          }
+        }
+      }
+    }
+    return JSON.stringify(pkg, null, 2);
+  }
+
+  /**
+   * Build transpilation error
+   * @param filename The name of the file
+   * @param diagnostics The diagnostic errors
+   */
+  static buildTranspileError(filename: string, diagnostics: Error | readonly ts.Diagnostic[]): Error {
+    if (diagnostics instanceof Error) {
+      return diagnostics;
+    }
+
+    const errors: string[] = diagnostics.slice(0, 5).map(diag => {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+      if (diag.file) {
+        const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start!);
+        return ` @ ${diag.file.fileName.replace(nativeCwd, '.')}(${line + 1}, ${character + 1}): ${message}`;
+      } else {
+        return ` ${message}`;
+      }
+    });
+
+    if (diagnostics.length > 5) {
+      errors.push(`${diagnostics.length - 5} more ...`);
+    }
+    return new Error(`Transpiling ${filename.replace(nativeCwd, '.')} failed: \n${errors.join('\n')}`);
+  }
+
+  /**
+   * Naive hashing
+   */
+  static naiveHash(text: string): number {
+    let hash = 5381;
+
+    for (let i = 0; i < text.length; i++) {
+      // eslint-disable-next-line no-bitwise
+      hash = (hash * 33) ^ text.charCodeAt(i);
+    }
+
+    return Math.abs(hash);
+  }
+}

package/src/watch.ts

@@ -0,0 +1,142 @@
+import { readFileSync } from 'fs';
+import fs from 'fs/promises';
+
+import {
+  ManifestContext, ManifestModuleUtil, ManifestUtil, WatchEvent, ManifestModuleFolderType,
+  ManifestModuleFileType, path, ManifestModule, watchFolders, WatchEventListener
+} from '@travetto/manifest';
+import { getManifestContext } from '@travetto/manifest/bin/context';
+
+import { CompilerState } from './state';
+import { CompilerUtil } from './util';
+import { CompileEmitter, CompileWatcherHandler } from './types';
+
+/**
+ * Utils for watching
+ */
+export class CompilerWatcher {
+
+  #sourceHashes = new Map<string, number>();
+  #manifestContexts = new Map<string, ManifestContext>();
+  #dirtyFiles: { modFolder: string, mod: string, moduleFile?: string, folderKey?: ManifestModuleFolderType, type?: ManifestModuleFileType }[] = [];
+  #state: CompilerState;
+
+  constructor(state: CompilerState) {
+    this.#state = state;
+  }
+
+  async #rebuildManifestsIfNeeded(): Promise<void> {
+    if (!this.#dirtyFiles.length) {
+      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;
+    this.#dirtyFiles = [];
+
+    for (const ctx of [...contexts, this.#state.manifest]) {
+      const newManifest = await ManifestUtil.buildManifest(ctx);
+      for (const file of files) {
+        if (
+          file.folderKey && file.moduleFile && file.type &&
+          file.mod in newManifest.modules && file.folderKey in newManifest.modules[file.mod].files
+        ) {
+          newManifest.modules[file.mod].files[file.folderKey]!.push([file.moduleFile, file.type, Date.now()]);
+        }
+      }
+      await ManifestUtil.writeManifest(ctx, 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])
+    );
+  }
+
+  /**
+   * Get a watcher for a given compiler state
+   * @param state
+   * @param handler
+   * @returns
+   */
+  #getWatcher(handler: CompileWatcherHandler): WatchEventListener {
+    const mods = this.#getModuleMap();
+
+    return async ({ file: sourceFile, action }: WatchEvent, folder: string): Promise<void> => {
+      const mod = mods[folder];
+      const moduleFile = sourceFile.includes(mod.sourceFolder) ? sourceFile.split(`${mod.sourceFolder}/`)[1] : sourceFile;
+      switch (action) {
+        case 'create': {
+          const fileType = ManifestModuleUtil.getFileType(moduleFile);
+          this.#dirtyFiles.push({
+            mod: mod.name,
+            modFolder: folder,
+            moduleFile,
+            folderKey: ManifestModuleUtil.getFolderKey(sourceFile),
+            type: ManifestModuleUtil.getFileType(sourceFile)
+          });
+          if (CompilerUtil.validFile(fileType)) {
+            await this.#rebuildManifestsIfNeeded();
+
+            const hash = CompilerUtil.naiveHash(readFileSync(sourceFile, 'utf8'));
+            const input = this.#state.registerInput(mod, moduleFile);
+            this.#sourceHashes.set(sourceFile, hash);
+            handler.create(input);
+          }
+          break;
+        }
+        case 'update': {
+          await this.#rebuildManifestsIfNeeded();
+          const entry = this.#state.getBySource(sourceFile);
+          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);
+              handler.update(entry.input);
+            }
+          }
+          break;
+        }
+        case 'delete': {
+          const entry = this.#state.getBySource(sourceFile);
+          if (entry) {
+            this.#state.removeInput(entry.input);
+            if (entry.output) {
+              this.#dirtyFiles.push({ mod: mod.name, modFolder: folder });
+              handler.delete(entry.output);
+            }
+          }
+        }
+      }
+    };
+  }
+
+  /**
+   * Watch files based on root index
+   */
+  watchFiles(emit: CompileEmitter): Promise<() => Promise<void>> {
+    return watchFolders(
+      this.#state.manifestIndex.getLocalInputFolderMapping(),
+      this.#getWatcher({
+        create: emit,
+        update: emit,
+        delete: (outputFile) => fs.rm(outputFile, { force: true })
+      }),
+      {
+        filter: ev => ev.file.endsWith('.ts') || ev.file.endsWith('.js') || ev.file.endsWith('package.json'),
+        ignore: ['node_modules']
+      }
+    );
+  }
+}

package/support/compiler-entry.ts

@@ -0,0 +1,2 @@
+import { Compiler } from '../src/compiler';
+Compiler.main();

package/support/launcher.ts

@@ -0,0 +1,139 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+import type { ManifestContext } from '@travetto/manifest';
+
+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'];
+
+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: unknown) => void): Promise<CompileResult> {
+  let changes = 0;
+
+  await LogUtil.withLogger('precompile', async () => {
+    for (const mod of PRECOMPILE_MODS) {
+      changes += (await TranspileUtil.compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
+    }
+  });
+
+  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 (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 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/cli.js');
+      return import(cliMain);
+    }
+  }
+}

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[]);
+  }
+});