@travetto/manifest 3.0.0-rc.6 → 3.0.0-rc.7

package/__index__.ts

@@ -2,9 +2,10 @@
 
 export * from './src/path';
 export * from './src/module';
+export * from './src/delta';
 export * from './src/manifest-index';
 export * from './src/root-index';
-export * from './src/delta';
 export * from './src/package';
-export * from './src/manifest';
-export * from './src/types';
+export * from './src/util';
+export * from './src/types';
+export * from './src/watch';

package/bin/context.d.ts

@@ -0,0 +1,10 @@
+import type { ManifestContext } from '../src/types';
+
+declare namespace ManifestBootstrap {
+  /**
+   * Get Context for building
+   */
+  function getManifestContext(folder?: string): Promise<ManifestContext>;
+}
+
+export = ManifestBootstrap;

package/bin/context.js

@@ -0,0 +1,94 @@
+// @ts-check
+
+/**
+ * @typedef {import('../src/types').Package} Pkg
+ * @typedef {import('../src/types').ManifestContext} ManifestContext
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { createRequire } from 'module';
+
+/**
+ * Returns the package.json
+ * @param {string} inputFolder
+ * @returns {Promise<Pkg>}
+ */
+async function $getPkg(inputFolder) {
+  if (!inputFolder.endsWith('.json')) {
+    inputFolder = path.resolve(inputFolder, 'package.json');
+  }
+  return JSON.parse(await fs.readFile(inputFolder, 'utf8'));
+}
+
+const WS_ROOT = {};
+
+/**
+ * Get workspace root
+ * @return {Promise<string>}
+ */
+async function $getWorkspaceRoot(base = process.cwd()) {
+  if (base in WS_ROOT) {
+    return WS_ROOT[base];
+  }
+
+  let folder = base;
+  let prevFolder = '';
+  while (folder !== prevFolder) {
+    try {
+      const pkg = await $getPkg(folder);
+      if (!!pkg.workspaces || !!pkg.travetto?.isolated) {
+        return (WS_ROOT[base] = folder);
+      }
+    } catch { }
+    if (await fs.stat(path.resolve(folder, '.git')).catch(() => { })) {
+      break;
+    }
+    prevFolder = folder;
+    folder = path.dirname(folder);
+  }
+  return WS_ROOT[base] = base;
+}
+
+
+/**
+ * Gets build context
+ * @param {string} [folder]
+ * @return {Promise<ManifestContext>}
+ */
+export async function getManifestContext(folder) {
+  const workspacePath = path.resolve(await $getWorkspaceRoot(folder));
+
+  // If manifest specified via env var, and is a package name
+  if (!folder && process.env.TRV_MODULE) {
+    const req = createRequire(`${workspacePath}/node_modules`);
+    try {
+      folder = path.dirname(req.resolve(`${process.env.TRV_MODULE}/package.json`));
+    } catch {
+      const workspacePkg = JSON.parse(await fs.readFile(path.resolve(workspacePath, 'package.json'), 'utf8'));
+      if (workspacePkg.name === process.env.TRV_MODULE) {
+        folder = workspacePath;
+      } else {
+        throw new Error(`Unable to resolve location for ${folder}`);
+      }
+    }
+  }
+
+  const mainPath = path.resolve(folder ?? '.');
+  const { name: mainModule, workspaces, travetto } = (await $getPkg(mainPath));
+  const monoRepo = workspacePath !== mainPath || !!workspaces;
+  const outputFolder = travetto?.outputFolder ?? '.trv_output';
+
+  const moduleType = (await $getPkg(workspacePath)).type ?? 'commonjs';
+  const mainFolder = mainPath === workspacePath ? '' : mainPath.replace(`${workspacePath}/`, '');
+
+  const res = {
+    moduleType,
+    mainModule,
+    mainFolder,
+    workspacePath,
+    monoRepo,
+    outputFolder,
+    compilerFolder: '.trv_compiler'
+  };
+  return res;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "3.0.0-rc.6",
+  "version": "3.0.0-rc.7",
   "description": "Manifest support",
   "keywords": [
     "path",
@@ -15,8 +15,10 @@
     "email": "travetto.framework@gmail.com",
     "name": "Travetto Framework"
   },
+  "type": "module",
   "files": [
     "__index__.ts",
+    "bin",
     "src",
     "support"
   ],
@@ -28,7 +30,14 @@
     "url": "https://github.com/travetto/travetto.git",
     "directory": "module/manifest"
   },
-  "dependencies": {},
+  "peerDependencies": {
+    "@parcel/watcher": "^2.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@parcel/watcher": {
+      "optional": true
+    }
+  },
   "travetto": {
     "displayName": "Manifest",
     "docBaseUrl": "https://github.com/travetto/travetto/tree/main"

package/src/delta.ts

@@ -1,12 +1,19 @@
-import { type Stats } from 'fs';
 import fs from 'fs/promises';
+import path from 'path';
+
 import {
-  ManifestDelta, ManifestDeltaEvent, ManifestDeltaModule,
-  ManifestModule, ManifestModuleFile, ManifestModuleFolderType,
-  ManifestRoot
+  ManifestContext, ManifestModule, ManifestModuleCore, ManifestModuleFile,
+  ManifestModuleFileType, ManifestModuleFolderType, ManifestRoot
 } from './types';
 
+import { ManifestModuleUtil } from './module';
+
+type DeltaEventType = 'added' | 'changed' | 'removed' | 'missing' | 'dirty';
+type DeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFile> };
+export type DeltaEvent = { file: string, type: DeltaEventType, module: string };
+
 const VALID_SOURCE_FOLDERS = new Set<ManifestModuleFolderType>(['bin', 'src', 'test', 'support', '$index', '$package', 'doc']);
+const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
 
 /**
  * Produce delta for the manifest
@@ -20,50 +27,37 @@ export class ManifestDeltaUtil {
   /**
    * Produce delta between two manifest modules, relative to an output folder
    */
-  static async #deltaModules(outputFolder: string, left: ManifestDeltaModule, right: ManifestDeltaModule): Promise<ManifestDeltaEvent[]> {
-    const out: ManifestDeltaEvent[] = [];
-    const getStat = (f: string): Promise<Stats | void> =>
-      fs.stat(`${outputFolder}/${left.output}/${f.replace(/[.]ts$/, '.js')}`).catch(() => { });
+  static async #deltaModules(ctx: ManifestContext, outputFolder: string, left: DeltaModule): Promise<DeltaEvent[]> {
+    const out: DeltaEvent[] = [];
 
-    const add = (file: string, type: ManifestDeltaEvent['type']): unknown =>
+    const add = (file: string, type: DeltaEvent['type']): unknown =>
       out.push({ file, module: left.name, type });
 
+    const root = `${ctx.workspacePath}/${ctx.outputFolder}/${left.outputFolder}`;
+    const right = new Set(
+      (await ManifestModuleUtil.scanFolder(root, left.main))
+        .filter(x => (x.endsWith('.ts') || x.endsWith('.js') || x.endsWith('package.json')))
+        .map(x => x.replace(`${root}/`, '').replace(/[.][tj]s$/, ''))
+    );
+
     for (const el of Object.keys(left.files)) {
-      if (!(el in right.files)) {
-        const [, , leftTs] = left.files[el];
-        const stat = await getStat(el);
-        if (stat && leftTs < this.#getNewest(stat)) {
-          // If file pre-exists manifest, be cool
-          continue;
-        }
+      const output = `${outputFolder}/${left.outputFolder}/${el.replace(/[.]ts$/, '.js')}`;
+      const [, , leftTs] = left.files[el];
+      const stat = await fs.stat(output).catch(() => { });
+      right.delete(el.replace(/[.][tj]s$/, ''));
+
+      if (!stat) {
         add(el, 'added');
       } else {
-        const [, , leftTs] = left.files[el];
-        const [, , rightTs] = right.files[el];
-        if (leftTs !== rightTs) {
-          const stat = await getStat(el);
-          if (!stat) {
-            add(el, 'missing');
-          } else if (leftTs > this.#getNewest(stat!)) {
-            add(el, 'changed');
-          }
-        } else {
-          const stat = await getStat(el);
-          if (!stat) {
-            add(el, 'missing');
-          } else if (this.#getNewest(stat!) < leftTs) {
-            add(el, 'dirty');
-          }
+        const rightTs = this.#getNewest(stat);
+        if (leftTs > rightTs) {
+          add(el, 'changed');
         }
       }
     }
-    for (const el of Object.keys(right.files)) {
-      if (!(el in left.files)) {
-        const stat = await getStat(el);
-        if (stat) {
-          add(el, 'removed');
-        }
-      }
+    // Deleted
+    for (const el of right) {
+      add(el, 'removed');
     }
     return out;
   }
@@ -81,7 +75,7 @@ export class ManifestDeltaUtil {
         continue;
       }
       for (const [name, type, date] of m.files?.[key] ?? []) {
-        if (type === 'ts' || type === 'js' || type === 'package-json') {
+        if (VALID_SOURCE_TYPE.has(type)) {
           out[name] = [name, type, date];
         }
       }
@@ -90,23 +84,19 @@ export class ManifestDeltaUtil {
   }
 
   /**
-   * Produce delta between ttwo manifest roots, relative to a single output folder
+   * Produce delta between manifest root and the output folder
    */
-  static async produceDelta(outputFolder: string, left: ManifestRoot, right: ManifestRoot): Promise<ManifestDelta> {
+  static async produceDelta(ctx: ManifestContext, manifest: ManifestRoot): Promise<DeltaEvent[]> {
     const deltaLeft = Object.fromEntries(
-      Object.values(left.modules)
-        .map(m => [m.name, { ...m, files: this.#flattenModuleFiles(m) }])
-    );
-
-    const deltaRight = Object.fromEntries(
-      Object.values(right.modules)
+      Object.values(manifest.modules)
         .map(m => [m.name, { ...m, files: this.#flattenModuleFiles(m) }])
     );
 
-    const out: Record<string, ManifestDeltaEvent[]> = {};
+    const out: DeltaEvent[] = [];
+    const outputFolder = path.resolve(ctx.workspacePath, ctx.outputFolder);
 
-    for (const [name, lMod] of Object.entries(deltaLeft)) {
-      out[name] = await this.#deltaModules(outputFolder, lMod, deltaRight[name] ?? { files: {}, name });
+    for (const lMod of Object.values(deltaLeft)) {
+      out.push(...await this.#deltaModules(manifest, outputFolder, lMod));
     }
 
     return out;

package/src/dependencies.ts

@@ -49,7 +49,7 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
   async init(req: PackageVisitReq<ModuleDep>): Promise<PackageVisitReq<ModuleDep>[]> {
     const pkg = PackageUtil.readPackage(req.sourcePath);
     const workspacePkg = PackageUtil.readPackage(this.ctx.workspacePath);
-    const workspaceModules = pkg.workspaces?.length ? (await PackageUtil.resolveWorkspaces(req.sourcePath)) : [];
+    const workspaceModules = pkg.workspaces?.length ? (await PackageUtil.resolveWorkspaces(this.ctx, req.sourcePath)) : [];
 
     this.#mainPatterns = ModuleDependencyVisitor.getMainPatterns(pkg.name, [
       ...pkg.travetto?.mainSource ?? [],

package/src/manifest-index.ts

@@ -1,5 +1,3 @@
-import fs from 'fs';
-
 import { path } from './path';
 
 import {
@@ -7,6 +5,8 @@ import {
   ManifestModuleFileType, ManifestModuleFolderType, ManifestProfile, ManifestRoot
 } from './types';
 
+import { ManifestUtil } from './util';
+
 type ScanTest = ((full: string) => boolean) | { test: (full: string) => boolean };
 export type FindConfig = {
   folders?: ManifestModuleFolderType[];
@@ -20,16 +20,17 @@ export type IndexedFile = {
   id: string;
   import: string;
   module: string;
-  source: string;
-  output: string;
-  relative: string;
+  sourceFile: string;
+  outputFile: string;
+  relativeFile: string;
   profile: ManifestProfile;
   type: ManifestModuleFileType;
 };
 
 export type IndexedModule = ManifestModuleCore & {
+  sourcePath: string;
+  outputPath: string;
   files: Record<ManifestModuleFolderType, IndexedFile[]>;
-  workspaceRelative: string;
 };
 
 /**
@@ -42,50 +43,51 @@ export class ManifestIndex {
   #modules: IndexedModule[];
   #modulesByName: Record<string, IndexedModule> = {};
   #modulesByFolder: Record<string, IndexedModule> = {};
-  #root: string;
+  #outputRoot: string;
   #outputToEntry = new Map<string, IndexedFile>();
   #sourceToEntry = new Map<string, IndexedFile>();
   #importToEntry = new Map<string, IndexedFile>();
 
-  constructor(root: string, manifest: string | ManifestRoot) {
-    this.init(root, manifest);
+  constructor(manifest: string) {
+    this.init(manifest);
   }
 
   #resolveOutput(...parts: string[]): string {
-    return path.resolve(this.#root, ...parts);
+    return path.resolve(this.#outputRoot, ...parts);
   }
 
   get manifest(): ManifestRoot {
     return this.#manifest;
   }
 
-  get root(): string {
-    return this.#root;
+  get outputRoot(): string {
+    return this.#outputRoot;
   }
 
   get manifestFile(): string {
     return this.#manifestFile;
   }
 
-  init(root: string, manifestInput: string | ManifestRoot): void {
-    this.#root = root;
-    this.#manifestFile = typeof manifestInput === 'string' ? manifestInput : manifestInput.manifestFile;
-    this.#manifest = typeof manifestInput === 'string' ? JSON.parse(fs.readFileSync(this.#manifestFile, 'utf8')) : manifestInput;
+  init(manifestInput: string): void {
+    const { manifest, file } = ManifestUtil.readManifestSync(manifestInput);
+    this.#manifest = manifest;
+    this.#manifestFile = file;
+    this.#outputRoot = path.resolve(this.#manifest.workspacePath, this.#manifest.outputFolder);
     this.#index();
   }
 
   #moduleFiles(m: ManifestModule, files: ManifestModuleFile[]): IndexedFile[] {
     return files.map(([f, type, ts, profile = 'std']) => {
-      const source = path.join(m.source, f);
+      const sourceFile = path.resolve(this.#manifest.workspacePath, m.sourceFolder, f);
       const js = (type === 'ts' ? f.replace(/[.]ts$/, '.js') : f);
-      const output = this.#resolveOutput(m.output, js);
+      const outputFile = this.#resolveOutput(m.outputFolder, js);
       const modImport = `${m.name}/${js}`;
       let id = modImport.replace(`${m.name}/`, _ => _.replace(/[/]$/, ':'));
       if (type === 'ts' || type === 'js') {
         id = id.replace(/[.]js$/, '');
       }
 
-      return { id, type, source, output, import: modImport, profile, relative: f, module: m.name };
+      return { id, type, sourceFile, outputFile, import: modImport, profile, relativeFile: f, module: m.name };
     });
   }
 
@@ -100,8 +102,8 @@ export class ManifestIndex {
     this.#modules = Object.values(this.manifest.modules)
       .map(m => ({
         ...m,
-        output: this.#resolveOutput(m.output),
-        workspaceRelative: m.source.replace(`${this.#manifest.workspacePath}/`, ''),
+        outputPath: this.#resolveOutput(m.outputFolder),
+        sourcePath: path.resolve(this.manifest.workspacePath, m.sourceFolder),
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         files: Object.fromEntries(
           Object.entries(m.files).map(([folder, files]) => [folder, this.#moduleFiles(m, files ?? [])])
@@ -111,15 +113,16 @@ export class ManifestIndex {
     for (const mod of this.#modules) {
       for (const files of Object.values(mod.files ?? {})) {
         for (const entry of files) {
-          this.#outputToEntry.set(entry.output, entry);
-          this.#sourceToEntry.set(entry.source, entry);
+          this.#outputToEntry.set(entry.outputFile, entry);
+          this.#sourceToEntry.set(entry.sourceFile, entry);
           this.#importToEntry.set(entry.import, entry);
           this.#importToEntry.set(entry.import.replace(/[.]js$/, ''), entry);
+          this.#importToEntry.set(entry.import.replace(/[.]js$/, '.ts'), entry);
         }
       }
     }
     this.#modulesByName = Object.fromEntries(this.#modules.map(x => [x.name, x]));
-    this.#modulesByFolder = Object.fromEntries(this.#modules.map(x => [x.workspaceRelative, x]));
+    this.#modulesByFolder = Object.fromEntries(this.#modules.map(x => [x.sourceFolder, x]));
   }
 
   /**
@@ -166,7 +169,7 @@ export class ManifestIndex {
 
     return searchSpace
       .filter(({ type }) => type === 'ts')
-      .filter(({ source }) => filter?.(source) ?? true);
+      .filter(({ sourceFile: source }) => filter?.(source) ?? true);
   }
 
   /**
@@ -218,8 +221,7 @@ export class ManifestIndex {
    * Resolve import
    */
   resolveFileImport(name: string): string {
-    name = !name.endsWith('.d.ts') ? name.replace(/[.]ts$/, '.js') : name;
-    return this.#importToEntry.get(name)?.output ?? name;
+    return this.#importToEntry.get(name)?.outputFile ?? name;
   }
 
   /**
@@ -247,6 +249,14 @@ export class ManifestIndex {
     return name ? this.getModule(name) : undefined;
   }
 
+  /**
+   * Get module from import name
+   * @param importName
+   */
+  getModuleFromImport(importName: string): IndexedModule | undefined {
+    const name = this.getFromImport(importName)?.module;
+    return name ? this.getModule(name) : undefined;
+  }
   /**
    * Build module list from an expression list (e.g. `@travetto/app,-@travetto/log)
    */

package/src/module.ts

@@ -29,6 +29,8 @@ const INDEX_FILES = new Set([
 
 export class ManifestModuleUtil {
 
+  static #scanCache: Record<string, string[]> = {};
+
   static #getNewest(stat: { mtimeMs: number, ctimeMs: number }): number {
     return Math.max(stat.mtimeMs, stat.ctimeMs);
   }
@@ -36,8 +38,19 @@ export class ManifestModuleUtil {
   /**
    * Simple file scanning
    */
-  static async #scanFolder(folder: string, topFolders = new Set<string>(), topFiles = new Set<string>()): Promise<string[]> {
+  static async scanFolder(folder: string, mainSource = false): Promise<string[]> {
+    if (!mainSource && folder in this.#scanCache) {
+      return this.#scanCache[folder];
+    }
+
+    if (!await fs.stat(folder).catch(() => false)) {
+      return [];
+    }
+
+    const topFolders = new Set(mainSource ? [] : ['src', 'bin', 'support']);
+    const topFiles = new Set(mainSource ? [] : [...INDEX_FILES, 'package.json']);
     const out: string[] = [];
+
     if (!fs.stat(folder).catch(() => false)) {
       return out;
     }
@@ -68,6 +81,11 @@ export class ManifestModuleUtil {
         }
       }
     }
+
+    if (!mainSource) {
+      this.#scanCache[folder] = out;
+    }
+
     return out;
   }
 
@@ -118,6 +136,8 @@ export class ManifestModuleUtil {
         return 'support/fixtures';
       } else if (moduleFile.startsWith('support/resources/')) {
         return 'support/resources';
+      } else if (moduleFile.startsWith('support/transform')) {
+        return '$transformer';
       }
       const key = moduleFile.substring(0, folderLocation);
       switch (key) {
@@ -152,13 +172,12 @@ export class ManifestModuleUtil {
   /**
    * Visit a module and describe files, and metadata
    */
-  static async describeModule(dep: ModuleDep): Promise<ManifestModule> {
+  static async describeModule(ctx: ManifestContext, dep: ModuleDep): Promise<ManifestModule> {
     const { main, mainSource, local, name, version, sourcePath, profileSet, parentSet, internal } = dep;
+
     const files: ManifestModule['files'] = {};
-    const folderSet = new Set<ManifestModuleFolderType>(mainSource ? [] : ['src', 'bin', 'support']);
-    const fileSet = new Set(mainSource ? [] : [...INDEX_FILES, 'package.json']);
 
-    for (const file of await this.#scanFolder(sourcePath, folderSet, fileSet)) {
+    for (const file of await this.scanFolder(sourcePath, mainSource)) {
       // Group by top folder
       const moduleFile = file.replace(`${sourcePath}/`, '');
       const entry = await this.transformFile(moduleFile, file);
@@ -173,9 +192,11 @@ export class ManifestModuleUtil {
 
     const profiles = [...profileSet].sort();
     const parents = [...parentSet].sort();
-    const output = `node_modules/${name}`;
+    const outputFolder = `node_modules/${name}`;
+    const sourceFolder = sourcePath === ctx.workspacePath ? '' : sourcePath.replace(`${ctx.workspacePath}/`, '');
 
-    return { main, name, version, local, internal, source: sourcePath, output, files, profiles, parents, };
+    const res = { main, name, version, local, internal, sourceFolder, outputFolder, files, profiles, parents, };
+    return res;
   }
 
   /**
@@ -183,10 +204,10 @@ export class ManifestModuleUtil {
    */
   static async produceModules(ctx: ManifestContext): Promise<Record<string, ManifestModule>> {
     const visitor = new ModuleDependencyVisitor(ctx);
-    const declared = await PackageUtil.visitPackages(ctx.mainPath, visitor);
+    const mainPath = path.resolve(ctx.workspacePath, ctx.mainFolder);
+    const declared = await PackageUtil.visitPackages(mainPath, visitor);
     const sorted = [...declared].sort((a, b) => a.name.localeCompare(b.name));
-
-    const modules = await Promise.all(sorted.map(x => this.describeModule(x)));
+    const modules = await Promise.all(sorted.map(x => this.describeModule(ctx, x)));
     return Object.fromEntries(modules.map(m => [m.name, m]));
   }
 }

package/src/package.ts

@@ -3,12 +3,12 @@ import fs from 'fs/promises';
 import { createRequire } from 'module';
 import { execSync } from 'child_process';
 
-import { Package, PackageDigest, PackageRel, PackageVisitor, PackageVisitReq, PackageWorkspaceEntry } from './types';
+import { ManifestContext, Package, PackageDigest, PackageRel, PackageVisitor, PackageVisitReq, PackageWorkspaceEntry } from './types';
 import { path } from './path';
 
 export class PackageUtil {
 
-  static #req = createRequire(`${path.cwd()}/node_modules`);
+  static #req = createRequire(path.resolve('node_modules'));
   static #framework: Package;
   static #cache: Record<string, Package> = {};
   static #workspaces: Record<string, PackageWorkspaceEntry[]> = {};
@@ -164,11 +164,18 @@ export class PackageUtil {
   /**
    * Find workspace values from rootPath
    */
-  static resolveWorkspaces(rootPath: string): PackageWorkspaceEntry[] {
+  static async resolveWorkspaces(ctx: ManifestContext, rootPath: string): Promise<PackageWorkspaceEntry[]> {
     if (!this.#workspaces[rootPath]) {
-      const text = execSync('npm query .workspace', { cwd: rootPath, encoding: 'utf8', env: {} });
-      const res: { location: string, name: string }[] = JSON.parse(text);
-      this.#workspaces[rootPath] = res.map(d => ({ sourcePath: d.location, name: d.name }));
+      await fs.mkdir(path.resolve(ctx.workspacePath, ctx.outputFolder), { recursive: true });
+      const cache = path.resolve(ctx.workspacePath, ctx.outputFolder, 'workspaces.json');
+      try {
+        return JSON.parse(await fs.readFile(cache, 'utf8'));
+      } catch {
+        const text = execSync('npm query .workspace', { cwd: rootPath, encoding: 'utf8', env: {} });
+        const res: { location: string, name: string }[] = JSON.parse(text);
+        const out = this.#workspaces[rootPath] = res.map(d => ({ sourcePath: d.location, name: d.name }));
+        await fs.writeFile(cache, JSON.stringify(out), 'utf8');
+      }
     }
     return this.#workspaces[rootPath];
   }

package/src/root-index.ts

@@ -1,6 +1,3 @@
-import { fileURLToPath } from 'url';
-import { createRequire } from 'module';
-
 import { path } from './path';
 import { IndexedModule, ManifestIndex } from './manifest-index';
 import { FunctionMetadata, Package, PackageDigest } from './types';
@@ -13,40 +10,16 @@ type Metadated = { [METADATA]: FunctionMetadata };
  * Extended manifest index geared for application execution
  */
 class $RootIndex extends ManifestIndex {
-  /**
-   * Load all source modules
-   */
-  static resolveManifestJSON(root: string, file?: string): string {
-    file = file || path.resolve(root, 'manifest.json');
-
-    // IF not a file
-    if (!file.endsWith('.json')) {
-      try {
-        // Try to resolve
-        const req = createRequire(path.resolve(root, 'node_modules'));
-        file = req.resolve(`${file}/manifest.json`);
-      } catch {
-        // Fallback to assumed node_modules pattern
-        file = `${root}/node_modules/${file}/manifest.json`;
-      }
-    }
-    return file;
-  }
 
   #config: Package | undefined;
-  #srcCache = new Map();
   #metadata = new Map<string, FunctionMetadata>();
 
-  constructor(output: string = process.env.TRV_OUTPUT ?? process.cwd()) {
-    super(output, $RootIndex.resolveManifestJSON(output, process.env.TRV_MANIFEST));
-  }
-
   /**
    * **WARNING**: This is a destructive operation, and should only be called before loading any code
    * @private
    */
   reinitForModule(module: string): void {
-    this.init(this.root, $RootIndex.resolveManifestJSON(this.root, module));
+    this.init(`${this.outputRoot}/node_modules/${module}`);
     this.#config = undefined;
   }
 
@@ -54,15 +27,15 @@ class $RootIndex extends ManifestIndex {
    * Determines if the manifest root is the root for a monorepo
    */
   isMonoRepoRoot(): boolean {
-    return !!this.manifest.monoRepo && this.manifest.workspacePath === this.manifest.mainPath;
+    return !!this.manifest.monoRepo && !this.manifest.mainFolder;
   }
 
   /**
    * Asynchronously load all source files from manifest
    */
   async loadSource(): Promise<void> {
-    for (const { output } of this.findSrc()) {
-      await import(output);
+    for (const { import: imp } of this.findSrc()) {
+      await import(imp);
     }
   }
 
@@ -87,14 +60,14 @@ class $RootIndex extends ManifestIndex {
    */
   get mainPackage(): Package {
     if (!this.#config) {
-      const { output: mainFolder } = this.getModule(this.manifest.mainModule)!;
+      const { outputPath } = this.getModule(this.manifest.mainModule)!;
       this.#config = {
         ...{
           name: 'untitled',
           description: 'A Travetto application',
           version: '0.0.0',
         },
-        ...PackageUtil.readPackage(mainFolder)
+        ...PackageUtil.readPackage(outputPath)
       };
     }
     return this.#config;
@@ -105,20 +78,11 @@ class $RootIndex extends ManifestIndex {
   }
 
   /**
-  * Get source file from output location
+  * Get source file from import location
   * @param outputFile
   */
-  getSourceFile(file: string): string {
-    if (!this.#srcCache.has(file)) {
-      if (file.startsWith('file:')) {
-        this.#srcCache.set(file, path.toPosix(fileURLToPath(file)));
-      } else {
-        this.#srcCache.set(file, path.toPosix(file));
-      }
-    }
-
-    const outputFile = this.#srcCache.get(file)!;
-    return this.getEntry(outputFile)?.source ?? outputFile;
+  getSourceFile(importFile: string): string {
+    return this.getFromImport(importFile)?.sourceFile ?? importFile;
   }
 
   /**
@@ -129,8 +93,8 @@ class $RootIndex extends ManifestIndex {
    * @param `methods` Methods and their hashes
    * @param `abstract` Is the class abstract
    */
-  registerFunction(cls: Function, file: string, hash: number, methods?: Record<string, { hash: number }>, abstract?: boolean, synthetic?: boolean): boolean {
-    const source = this.getSourceFile(file);
+  registerFunction(cls: Function, fileOrImport: string, hash: number, methods?: Record<string, { hash: number }>, abstract?: boolean, synthetic?: boolean): boolean {
+    const source = this.getSourceFile(fileOrImport);
     const id = this.getId(source, cls.name);
     Object.defineProperty(cls, 'Ⲑid', { value: id });
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -154,14 +118,32 @@ class $RootIndex extends ManifestIndex {
     const id = clsId === undefined ? '' : typeof clsId === 'string' ? clsId : clsId.Ⲑid;
     return this.#metadata.get(id);
   }
+
+  /**
+   * Get local folders that represent the user's controlled input
+   */
+  getLocalInputFolders(): string[] {
+    return this.getLocalModules()
+      .flatMap(x =>
+        (!this.manifest.monoRepo || x.sourcePath !== this.manifest.workspacePath) ?
+          [x.sourcePath] : [...Object.keys(x.files)].filter(y => !y.startsWith('$')).map(y => path.resolve(x.sourcePath, y))
+      );
+  }
+
+  /**
+   * Get local output folders
+   */
+  getLocalOutputFolders(): string[] {
+    return this.getLocalModules().map(x => x.outputPath);
+  }
 }
 
 let index: $RootIndex | undefined;
 
 try {
-  index = new $RootIndex();
+  index = new $RootIndex(process.env.TRV_MANIFEST!);
 } catch (err) {
-  if (process.env.TRV_THROW_ROOT_INDEX_ERR) {
+  if (/prod/i.test(process.env.NODE_ENV ?? '')) {
     throw err;
   }
 }

package/src/types.ts

@@ -3,7 +3,7 @@ export type ManifestModuleFolderType =
   '$root' | '$index' | '$package' |
   'src' | 'bin' | 'support' | 'resources' | 'test' | 'doc' |
   'test/fixtures' | 'support/fixtures' | 'support/resources' |
-  '$other';
+  '$other' | '$transformer';
 
 export type ManifestProfile = 'compile' | 'test' | 'doc' | 'build' | 'std';
 export type PackageRel = 'dev' | 'prod' | 'peer' | 'opt' | 'root' | 'global';
@@ -14,8 +14,8 @@ export type ManifestModuleCore = {
   main?: boolean;
   local?: boolean;
   version: string;
-  source: string;
-  output: string;
+  sourceFolder: string;
+  outputFolder: string;
   profiles: ManifestProfile[];
   parents: string[];
   internal?: boolean;
@@ -26,13 +26,13 @@ export type ManifestModule = ManifestModuleCore & {
 };
 
 export type ManifestContext = {
-  manifestFile: string;
   mainModule: string;
-  mainPath: string;
+  mainFolder: string;
   workspacePath: string;
   outputFolder: string;
   compilerFolder: string;
   monoRepo?: boolean;
+  moduleType: 'module' | 'commonjs';
 };
 
 export type ManifestRoot = ManifestContext & {
@@ -40,15 +40,6 @@ export type ManifestRoot = ManifestContext & {
   modules: Record<string, ManifestModule>;
 };
 
-export type ManifestDeltaEventType = 'added' | 'changed' | 'removed' | 'missing' | 'dirty';
-export type ManifestDeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFile> };
-export type ManifestDeltaEvent = { file: string, type: ManifestDeltaEventType, module: string };
-export type ManifestDelta = Record<string, ManifestDeltaEvent[]>;
-export type ManifestState = {
-  manifest: ManifestRoot;
-  delta: ManifestDelta;
-};
-
 export type Package = {
   name: string;
   type?: 'module' | 'commonjs';
@@ -116,4 +107,4 @@ export type FunctionMetadata = {
   methods?: Record<string, { hash: number }>;
   synthetic?: boolean;
   abstract?: boolean;
-};
+};

package/src/util.ts

@@ -0,0 +1,81 @@
+import { readFileSync } from 'fs';
+import fs from 'fs/promises';
+import os from 'os';
+
+import { path } from './path';
+import { ManifestContext, ManifestRoot } from './types';
+import { ManifestModuleUtil } from './module';
+
+export const MANIFEST_FILE = 'manifest.json';
+
+/**
+ * Manifest utils
+ */
+export class ManifestUtil {
+
+  static async writeJsonWithBuffer(ctx: ManifestContext, filename: string, obj: object): Promise<string> {
+    const tempName = path.resolve(ctx.workspacePath, ctx.mainFolder, filename).replace(/[\/\\: ]/g, '_');
+    const file = path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule, filename);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const temp = path.resolve(os.tmpdir(), `${tempName}.${Date.now()}`);
+    await fs.writeFile(temp, JSON.stringify(obj), 'utf8');
+    await fs.copyFile(temp, file);
+    fs.unlink(temp);
+    return file;
+  }
+
+  /**
+   * Build a manifest context
+   * @param folder
+   */
+  static async buildContext(folder?: string): Promise<ManifestContext> {
+    const { getManifestContext } = await import('../bin/context.js');
+    return getManifestContext(folder);
+  }
+
+  /**
+   * Produce manifest in memory
+   */
+  static async buildManifest(ctx: ManifestContext): Promise<ManifestRoot> {
+    return {
+      modules: await ManifestModuleUtil.produceModules(ctx),
+      generated: Date.now(),
+      ...ctx
+    };
+  }
+
+  /**
+   * Read manifest, synchronously
+   *
+   * @param file
+   * @returns
+   */
+  static readManifestSync(file: string): { manifest: ManifestRoot, file: string } {
+    file = path.resolve(file);
+    if (!file.endsWith('.json')) {
+      file = path.resolve(file, MANIFEST_FILE);
+    }
+    const manifest: ManifestRoot = JSON.parse(readFileSync(file, 'utf8'));
+    if (!manifest.outputFolder) {
+      manifest.outputFolder = path.cwd();
+      manifest.workspacePath = path.cwd();
+    }
+    return { manifest, file };
+  }
+
+  /**
+   * Write manifest for a given context, return location
+   */
+  static writeManifest(ctx: ManifestContext, manifest: ManifestRoot): Promise<string> {
+    return this.writeJsonWithBuffer(ctx, MANIFEST_FILE, manifest);
+  }
+
+  /**
+   * Rewrite manifest for a given folder
+   */
+  static async rewriteManifest(source: string): Promise<void> {
+    const subCtx = await this.buildContext(source);
+    const subManifest = await this.buildManifest(subCtx);
+    await this.writeManifest(subCtx, subManifest);
+  }
+}

package/src/watch.ts

@@ -0,0 +1,48 @@
+import fs from 'fs/promises';
+
+export type WatchEvent = { action: 'create' | 'update' | 'delete', file: string };
+
+type EventListener = (ev: WatchEvent, folder: string) => void;
+type EventFilter = (ev: WatchEvent) => boolean;
+type WatchConfig = { filter?: EventFilter, ignore?: string[] };
+
+async function getWatcher(): Promise<typeof import('@parcel/watcher')> {
+  try {
+    return await import('@parcel/watcher');
+  } catch (err) {
+    console.error('@parcel/watcher must be installed to use watching functionality');
+    throw err;
+  }
+}
+
+/**
+ * Leverages @parcel/watcher to watch a series of folders
+ * @param folders
+ * @param onEvent
+ * @private
+ */
+export async function watchFolders(folders: string[], onEvent: EventListener, config: WatchConfig = {}): Promise<() => Promise<void>> {
+  const lib = await getWatcher();
+  const subs = await Promise.all(folders.map(async folder => {
+    if (await fs.stat(folder).then(() => true, () => false)) {
+      const ignore = (await fs.readdir(folder)).filter(x => x.startsWith('.') && x.length > 2);
+      return lib.subscribe(folder, (err, events) => {
+        for (const ev of events) {
+          const finalEv = { action: ev.type, file: ev.path };
+          if (!config.filter || config.filter(finalEv)) {
+            onEvent(finalEv, folder);
+          }
+        }
+      }, { ignore: [...ignore, ...config.ignore ?? []] });
+    }
+  }));
+
+  // Allow for multiple calls
+  let finalProm: Promise<void> | undefined;
+  const remove = (): Promise<void> => finalProm ??= Promise.all(subs.map(x => x?.unsubscribe())).then(() => { });
+
+  // Cleanup on exit
+  process.on('exit', remove);
+
+  return remove;
+}

package/src/manifest.ts

@@ -1,110 +0,0 @@
-import fs from 'fs/promises';
-import os from 'os';
-
-import { path } from './path';
-import { ManifestContext, ManifestRoot, ManifestState } from './types';
-
-import { ManifestModuleUtil } from './module';
-import { ManifestDeltaUtil } from './delta';
-
-/**
- * Manifest utils
- */
-export class ManifestUtil {
-
-  /**
-   * Produce manifest in memory
-   */
-  static async buildManifest(ctx: ManifestContext): Promise<ManifestRoot> {
-    return {
-      modules: await ManifestModuleUtil.produceModules(ctx),
-      generated: Date.now(),
-      ...ctx
-    };
-  }
-
-  /**
-   * Generate manifest for a given context, and persist
-   */
-  static async createAndWriteManifest(ctx: ManifestContext): Promise<void> {
-    const manifest = await this.buildManifest(ctx);
-    await this.writeManifest(ctx, manifest);
-  }
-
-  /**
-   * Read manifest from a folder
-   */
-  static async readManifest(ctx: ManifestContext): Promise<ManifestRoot> {
-    const file = path.resolve(ctx.workspacePath, ctx.outputFolder, ctx.manifestFile);
-    if (await fs.stat(file).catch(() => false)) {
-      try {
-        return JSON.parse(await fs.readFile(file, 'utf8'));
-      } catch (err) {
-        await fs.unlink(file).catch(() => { });
-        const final = new Error(`Corrupted manifest ${ctx.manifestFile}: file has been removed, retry`);
-        if (err instanceof Error) {
-          final.stack = [final.message, ...(err.stack ?? '').split('\n').slice(1)].join('\n');
-        }
-        throw final;
-      }
-    } else {
-      return {
-        modules: {},
-        generated: Date.now(),
-        ...ctx,
-      };
-    }
-  }
-
-  /**
-   * Load state from disk
-   */
-  static async readState(file: string): Promise<ManifestState> {
-    return JSON.parse(await fs.readFile(file, 'utf8'));
-  }
-
-  /**
-   * Persist state to disk in a temp file, return said temp file
-   */
-  static async writeState(state: ManifestState, file?: string): Promise<string> {
-    const manifestTemp = file ?? path.resolve(os.tmpdir(), `manifest-state.${Date.now()}${Math.random()}.json`);
-    await fs.writeFile(manifestTemp, JSON.stringify(state), 'utf8');
-    return manifestTemp;
-  }
-
-  /**
-   * Generate the manifest and delta as a single output
-   */
-  static async produceState(ctx: ManifestContext): Promise<ManifestState> {
-    const manifest = await this.buildManifest(ctx);
-    const oldManifest = await this.readManifest(ctx);
-    const delta = await ManifestDeltaUtil.produceDelta(
-      path.resolve(manifest.workspacePath, ctx.outputFolder),
-      manifest,
-      oldManifest
-    );
-    return { manifest, delta };
-  }
-
-  /**
-   * Resolves a module file, from a context and manifest
-   */
-  static resolveFile(ctx: ManifestContext, manifest: ManifestRoot, module: string, file: string): string {
-    return path.resolve(
-      ctx.workspacePath,
-      ctx.compilerFolder,
-      manifest.modules[module].output,
-      file
-    );
-  }
-
-  /**
-   * Write manifest for a given context
-   */
-  static async writeManifest(ctx: ManifestContext, manifest: ManifestRoot): Promise<void> {
-    // Write manifest in the scenario we are in mono-repo state where everything pre-existed
-    const file = path.resolve(ctx.workspacePath, ctx.outputFolder, ctx.manifestFile);
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    await fs.writeFile(file, JSON.stringify(manifest));
-  }
-}