@travetto/compiler 5.0.2 → 5.0.3

package/bin/common.js

@@ -1,8 +1,6 @@
 // @ts-check
-import { statSync, readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, rmSync } from 'node:fs';
-import path from 'node:path';
-
-import { getManifestContext } from '@travetto/manifest/bin/context.js';
+const { statSync, readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, rmSync } = require('node:fs');
+const path = require('node:path');
 
 /** @typedef {import('@travetto/manifest').ManifestContext} Ctx */
 
@@ -36,13 +34,23 @@ const getTranspiler = async (/** @type {Ctx} */ ctx) => {
       .replace(/from '(@travetto\/[^/']+)([/][^']+)?'/g, (_, mod, file) => `from '${modPath(ctx, mod, file)}'`);
 };
 
-/** @returns {Promise<import('@travetto/compiler/support/entry.trvc')>} */
-async function imp(f = '') { try { return require(f); } catch { return import(f); } }
-
-export async function getEntry() {
+async function getEntry() {
   process.setSourceMapsEnabled(true); // Ensure source map during compilation/development
   process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps`; // Ensure it passes to children
 
+  // Load manifest without compiling, just stripping types away
+  const loc = require.resolve('@travetto/manifest').replace(/__index__.*/, 'src/context.ts');
+  const src = readFileSync(loc, 'utf8')
+    // Remove type information
+    .replace(/\s*[|]\s+undefined/g, '')
+    .replace(/<([^>]|\n)+>/gsm, '')
+    .replace(/: (string|[A-Z][a-zA-Z]+)/g, '')
+    .replace(/^(import )?type .*$/gm, '');
+
+  // Load module on demand
+  const { getManifestContext } = await import(`data:text/javascript;charset=utf-8,${encodeURIComponent(src)}`);
+
+  /** @type {Ctx} */
   const ctx = getManifestContext();
   const target = getTarget.bind(null, ctx);
 
@@ -67,9 +75,12 @@ export async function getEntry() {
 
   // Load
   try {
-    return await imp(target('support/entry.trvc.ts').dest).then(v => v.main(ctx));
+    const res = await import(target('support/entry.trvc.ts').dest);
+    return await res.main(ctx);
   } catch (err) {
     rmSync(target('.').dest, { recursive: true, force: true });
     throw err;
   }
-}
+}
+
+module.exports = { getEntry };

package/bin/trvc.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // @ts-check
-import { getEntry } from './common.js';
+const { getEntry } = require('./common.js');
 
 const help = () => [
   'npx trvc [command]',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -13,7 +13,6 @@
     "email": "travetto.framework@gmail.com",
     "name": "Travetto Framework"
   },
-  "type": "module",
   "files": [
     "__index__.ts",
     "src",
@@ -34,12 +33,12 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.4.1",
-    "@travetto/manifest": "^5.0.1",
-    "@travetto/transformer": "^5.0.2",
+    "@travetto/manifest": "^5.0.2",
+    "@travetto/transformer": "^5.0.3",
     "@types/node": "^22.5.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.2"
+    "@travetto/cli": "^5.0.3"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -27,6 +27,7 @@ export class Compiler {
     const state = await CompilerState.get(new ManifestIndex());
     log.debug('Running compiler with dirty file', dirty);
     const dirtyFiles = ManifestModuleUtil.getFileType(dirty) === 'ts' ? [dirty] : (await fs.readFile(dirty, 'utf8')).split(/\n/).filter(x => !!x);
+    log.debug('Running compiler with dirty file', dirtyFiles);
     await new Compiler(state, dirtyFiles, watch === 'true').run();
   }
 
@@ -41,7 +42,7 @@ export class Compiler {
     this.#state = state;
     this.#dirtyFiles = dirtyFiles[0] === '*' ?
       this.#state.getAllFiles() :
-      dirtyFiles.map(f => this.#state.getBySource(f)!.inputFile);
+      dirtyFiles.map(f => this.#state.getBySource(f)!.sourceFile);
     this.#watch = watch;
 
     this.#ctrl = new AbortController();
@@ -90,7 +91,7 @@ export class Compiler {
    * Compile in a single pass, only emitting dirty files
    */
   getCompiler(): CompileEmitter {
-    return (inputFile: string, needsNewProgram?: boolean) => this.#state.writeInputFile(inputFile, needsNewProgram);
+    return (sourceFile: string, needsNewProgram?: boolean) => this.#state.compileSourceFile(sourceFile, needsNewProgram);
   }
 
   /**
@@ -165,9 +166,9 @@ export class Compiler {
       try {
         for await (const ev of new CompilerWatcher(this.#state, this.#signal).watchChanges()) {
           if (ev.action !== 'delete') {
-            const err = await emitter(ev.entry.inputFile, true);
+            const err = await emitter(ev.entry.sourceFile, true);
             if (err) {
-              log.info('Compilation Error', CompilerUtil.buildTranspileError(ev.entry.inputFile, err));
+              log.info('Compilation Error', CompilerUtil.buildTranspileError(ev.entry.sourceFile, err));
             } else {
               log.info(`Compiled ${ev.entry.sourceFile} on ${ev.action}`);
             }

package/src/state.ts

@@ -9,16 +9,6 @@ import { CompilerUtil } from './util';
 import { CompileEmitError, CompileStateEntry } from './types';
 import { CommonUtil } from '../support/util';
 
-function folderMapper(root: string, prefix: string): { dir: string, translate: (val: string) => string } {
-  let matched: string = '~~';
-  prefix = `/${prefix}`;
-  const final = path.resolve(root).replace(/\/[^\/]+/, m => {
-    matched = m;
-    return prefix;
-  });
-  return { dir: final, translate: (file: string) => file.replace(prefix, matched) };
-}
-
 export class CompilerState implements ts.CompilerHost {
 
   static async get(idx: ManifestIndex): Promise<CompilerState> {
@@ -27,14 +17,12 @@ export class CompilerState implements ts.CompilerHost {
 
   private constructor() { }
 
-  #rootDir: string;
-  #inputPathToSourcePath: (file: string) => string;
   #outputPath: string;
-  #inputFiles = new Set<string>();
-  #inputDirectoryToSource = new Map<string, string>();
-  #inputToEntry = new Map<string, CompileStateEntry>();
+  #sourceFiles = new Set<string>();
+  #sourceDirectory = new Map<string, string>();
   #sourceToEntry = new Map<string, CompileStateEntry>();
   #outputToEntry = new Map<string, CompileStateEntry>();
+  #tscOutputFileToOuptut = new Map<string, string>();
 
   #sourceContents = new Map<string, string | undefined>();
   #sourceFileObjects = new Map<string, ts.SourceFile>();
@@ -47,18 +35,22 @@ export class CompilerState implements ts.CompilerHost {
   #compilerOptions: ts.CompilerOptions;
   #program: ts.Program;
 
-  #readFile(inputFile: string): string | undefined {
-    return ts.sys.readFile(this.#inputToEntry.get(inputFile)?.sourceFile ?? this.#inputPathToSourcePath(inputFile));
+  #readFile(sourceFile: string): string | undefined {
+    return ts.sys.readFile(this.#sourceToEntry.get(sourceFile)?.sourceFile ?? sourceFile);
   }
 
   async init(idx: ManifestIndex): Promise<this> {
     this.#manifestIndex = idx;
     this.#manifest = idx.manifest;
-    const mapper = folderMapper(this.#manifest.workspace.path, '##');
-    this.#rootDir = mapper.dir;
-    this.#inputPathToSourcePath = mapper.translate;
-
     this.#outputPath = path.resolve(this.#manifest.workspace.path, this.#manifest.build.outputFolder);
+
+
+    this.#compilerOptions = {
+      ...await TypescriptUtil.getCompilerOptions(this.#manifest),
+      rootDir: this.#manifest.workspace.path,
+      outDir: this.#outputPath
+    };
+
     this.#modules = Object.values(this.#manifest.modules);
 
     // Register all inputs
@@ -74,7 +66,7 @@ export class CompilerState implements ts.CompilerHost {
         ...base.$package ?? []
       ];
       for (const [file, type] of files) {
-        if (CompilerUtil.validFile(type) || type === 'typings') {
+        if (CompilerUtil.validFile(type)) {
           this.registerInput(x, file);
         }
       }
@@ -82,12 +74,6 @@ export class CompilerState implements ts.CompilerHost {
 
     this.#transformerManager = await TransformerManager.create(this.#manifestIndex);
 
-    this.#compilerOptions = {
-      ...await TypescriptUtil.getCompilerOptions(this.#manifest),
-      rootDir: this.#rootDir,
-      outDir: this.#outputPath
-    };
-
     return this;
   }
 
@@ -108,7 +94,7 @@ export class CompilerState implements ts.CompilerHost {
       .filter(x => x.files.src?.length)[0]
       .files.src[0].sourceFile;
 
-    return this.getBySource(randomSource)!.inputFile;
+    return this.getBySource(randomSource)!.sourceFile;
   }
 
   async createProgram(force = false): Promise<ts.Program> {
@@ -120,19 +106,25 @@ export class CompilerState implements ts.CompilerHost {
     return this.#program;
   }
 
-  async writeInputFile(inputFile: string, needsNewProgram = false): Promise<CompileEmitError | undefined> {
+  async compileSourceFile(sourceFile: string, needsNewProgram = false): Promise<CompileEmitError | undefined> {
+    const output = this.#sourceToEntry.get(sourceFile)?.outputFile;
+    if (!output) {
+      return;
+    }
+
     const program = await this.createProgram(needsNewProgram);
     try {
-      switch (ManifestModuleUtil.getFileType(inputFile)) {
+      switch (ManifestModuleUtil.getFileType(sourceFile)) {
+        case 'typings':
         case 'package-json':
-          this.writeFile(this.#inputToEntry.get(inputFile)!.outputFile!, this.readFile(inputFile)!, false), undefined;
+          this.writeFile(output, this.readFile(sourceFile)!, false), undefined;
           break;
         case 'js':
-          this.writeFile(this.#inputToEntry.get(inputFile)!.outputFile!, ts.transpile(this.readFile(inputFile)!, this.#compilerOptions), false);
+          this.writeFile(output, ts.transpile(this.readFile(sourceFile)!, this.#compilerOptions), false);
           break;
         case 'ts': {
           const result = program.emit(
-            program.getSourceFile(inputFile)!,
+            program.getSourceFile(sourceFile)!,
             (...args) => this.writeFile(...args), undefined, false,
             this.#transformerManager.get()
           );
@@ -153,78 +145,89 @@ export class CompilerState implements ts.CompilerHost {
   }
 
   registerInput(module: ManifestModule, moduleFile: string): CompileStateEntry {
-    const relativeInput = `${module.outputFolder}/${moduleFile}`;
-    const sourceFile = path.resolve(this.#manifest.workspace.path, module.sourceFolder, moduleFile);
+    const relativeSource = `${module.sourceFolder || '.'}/${moduleFile}`;
+    const relativeOutput = `${module.outputFolder}/${moduleFile}`;
+    const sourceFile = path.resolve(this.#manifest.workspace.path, relativeSource);
     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, ManifestModuleUtil.withOutputExtension(relativeInput));
+    const isTypings = fileType === 'typings';
+    const tscOutputFile = path.resolve(this.#outputPath, ManifestModuleUtil.withOutputExtension(relativeSource));
+    const outputFile = path.resolve(this.#outputPath, ManifestModuleUtil.withOutputExtension(relativeOutput));
 
-    const entry = { sourceFile, inputFile, outputFile, module };
+    const entry: CompileStateEntry = { sourceFile, outputFile, module, tscOutputFile };
 
-    this.#inputToEntry.set(inputFile, entry);
+    this.#outputToEntry.set(outputFile, entry);
+    this.#sourceFiles.add(sourceFile);
+    this.#sourceHashes.set(sourceFile, -1); // Unknown
     this.#sourceToEntry.set(sourceFile, entry);
-    this.#inputDirectoryToSource.set(inputFolder, sourceFolder);
+    this.#sourceDirectory.set(sourceFolder, sourceFolder);
+
+    this.#tscOutputFileToOuptut.set(tscOutputFile, outputFile);
+    this.#tscOutputFileToOuptut.set(`${tscOutputFile}.map`, `${outputFile}.map`);
 
-    if (outputFile) {
-      this.#outputToEntry.set(outputFile, entry);
+    if (!isTypings) {
+      const srcBase = `${ManifestModuleUtil.withoutSourceExtension(tscOutputFile)}.d.ts`;
+      const outBase = `${ManifestModuleUtil.withoutSourceExtension(outputFile)}.d.ts`;
+      this.#tscOutputFileToOuptut.set(`${srcBase}.map`, `${outBase}.map`);
+      this.#tscOutputFileToOuptut.set(srcBase, outBase);
     }
 
-    this.#inputFiles.add(inputFile);
-    this.#sourceHashes.set(sourceFile, -1); // Unknown
     return entry;
   }
 
-  checkIfSourceChanged(inputFile: string): boolean {
-    const contents = this.#readFile(inputFile);
-    const prevHash = this.#sourceHashes.get(inputFile);
+  checkIfSourceChanged(sourceFile: string): boolean {
+    const contents = this.#readFile(sourceFile);
+    const prevHash = this.#sourceHashes.get(sourceFile);
     if (!contents || (contents.length === 0 && prevHash)) {
       return false; // Ignore empty file
     }
     const currentHash = CommonUtil.naiveHash(contents);
     const changed = prevHash !== currentHash;
     if (changed) {
-      this.#sourceHashes.set(inputFile, currentHash);
-      this.#sourceContents.set(inputFile, contents);
-      this.#sourceFileObjects.delete(inputFile);
+      this.#sourceHashes.set(sourceFile, currentHash);
+      this.#sourceContents.set(sourceFile, contents);
+      this.#sourceFileObjects.delete(sourceFile);
     }
     return changed;
   }
 
-  removeInput(inputFile: string): void {
-    const { outputFile, sourceFile } = this.#inputToEntry.get(inputFile)!;
-    if (outputFile) {
-      this.#outputToEntry.delete(outputFile);
+  removeSource(sourceFile: string): void {
+    const entry = this.#sourceToEntry.get(sourceFile)!;
+    if (entry.outputFile) {
+      this.#outputToEntry.delete(entry.outputFile);
     }
-    this.#sourceFileObjects.delete(inputFile);
-    this.#sourceContents.delete(inputFile);
-    this.#sourceHashes.delete(inputFile);
+
+    this.#sourceFileObjects.delete(sourceFile);
+    this.#sourceContents.delete(sourceFile);
+    this.#sourceHashes.delete(sourceFile);
     this.#sourceToEntry.delete(sourceFile);
-    this.#inputToEntry.delete(inputFile);
-    this.#inputFiles.delete(inputFile);
+    this.#sourceFiles.delete(sourceFile);
+
+    const tscOutputDts = `${ManifestModuleUtil.withoutSourceExtension(entry.tscOutputFile)}.d.ts`;
+    this.#tscOutputFileToOuptut.delete(entry.tscOutputFile);
+    this.#tscOutputFileToOuptut.delete(`${entry.tscOutputFile}.map`);
+    this.#tscOutputFileToOuptut.delete(tscOutputDts);
+    this.#tscOutputFileToOuptut.delete(`${tscOutputDts}.map`);
   }
 
   getAllFiles(): string[] {
-    return [...this.#inputFiles];
+    return [...this.#sourceFiles];
   }
 
   /* Start Compiler Host */
   getCanonicalFileName(file: string): string { return file; }
-  getCurrentDirectory(): string { return this.#rootDir; }
+  getCurrentDirectory(): string { return this.#manifest.workspace.path; }
   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.#inputPathToSourcePath(inputFile));
+  fileExists(sourceFile: string): boolean {
+    return this.#sourceToEntry.has(sourceFile) || ts.sys.fileExists(sourceFile);
   }
 
-  directoryExists(inputDir: string): boolean {
-    return this.#inputDirectoryToSource.has(inputDir) || ts.sys.directoryExists(this.#inputPathToSourcePath(inputDir));
+  directoryExists(sourceDir: string): boolean {
+    return this.#sourceDirectory.has(sourceDir) || ts.sys.directoryExists(sourceDir);
   }
 
   writeFile(
@@ -237,25 +240,22 @@ export class CompilerState implements ts.CompilerHost {
   ): 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);
+    const location = this.#tscOutputFileToOuptut.get(outputFile)! ?? outputFile;
+    ts.sys.writeFile(location, text, bom);
   }
 
-  readFile(inputFile: string): string | undefined {
-    const res = this.#sourceContents.get(inputFile) ?? this.#readFile(inputFile);
-    this.#sourceContents.set(inputFile, res);
+  readFile(sourceFile: string): string | undefined {
+    const res = this.#sourceContents.get(sourceFile) ?? this.#readFile(sourceFile);
+    this.#sourceContents.set(sourceFile, 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));
+  getSourceFile(sourceFile: string, language: ts.ScriptTarget): ts.SourceFile {
+    if (!this.#sourceFileObjects.has(sourceFile)) {
+      const content = this.readFile(sourceFile)!;
+      this.#sourceFileObjects.set(sourceFile, ts.createSourceFile(sourceFile, content ?? '', language));
     }
-    return this.#sourceFileObjects.get(inputFile)!;
+    return this.#sourceFileObjects.get(sourceFile)!;
   }
 }

package/src/types.ts

@@ -5,4 +5,4 @@ import type { ManifestModule } from '@travetto/manifest';
 export type CompileEmitError = Error | readonly ts.Diagnostic[];
 export type CompileEmitter = (file: string, newProgram?: boolean) => Promise<CompileEmitError | undefined>;
 export type CompileEmitEvent = { file: string, i: number, total: number, err?: CompileEmitError };
-export type CompileStateEntry = { sourceFile: string, inputFile: string, outputFile?: string, module: ManifestModule };
+export type CompileStateEntry = { sourceFile: string, tscOutputFile: string, outputFile?: string, module: ManifestModule };

package/src/util.ts

@@ -1,8 +1,6 @@
 import ts from 'typescript';
 
-import { path, ManifestContext, ManifestModuleFileType, ManifestModuleUtil, ManifestRoot, Package } from '@travetto/manifest';
-
-type OutputToSource = (outputFile: string) => ({ sourceFile: string } | undefined);
+import { ManifestModuleFileType, ManifestModuleUtil, ManifestRoot, Package } from '@travetto/manifest';
 
 const nativeCwd = process.cwd();
 
@@ -14,57 +12,7 @@ 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';
-
-  /**
-   * 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 = ManifestModuleUtil.withOutputExtension(path.resolve(ctx.workspace.path, ctx.build.outputFolder, data.sources[0]));
-    const { sourceFile } = outputToSource(output) ?? {};
-
-    if (sourceFile) {
-      delete data.sourceRoot;
-      data.sources = [sourceFile];
-      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('');
-  }
+  static validFile = (type: ManifestModuleFileType): boolean => type === 'ts' || type === 'package-json' || type === 'js' || type === 'typings';
 
   /**
    * Rewrites the package.json to target output file names, and pins versions

package/src/watch.ts

@@ -189,10 +189,10 @@ export class CompilerWatcher {
           entry = this.#state.registerInput(mod, moduleFile);
         } else if (!entry) {
           continue;
-        } else if (action === 'update' && !this.#state.checkIfSourceChanged(entry.inputFile)) {
+        } else if (action === 'update' && !this.#state.checkIfSourceChanged(entry.sourceFile)) {
           continue;
         } else if (action === 'delete') {
-          this.#state.removeInput(entry.inputFile);
+          this.#state.removeSource(entry.sourceFile);
         }
 
         outEvents.push({ action, file: entry.sourceFile, entry });

package/support/setup.ts

@@ -33,26 +33,26 @@ export class CompilerSetup {
   };
 
   /**  Convert a file to a given ext */
-  static #sourceToExtension(inputFile: string, ext: string): string {
-    return inputFile.replace(/[.][tj]sx?$/, ext);
+  static #sourceToExtension(sourceFile: string, ext: string): string {
+    return sourceFile.replace(/[.][tj]sx?$/, ext);
   }
 
   /**
    * Get the output file name for a given input
    */
-  static #sourceToOutputExt(inputFile: string): string {
-    return this.#sourceToExtension(inputFile, '.js');
+  static #sourceToOutputExt(sourceFile: string): string {
+    return this.#sourceToExtension(sourceFile, '.js');
   }
 
   /**
    * Output a file, support for ts, js, and package.json
    */
-  static async #transpileFile(ctx: ManifestContext, inputFile: string, outputFile: string): Promise<void> {
-    const type = CommonUtil.getFileType(inputFile);
+  static async #transpileFile(ctx: ManifestContext, sourceFile: string, outputFile: string): Promise<void> {
+    const type = CommonUtil.getFileType(sourceFile);
     if (type === 'js' || type === 'ts') {
       const compilerOut = CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, 'node_modules');
 
-      const text = (await fs.readFile(inputFile, 'utf8'))
+      const text = (await fs.readFile(sourceFile, 'utf8'))
         .replace(/from '([.][^']+)'/g, (_, i) => `from '${i.replace(/[.]js$/, '')}.js'`)
         .replace(/from '(@travetto\/(.*?))'/g, (_, i, s) => `from '${compilerOut}/${i}${s.includes('/') ? '.js' : '/__index__.js'}'`);
 
@@ -61,10 +61,10 @@ export class CompilerSetup {
         ...await TypescriptUtil.getCompilerOptions(ctx),
         sourceMap: false,
         inlineSourceMap: true,
-      }, inputFile);
+      }, sourceFile);
       await CommonUtil.writeTextFile(outputFile, content);
     } else if (type === 'package-json') {
-      const pkg: Package = JSON.parse(await fs.readFile(inputFile, 'utf8'));
+      const pkg: Package = JSON.parse(await fs.readFile(sourceFile, 'utf8'));
       const main = pkg.main ? this.#sourceToOutputExt(pkg.main) : undefined;
       const files = pkg.files?.map(x => this.#sourceToOutputExt(x));
 

package/support/ts-util.ts

@@ -1,9 +1,10 @@
 import fs from 'node:fs/promises';
+import type { CompilerOptions } from 'typescript';
 
 import type { ManifestContext } from '@travetto/manifest';
 import { CommonUtil } from './util';
 
-const OPT_CACHE: Record<string, import('typescript').CompilerOptions> = {};
+const OPT_CACHE: Record<string, CompilerOptions> = {};
 
 export class TypescriptUtil {
   /**

package/tsconfig.trv.json

@@ -8,6 +8,8 @@
     ],
     "jsx": "react-jsx",
     "strict": true,
+    "declaration": true,
+    "declarationMap": true,
     "esModuleInterop": true,
     "strictPropertyInitialization": false,
     "experimentalDecorators": true,