@travetto/manifest 3.3.2 → 3.4.0-rc.1

package/README.md

@@ -19,7 +19,6 @@ This module aims to be the boundary between the file system and the code.  The m
    *  Class and Function Metadata
    *  Runtime Indexing
    *  Path Normalization
-   *  File Watching
 
 ## Project Manifesting
 The project manifest fulfills two main goals: Compile-time Support, and Runtime Knowledge of the project.
@@ -31,7 +30,7 @@ During the compilation process, the compiler needs to know every file that is el
 Additionally, once the code has been compiled (or even bundled after that), the executing process needs to know what files are available for loading, and any patterns necessary for knowing which files to load versus which ones to ignore. This allows for dynamic loading of modules/files without knowledge/access to the file system, and in a more performant manner.
 
 ## Manifest Delta
-During the compilation process, it is helpful to know how the output content differs from the manifest, which is produced from the source input. The [ManifestDeltaUtil](https://github.com/travetto/travetto/tree/main/module/manifest/src/delta.ts#L21) provides the functionality for a given manifest, and will produce a stream of changes grouped by module.  This is the primary input into the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework")'s incremental behavior to know when a file has changed and needs to be recompiled.
+During the compilation process, it is helpful to know how the output content differs from the manifest, which is produced from the source input. The [ManifestDeltaUtil](https://github.com/travetto/travetto/tree/main/module/manifest/src/delta.ts#L20) provides the functionality for a given manifest, and will produce a stream of changes grouped by module.  This is the primary input into the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework")'s incremental behavior to know when a file has changed and needs to be recompiled.
 
 ## Class and Function Metadata
 For the framework to work properly, metadata needs to be collected about files, classes and functions to uniquely identify them, with support for detecting changes during live reloads.  To achieve this, every `class` is decorated with an additional field of `Ⲑid`.  `Ⲑid` represents a computed id that is tied to the file/class combination. 
@@ -87,75 +86,25 @@ Once the manifest is created, the application runtime can now read this manifest
 ## Path Normalization
 By default, all paths within the framework are assumed to be in a POSIX style, and all input paths are converted to the POSIX style.  This works appropriately within a Unix and a Windows environment.  This module offers up [path](https://github.com/travetto/travetto/tree/main/module/manifest/src/path.ts#L21) as an equivalent to [Node](https://nodejs.org)'s [http](https://nodejs.org/api/path.html) library.  This allows for consistent behavior across all file-interactions, and also allows for easy analysis if [Node](https://nodejs.org)'s [http](https://nodejs.org/api/path.html) library is ever imported.
 
-## File Watching
-The module also leverages [@parcel/watcher](https://www.npmjs.com/package/@parcel/watcher), to expose a single function of `watchFolders`. Only the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework") module packages [@parcel/watcher](https://www.npmjs.com/package/@parcel/watcher) as a direct dependency.  This means, that in production, by default all watch operations will fail with a missing dependency.
-
-**Code: Watch Configuration**
-```typescript
-export type WatchEvent = { action: 'create' | 'update' | 'delete', file: string, folder: string };
-
-export type WatchFolder = {
-  /**
-   * Source folder
-   */
-  src: string;
-  /**
-   * Target folder name, useful for deconstructing
-   */
-  target?: string;
-  /**
-   * Filter events
-   */
-  filter?: (ev: WatchEvent) => boolean;
-  /**
-   * Only look at immediate folder
-   */
-  immediate?: boolean;
-  /**
-   * List of top level folders to ignore
-   */
-  ignore?: string[];
-  /**
-   * If watching a folder that doesn't exist, should it be created?
-   */
-  createMissing?: boolean;
-  /**
-   * Include files that start with '.'
-   */
-  includeHidden?: boolean;
-};
-
-export type WatchStream = AsyncIterable<WatchEvent> & { close: () => Promise<void>, add: (item: WatchEvent | WatchEvent[]) => void };
-```
-
-This method allows for watching one or more folders, and registering a callback that will fire every time a file changes, and which of the registered folders it was triggered within. The return of the `watchFolders` is a cleanup method, that when invoked will remove and stop all watching behavior.
-
-**Code: Watch Configuration**
-```typescript
-export function watchFolders(
-  folders: string[] | WatchFolder[],
-  config: Omit<WatchFolder, 'src' | 'target'> = {}
-): WatchStream {
-```
-
 ## Anatomy of a Manifest
 
 **Code: Manifest for @travetto/manifest**
 ```typescript
 {
   "generated": 1868155200000,
-  "moduleType": "commonjs",
-  "mainModule": "@travetto/manifest",
-  "mainFolder": "module/manifest",
   "workspacePath": "<generated>",
   "monoRepo": true,
-  "outputFolder": ".trv_output",
-  "toolFolder": ".trv_build",
-  "compilerFolder": ".trv_compiler",
   "packageManager": "npm",
+  "moduleType": "commonjs",
+  "outputFolder": ".trv/output",
+  "toolFolder": ".trv/tool",
+  "compilerFolder": ".trv/compiler",
+  "compilerUrl": "http://127.0.0.1:26803",
+  "frameworkVersion": "x.x.x",
+  "mainModule": "@travetto/manifest",
+  "mainFolder": "module/manifest",
   "version": "x.x.x",
   "description": "Support for project indexing, manifesting, along with file watching",
-  "frameworkVersion": "x.x.x",
   "modules": {
     "@travetto/manifest": {
       "main": true,
@@ -165,6 +114,9 @@ export function watchFolders(
       "internal": false,
       "sourceFolder": "module/manifest",
       "outputFolder": "node_modules/@travetto/manifest",
+      "roles": [ "std" ],
+      "parents": [],
+      "prod": true,
       "files": {
         "$root": [
           [ "DOC.html", "unknown", 1868155200000 ],
@@ -195,6 +147,7 @@ export function watchFolders(
         "src": [
           [ "src/delta.ts", "ts", 1868155200000 ],
           [ "src/dependencies.ts", "ts", 1868155200000 ],
+          [ "src/file.ts", "ts", 1868155200000 ],
           [ "src/manifest-index.ts", "ts", 1868155200000 ],
           [ "src/module.ts", "ts", 1868155200000 ],
           [ "src/package.ts", "ts", 1868155200000 ],
@@ -202,16 +155,13 @@ export function watchFolders(
           [ "src/root-index.ts", "ts", 1868155200000 ],
           [ "src/types.ts", "ts", 1868155200000 ],
           [ "src/typings.d.ts", "typings", 1868155200000 ],
-          [ "src/util.ts", "ts", 1868155200000 ],
-          [ "src/watch.ts", "ts", 1868155200000 ]
+          [ "src/util.ts", "ts", 1868155200000 ]
         ],
         "bin": [
           [ "bin/context.d.ts", "typings", 1868155200000 ],
           [ "bin/context.js", "js", 1868155200000 ]
         ]
-      },
-      "profiles": [ "std" ],
-      "parents": []
+      }
     }
   }
 }

package/__index__.ts

@@ -7,5 +7,5 @@ export * from './src/manifest-index';
 export * from './src/root-index';
 export * from './src/package';
 export * from './src/util';
-export * from './src/types';
-export * from './src/watch';
+export * from './src/file';
+export * from './src/types';

package/bin/context.js

@@ -1,131 +1,161 @@
 // @ts-check
 
 /**
- * @typedef {import('../src/types').Package} Pkg
+ * @typedef {import('../src/types').Package & { path:string }} Pkg
+ * @typedef {Pkg & { mono: boolean, manager: 'yarn'|'npm', resolve: (file:string) => string}} Workspace
  * @typedef {import('../src/types').ManifestContext} ManifestContext
  */
 import fs from 'fs/promises';
 import path from 'path';
 import { createRequire } from 'module';
 
+/** @type {Record<string, Workspace>} */ const WS_ROOT = {};
+const TOOL_FOLDER = '.trv/tool';
+const COMPILER_FOLDER = '.trv/compiler';
+const OUTPUT_FOLDER = '.trv/output';
+
 /**
- * Returns the package.json
- * @param {string} inputFolder
- * @returns {Promise<Pkg>}
+ * Read package.json or return undefined if missing
+ * @param {string} dir
+ * @returns {Promise<Pkg|undefined>}
  */
-async function $getPkg(inputFolder) {
-  if (!inputFolder.endsWith('.json')) {
-    inputFolder = path.resolve(inputFolder, 'package.json');
-  }
-  return JSON.parse(await fs.readFile(inputFolder, 'utf8'));
+async function $readPackage(dir) {
+  dir = dir.endsWith('.json') ? path.dirname(dir) : dir;
+  return await fs.readFile(path.resolve(dir, 'package.json'), 'utf8')
+    .then(v => ({ ...JSON.parse(v), path: path.resolve(dir) }), () => undefined);
 }
 
-const WS_ROOT = {};
-
 /**
- * Get module root for a given folder
+ * Find package.json for a given folder
  * @param {string} dir
- * @return {Promise<string>}
+ * @return {Promise<Pkg>}
  */
-async function $getModuleRoot(dir) {
+async function $findPackage(dir) {
   let prev;
-  while (dir !== prev && !(await fs.stat(path.resolve(dir, 'package.json')).catch(() => false))) {
-    prev = dir;
-    dir = path.dirname(dir);
+  let pkg, curr = path.resolve(dir);
+  while (!pkg && curr !== prev) {
+    pkg = await $readPackage(curr);
+    [prev, curr] = [curr, path.dirname(curr)];
+  }
+  if (!pkg) {
+    throw new Error('Could not find a package.json');
+  } else {
+    return pkg;
   }
-  return dir;
-}
-
-
-/**
- * Get module name from a given file
- * @param {string} file
- * @return {Promise<string|void>}
- */
-async function $getModuleFromFile(file) {
-  return $getPkg(await $getModuleRoot(path.dirname(file))).then(v => v.name, () => { });
 }
 
 /**
  * Get workspace root
- * @return {Promise<string>}
+ * @return {Promise<Workspace>}
  */
-async function $getWorkspaceRoot(base = process.cwd()) {
-  if (base in WS_ROOT) {
-    return WS_ROOT[base];
-  }
-
+async function $resolveWorkspace(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(() => { })) {
+  let prev;
+  /** @type {Pkg|undefined} */
+  let prevPkg, pkg;
+
+  while (prev !== folder) {
+    [prev, prevPkg] = [folder, pkg];
+    pkg = await $readPackage(folder) ?? pkg;
+    if (
+      (pkg && (!!pkg.workspaces || !!pkg.travetto?.isolated)) || // if we have a monorepo root, or we are isolated
+      await fs.stat(path.resolve(folder, '.git')).catch(() => { }) // we made it to the source repo root
+    ) {
       break;
     }
-    prevFolder = folder;
     folder = path.dirname(folder);
   }
-  return WS_ROOT[base] = base;
-}
 
+  if (!pkg) {
+    throw new Error('Could not find a package.json');
+  }
+
+  return WS_ROOT[base] = {
+    ...pkg,
+    manager: await fs.stat(path.resolve(pkg.path, 'yarn.lock')).catch(() => { }) ? 'yarn' : 'npm',
+    resolve: createRequire(`${pkg.path}/node_modules`).resolve.bind(null),
+    mono: !!pkg.workspaces || (!pkg.travetto?.isolated && !!prevPkg)  // Workspaces or nested projects
+  };
+}
 
 /**
- * Gets build context
- * @param {string} [folder]
- * @return {Promise<ManifestContext>}
+ * Get Compiler url
+ * @param {Workspace} ws
  */
-export async function getManifestContext(folder) {
-  const workspacePath = path.resolve(await $getWorkspaceRoot(folder));
-  const req = createRequire(`${workspacePath}/node_modules`);
+async function $getCompilerUrl(ws) {
+  let out = ws.travetto?.compilerUrl;
+  if (!out) {
+    const file = path.resolve(ws.path, ws.travetto?.toolFolder ?? TOOL_FOLDER, 'compiler.url');
+    // eslint-disable-next-line no-bitwise
+    const port = (Math.abs([...file].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
+    out = `http://localhost:${port}`;
+    try { await fs.stat(file); } catch {
+      await fs.mkdir(path.dirname(file), { recursive: true });
+      await fs.writeFile(file, out, 'utf8');
+    }
+  }
+  return out.replace('localhost', '127.0.0.1');
+}
 
-  // If manifest specified via env var, and is a package name
+/**
+ * Resolve module folder
+ * @param {Workspace} workspace
+ * @param {string|undefined} folder
+ */
+async function $resolveModule(workspace, folder) {
+  let mod;
   if (!folder && process.env.TRV_MODULE) {
-    // If module is actually a file, try to detect
-    if (/[.](t|j)s$/.test(process.env.TRV_MODULE)) {
-      process.env.TRV_MODULE = await $getModuleFromFile(process.env.TRV_MODULE) ?? process.env.TRV_MODULE;
+    mod = process.env.TRV_MODULE;
+    if (/[.](t|j)s$/.test(mod)) { // Rewrite from file to module
+      process.env.TRV_MODULE = mod = await $findPackage(path.dirname(mod))
+        .then(v => v.name, () => '');
     }
+  }
+
+  if (mod) { // If module provided in lieu of folder
     try {
-      folder = path.dirname(req.resolve(`${process.env.TRV_MODULE}/package.json`));
+      folder = path.dirname(workspace.resolve(`${mod}/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;
+      const workspacePkg = await $readPackage(workspace.path);
+      if (workspacePkg?.name === mod) {
+        folder = workspace.path;
       } else {
         throw new Error(`Unable to resolve location for ${folder}`);
       }
     }
   }
 
-  const mainPath = await $getModuleRoot(path.resolve(folder ?? '.'));
-  const { name: mainModule, workspaces, travetto, version, description } = (await $getPkg(mainPath));
-  const monoRepo = workspacePath !== mainPath || !!workspaces;
-  const outputFolder = travetto?.outputFolder ?? '.trv_output';
+  return $findPackage(folder ?? '.');
+}
 
-  const moduleType = (await $getPkg(workspacePath)).type ?? 'commonjs';
-  const mainFolder = mainPath === workspacePath ? '' : mainPath.replace(`${workspacePath}/`, '');
-  /** @type {'yarn'|'npm'} */
-  const packageManager = await fs.stat(path.resolve(workspacePath, 'yarn.lock')).then(() => 'yarn', () => 'npm');
+/**
+ * Gets build context
+ * @param {string} [folder]
+ * @return {Promise<ManifestContext>}
+ */
+export async function getManifestContext(folder) {
+  const workspace = await $resolveWorkspace(folder);
 
-  const { version: frameworkVersion } = JSON.parse(await fs.readFile(req.resolve('@travetto/manifest/package.json'), 'utf8'));
+  const [mod, framework, compilerUrl] = await Promise.all([
+    $resolveModule(workspace, folder),
+    $readPackage(workspace.resolve('@travetto/manifest/package.json')),
+    $getCompilerUrl(workspace),
+  ]);
 
-  const res = {
-    moduleType,
-    mainModule: mainModule ?? 'untitled', // When root package.json is missing a name
-    mainFolder,
-    workspacePath,
-    monoRepo,
-    outputFolder,
-    toolFolder: '.trv_build',
-    compilerFolder: '.trv_compiler',
-    packageManager,
-    version,
-    description,
-    frameworkVersion
+  return {
+    workspacePath: workspace.path,
+    monoRepo: workspace.mono,
+    packageManager: workspace.manager,
+    moduleType: workspace.type ?? 'commonjs',
+    outputFolder: workspace.travetto?.outputFolder ?? OUTPUT_FOLDER,
+    toolFolder: workspace.travetto?.toolFolder ?? TOOL_FOLDER,
+    compilerFolder: workspace.travetto?.compilerFolder ?? COMPILER_FOLDER,
+    compilerUrl,
+    frameworkVersion: framework?.version ?? '1.0.0',
+    mainModule: mod.name ?? 'untitled',
+    mainFolder: mod.path === workspace.path ? '' : mod.path.replace(`${workspace.path}/`, ''),
+    version: mod.version,
+    description: mod.description
   };
-  return res;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "3.3.2",
+  "version": "3.4.0-rc.1",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
     "path",
@@ -30,14 +30,6 @@
     "url": "https://github.com/travetto/travetto.git",
     "directory": "module/manifest"
   },
-  "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,11 @@
-import fs from 'fs/promises';
-import path from 'path';
-
 import {
   ManifestContext, ManifestModule, ManifestModuleCore, ManifestModuleFile,
   ManifestModuleFileType, ManifestModuleFolderType, ManifestRoot
 } from './types';
 
 import { ManifestModuleUtil } from './module';
+import { ManifestFileUtil } from './file';
+import { path } from './path';
 
 type DeltaEventType = 'added' | 'changed' | 'removed' | 'missing' | 'dirty';
 type DeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFile> };
@@ -46,7 +45,7 @@ export class ManifestDeltaUtil {
     for (const el of Object.keys(left.files)) {
       const output = ManifestModuleUtil.sourceToOutputExt(`${outputFolder}/${left.outputFolder}/${el}`);
       const [, , leftTs] = left.files[el];
-      const stat = await fs.stat(output).catch(() => { });
+      const stat = await ManifestFileUtil.statFile(output);
       right.delete(ManifestModuleUtil.sourceToBlankExt(el));
 
       if (!stat) {

package/src/dependencies.ts

@@ -1,8 +1,9 @@
 import { PackageUtil } from './package';
 import { path } from './path';
-import { ManifestContext, ManifestProfile, PackageRel, PackageVisitor, PackageVisitReq } from './types';
+import { ManifestContext, ManifestModuleRole, PackageVisitor, PackageVisitReq, Package } from './types';
 
 export type ModuleDep = {
+  pkg: Package;
   version: string;
   name: string;
   main?: boolean;
@@ -10,9 +11,11 @@ export type ModuleDep = {
   local?: boolean;
   internal?: boolean;
   sourcePath: string;
-  childSet: Map<string, Set<PackageRel>>;
+  childSet: Set<string>;
   parentSet: Set<string>;
-  profileSet: Set<ManifestProfile>;
+  roleSet: Set<ManifestModuleRole>;
+  prod: boolean;
+  topLevel?: boolean;
 };
 
 /**
@@ -60,19 +63,13 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
       ...workspaceModules.map(x => x.name)
     ]);
 
-    const globals = [
-      ...(workspacePkg.travetto?.globalModules ?? []),
-      ...(pkg.travetto?.globalModules ?? [])
-    ]
-      .map(f => PackageUtil.resolvePackagePath(f));
+    const globals = (workspacePkg.travetto?.globalModules ?? [])
+      .map(name => PackageUtil.packageReq<ModuleDep>(PackageUtil.resolvePackagePath(name), name in (workspacePkg.dependencies ?? {}), true));
 
     const workspaceModuleDeps = workspaceModules
-      .map(entry => path.resolve(req.sourcePath, entry.sourcePath));
+      .map(entry => PackageUtil.packageReq<ModuleDep>(path.resolve(req.sourcePath, entry.sourcePath), false, true));
 
-    return [
-      ...globals,
-      ...workspaceModuleDeps
-    ].map(s => PackageUtil.packageReq(s, 'global'));
+    return [...globals, ...workspaceModuleDeps];
   }
 
   /**
@@ -80,8 +77,7 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
    */
   valid(req: PackageVisitReq<ModuleDep>): boolean {
     return req.sourcePath === this.#mainSourcePath || (
-      req.rel !== 'peer' &&
-      (!!req.pkg.travetto || req.pkg.private === true || !req.sourcePath.includes('node_modules') || req.rel === 'global')
+      (!!req.pkg.travetto || req.pkg.private === true || !req.sourcePath.includes('node_modules'))
     );
   }
 
@@ -89,18 +85,16 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
    * Create dependency from request
    */
   create(req: PackageVisitReq<ModuleDep>): ModuleDep {
-    const { pkg: { name, version, travetto: { profiles = [] } = {}, ...pkg }, sourcePath } = req;
-    const profileSet = new Set<ManifestProfile>([
-      ...profiles ?? []
-    ]);
+    const { pkg, sourcePath } = req;
+    const { name, version } = pkg;
     const main = name === this.ctx.mainModule;
     const mainSource = main || this.#mainPatterns.some(x => x.test(name));
     const internal = pkg.private === true;
     const local = internal || mainSource || !sourcePath.includes('node_modules');
 
     const dep = {
-      name, version, sourcePath, main, mainSource, local, internal,
-      parentSet: new Set([]), childSet: new Map(), profileSet
+      name, version, sourcePath, main, mainSource, local, internal, pkg: req.pkg,
+      parentSet: new Set([]), childSet: new Set([]), roleSet: new Set([]), prod: req.prod, topLevel: req.topLevel
     };
 
     return dep;
@@ -113,28 +107,30 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
     const { parent } = req;
     if (parent && dep.name !== this.ctx.mainModule) {
       dep.parentSet.add(parent.name);
-      const set = parent.childSet.get(dep.name) ?? new Set();
-      parent.childSet.set(dep.name, set);
-      set.add(req.rel);
+      parent.childSet.add(dep.name);
     }
   }
 
   /**
-   * Propagate profile/relationship information through graph
+   * Propagate prod, role information through graph
    */
   complete(deps: Set<ModuleDep>): Set<ModuleDep> {
-    const mapping = new Map<string, { parent: Set<string>, child: Map<string, Set<PackageRel>>, el: ModuleDep }>();
+    const mapping = new Map<string, { parent: Set<string>, child: Set<string>, el: ModuleDep }>();
     for (const el of deps) {
-      mapping.set(el.name, { parent: new Set(el.parentSet), child: new Map(el.childSet), el });
+      mapping.set(el.name, { parent: new Set(el.parentSet), child: new Set(el.childSet), el });
     }
 
     const main = mapping.get(this.ctx.mainModule)!;
 
     // Visit all direct dependencies and mark
-    for (const [name, relSet] of main.child) {
-      const childDep = mapping.get(name)!.el;
-      if (!relSet.has('dev')) {
-        childDep.profileSet.add('std');
+    for (const { el } of mapping.values()) {
+      if (el.topLevel) {
+        el.roleSet = new Set(el.pkg.travetto?.roles ?? []);
+        if (!el.roleSet.size) {
+          el.roleSet.add('std');
+        }
+      } else if (!main.child.has(el.name)) { // Not a direct descendent
+        el.prod = false;
       }
     }
 
@@ -148,9 +144,10 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
         for (const c of child.keys()) {
           const { el: cDep, parent } = mapping.get(c)!;
           parent.delete(el.name); // Remove from child
-          for (const prof of el.profileSet) {
-            cDep.profileSet.add(prof);
+          for (const role of el.roleSet) {
+            cDep.roleSet.add(role);
           }
+          cDep.prod ||= el.prod; // Allow prod to trickle down as needed
         }
       }
       // Remove from mapping
@@ -159,8 +156,10 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
       }
     }
 
-    // Color the main folder as std
-    main.el.profileSet.add('std');
+    // Color parent as final step
+    main.el.prod = true;
+    main.el.roleSet.add('std');
+
     return deps;
   }
 }

package/src/file.ts

@@ -0,0 +1,55 @@
+import os from 'os';
+import fs from 'fs/promises';
+import { readFileSync } from 'fs';
+
+import { path } from './path';
+import type { ManifestContext } from './types';
+
+export class ManifestFileUtil {
+  /**
+   * Write file and copy over when ready
+   */
+  static async bufferedFileWrite(file: string, content: string | object): Promise<string> {
+    const ext = path.extname(file);
+    const tempName = `${path.basename(file, ext)}.${process.ppid}.${process.pid}.${Date.now()}.${Math.random()}${ext}`;
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const temp = path.resolve(os.tmpdir(), tempName);
+    await fs.writeFile(temp, typeof content === 'string' ? content : JSON.stringify(content), 'utf8');
+    await fs.copyFile(temp, file);
+    fs.unlink(temp);
+    return file;
+  }
+
+  /**
+   * Read as json
+   */
+  static async readAsJson<T = unknown>(file: string): Promise<T> {
+    return JSON.parse(await fs.readFile(file, 'utf8'));
+  }
+
+  /**
+   * Read as json, sync
+   */
+  static readAsJsonSync<T = unknown>(file: string): T {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  }
+
+  /**
+   * Stat file
+   */
+  static statFile(file: string): Promise<{ mtimeMs: number, ctimeMs: number } | undefined> {
+    return fs.stat(file).catch(() => undefined);
+  }
+
+  /**
+   * Resolve tool path for usage
+   */
+  static toolPath(ctx: ManifestContext | { manifest: ManifestContext }, rel: string, moduleSpecific = false): string {
+    ctx = 'manifest' in ctx ? ctx.manifest : ctx;
+    const parts = [rel];
+    if (moduleSpecific) {
+      parts.unshift('node_modules', ctx.mainModule);
+    }
+    return path.resolve(ctx.workspacePath, ctx.toolFolder, ...parts);
+  }
+}

package/src/manifest-index.ts

@@ -3,18 +3,16 @@ import { path } from './path';
 
 import {
   ManifestModule, ManifestModuleCore, ManifestModuleFile,
-  ManifestModuleFileType, ManifestModuleFolderType, ManifestProfile, ManifestRoot
+  ManifestModuleFileType, ManifestModuleFolderType, ManifestModuleRole, ManifestRoot
 } from './types';
 
 import { ManifestUtil } from './util';
 
-type ScanTest = ((full: string) => boolean) | { test: (full: string) => boolean };
 export type FindConfig = {
-  folders?: ManifestModuleFolderType[];
-  filter?: ScanTest;
-  includeIndex?: boolean;
-  profiles?: string[];
-  checkProfile?: boolean;
+  folder?: (folder: ManifestModuleFolderType) => boolean;
+  module?: (module: IndexedModule) => boolean;
+  file?: (file: IndexedFile) => boolean;
+  sourceOnly?: boolean;
 };
 
 export type IndexedFile = {
@@ -24,7 +22,7 @@ export type IndexedFile = {
   sourceFile: string;
   outputFile: string;
   relativeFile: string;
-  profile: ManifestProfile;
+  role: ManifestModuleRole;
   type: ManifestModuleFileType;
 };
 
@@ -34,6 +32,12 @@ export type IndexedModule = ManifestModuleCore & {
   files: Record<ManifestModuleFolderType, IndexedFile[]>;
 };
 
+const TypedObject: {
+  keys<T = unknown, K extends keyof T = keyof T>(o: T): K[];
+  fromEntries<K extends string | symbol, V>(items: ([K, V] | readonly [K, V])[]): Record<K, V>;
+  entries<K extends Record<symbol | string, unknown>>(record: K): [keyof K, K[keyof K]][];
+} & ObjectConstructor = Object;
+
 /**
  * Manifest index
  */
@@ -78,7 +82,7 @@ export class ManifestIndex {
   }
 
   #moduleFiles(m: ManifestModule, files: ManifestModuleFile[]): IndexedFile[] {
-    return files.map(([f, type, ts, profile = 'std']) => {
+    return files.map(([f, type, ts, role = 'std']) => {
       const isSource = type === 'ts' || type === 'js';
       const sourceFile = path.resolve(this.#manifest.workspacePath, m.sourceFolder, f);
       const js = isSource ? ManifestModuleUtil.sourceToOutputExt(f) : f;
@@ -89,7 +93,7 @@ export class ManifestIndex {
         id = ManifestModuleUtil.sourceToBlankExt(id);
       }
 
-      return { id, type, sourceFile, outputFile, import: modImport, profile, relativeFile: f, module: m.name };
+      return { id, type, sourceFile, outputFile, import: modImport, role, relativeFile: f, module: m.name };
     });
   }
 
@@ -143,58 +147,27 @@ export class ManifestIndex {
 
   /**
    * Find files from the index
-   * @param folder The sub-folder to check into
-   * @param filter The filter to determine if this is a valid support file
+   * @param config The configuration for controlling the find process
    */
   find(config: FindConfig): IndexedFile[] {
-    const { filter: f, folders } = config;
-    const filter = f ? 'test' in f ? f.test.bind(f) : f : f;
-
-    let idx = this.#modules;
-
-    const checkProfile = config.checkProfile ?? true;
-
-    const activeProfiles = new Set(['std', ...(config.profiles ?? process.env.TRV_PROFILES?.split(/\s*,\s*/g) ?? [])]);
-
-    if (checkProfile) {
-      idx = idx.filter(m => m.profiles.length === 0 || m.profiles.some(p => activeProfiles.has(p)));
-    }
-
-    let searchSpace = folders ?
-      idx.flatMap(m => [...folders.flatMap(fo => m.files[fo] ?? []), ...(config.includeIndex ? (m.files.$index ?? []) : [])]) :
-      idx.flatMap(m => [...Object.values(m.files)].flat());
-
-    if (checkProfile) {
-      searchSpace = searchSpace.filter(fi => activeProfiles.has(fi.profile));
+    const searchSpace: IndexedFile[] = [];
+    for (const m of this.#modules) {
+      if (config.module?.(m) ?? true) {
+        for (const [folder, files] of TypedObject.entries(m.files)) {
+          if (config.folder?.(folder) ?? true) {
+            for (const file of files) {
+              if (
+                (config.file?.(file) ?? true) &&
+                (config.sourceOnly === false || file.type === 'ts')
+              ) {
+                searchSpace.push(file);
+              }
+            }
+          }
+        }
+      }
     }
-
-    return searchSpace
-      .filter(({ type }) => type === 'ts')
-      .filter(({ sourceFile: source }) => filter?.(source) ?? true);
-  }
-
-  /**
-   * Find files from the index
-   * @param filter The filter to determine if this is a valid support file
-   */
-  findSupport(config: Omit<FindConfig, 'folder'>): IndexedFile[] {
-    return this.find({ ...config, folders: ['support'] });
-  }
-
-  /**
-   * Find files from the index
-   * @param filter The filter to determine if this is a valid support file
-   */
-  findSrc(config: Omit<FindConfig, 'folder'> = {}): IndexedFile[] {
-    return this.find({ ...config, includeIndex: true, folders: ['src'] });
-  }
-
-  /**
-   * Find files from the index
-   * @param filter The filter to determine if this is a valid support file
-   */
-  findTest(config: Omit<FindConfig, 'folder'>): IndexedFile[] {
-    return this.find({ ...config, folders: ['test'] });
+    return searchSpace;
   }
 
   /**

package/src/module.ts

@@ -4,7 +4,8 @@ import { path } from './path';
 import {
   ManifestContext,
   ManifestModule, ManifestModuleFile, ManifestModuleFileType,
-  ManifestModuleFolderType, ManifestProfile
+  ManifestModuleFolderType,
+  ManifestModuleRole
 } from './types';
 import { ModuleDep, ModuleDependencyVisitor } from './dependencies';
 import { PackageUtil } from './package';
@@ -56,9 +57,6 @@ export class ManifestModuleUtil {
     const topFiles = new Set(mainSource ? [] : [...INDEX_FILES, 'package.json']);
     const out: string[] = [];
 
-    if (!fs.stat(folder).catch(() => false)) {
-      return out;
-    }
     const stack: [string, number][] = [[folder, 0]];
     while (stack.length) {
       const popped = stack.pop();
@@ -117,7 +115,7 @@ export class ManifestModuleUtil {
   /**
    * Get file type for a file name
    */
-  static getFileProfile(moduleFile: string): ManifestProfile | undefined {
+  static getFileRole(moduleFile: string): ManifestModuleRole | undefined {
     if (moduleFile.startsWith('support/transform')) {
       return 'compile';
     } else if (moduleFile.startsWith('support/test/') || moduleFile.startsWith('test/')) {
@@ -170,15 +168,15 @@ export class ManifestModuleUtil {
    */
   static async transformFile(moduleFile: string, full: string): Promise<ManifestModuleFile> {
     const res: ManifestModuleFile = [moduleFile, this.getFileType(moduleFile), this.#getNewest(await fs.stat(full))];
-    const profile = this.getFileProfile(moduleFile);
-    return profile ? [...res, profile] : res;
+    const role = this.getFileRole(moduleFile);
+    return role ? [...res, role] : res;
   }
 
   /**
    * Visit a module and describe files, and metadata
    */
   static async describeModule(ctx: ManifestContext, dep: ModuleDep): Promise<ManifestModule> {
-    const { main, mainSource, local, name, version, sourcePath, profileSet, parentSet, internal } = dep;
+    const { main, mainSource, local, name, version, sourcePath, roleSet, prod, parentSet, internal } = dep;
 
     const files: ManifestModule['files'] = {};
 
@@ -195,12 +193,12 @@ export class ManifestModuleUtil {
       files.$root = files.$root?.filter(([file, type]) => type !== 'ts');
     }
 
-    const profiles = [...profileSet].sort();
+    const roles = [...roleSet ?? []].sort();
     const parents = [...parentSet].sort();
     const outputFolder = `node_modules/${name}`;
     const sourceFolder = sourcePath === ctx.workspacePath ? '' : sourcePath.replace(`${ctx.workspacePath}/`, '');
 
-    const res = { main, name, version, local, internal, sourceFolder, outputFolder, files, profiles, parents, };
+    const res = { main, name, version, local, internal, sourceFolder, outputFolder, roles, parents, prod, files };
     return res;
   }
 

package/src/package.ts

@@ -1,10 +1,9 @@
-import { readFileSync } from 'fs';
-import fs from 'fs/promises';
 import { createRequire } from 'module';
 import { execSync } from 'child_process';
 
-import { ManifestContext, Package, PackageRel, PackageVisitor, PackageVisitReq, PackageWorkspaceEntry } from './types';
+import { ManifestContext, Package, PackageVisitor, PackageVisitReq, PackageWorkspaceEntry } from './types';
 import { path } from './path';
+import { ManifestFileUtil } from './file';
 
 /**
  * Utilities for querying, traversing and reading package.json files.
@@ -60,8 +59,8 @@ export class PackageUtil {
   /**
    * Build a package visit req
    */
-  static packageReq<T>(sourcePath: string, rel: PackageRel): PackageVisitReq<T> {
-    return { pkg: this.readPackage(sourcePath), sourcePath, rel };
+  static packageReq<T>(sourcePath: string, prod: boolean, topLevel?: boolean): PackageVisitReq<T> {
+    return { pkg: this.readPackage(sourcePath), sourcePath, prod, topLevel };
   }
 
   /**
@@ -71,22 +70,13 @@ export class PackageUtil {
     const pkg = this.readPackage(modulePath);
     const children: Record<string, PackageVisitReq<T>> = {};
     const local = modulePath === rootPath && !modulePath.includes('node_modules');
-    for (const [deps, rel] of [
-      [pkg.dependencies, 'prod'],
-      [pkg.peerDependencies, 'peer'],
-      [pkg.optionalDependencies, 'opt'],
-      ...(local ? [[pkg.devDependencies, 'dev'] as const] : []),
+    for (const [deps, prod] of [
+      [pkg.dependencies, true],
+      ...(local ? [[pkg.devDependencies, false] as const] : []),
     ] as const) {
       for (const [name, version] of Object.entries(deps ?? {})) {
-        try {
-          const depPath = this.resolveVersionPath(modulePath, version) ?? this.resolvePackagePath(name);
-          children[`${name}#${version}`] = this.packageReq<T>(depPath, rel);
-        } catch (err) {
-          if (rel === 'opt' || (rel === 'peer' && !!pkg.peerDependenciesMeta?.[name].optional)) {
-            continue;
-          }
-          throw err;
-        }
+        const depPath = this.resolveVersionPath(modulePath, version) ?? this.resolvePackagePath(name);
+        children[`${name}#${version}`] = this.packageReq<T>(depPath, prod, false);
       }
     }
     return Object.values(children).sort((a, b) => a.pkg.name.localeCompare(b.pkg.name));
@@ -99,10 +89,9 @@ export class PackageUtil {
     if (forceRead) {
       delete this.#cache[modulePath];
     }
-    const res = this.#cache[modulePath] ??= JSON.parse(readFileSync(
+    const res = this.#cache[modulePath] ??= ManifestFileUtil.readAsJsonSync(
       modulePath.endsWith('.json') ? modulePath : path.resolve(modulePath, 'package.json'),
-      'utf8'
-    ));
+    );
 
     res.name ??= 'untitled'; // If a package.json (root-only) is missing a name, allows for npx execution
 
@@ -125,7 +114,7 @@ export class PackageUtil {
   ): Promise<Set<T>> {
 
     const root = typeof rootOrPath === 'string' ?
-      this.packageReq<T>(rootOrPath, 'root') :
+      this.packageReq<T>(rootOrPath, false, true) :
       rootOrPath;
 
     const seen = new Map<string, T>();
@@ -159,11 +148,10 @@ export class PackageUtil {
    */
   static async resolveWorkspaces(ctx: ManifestContext, rootPath: string): Promise<PackageWorkspaceEntry[]> {
     if (!this.#workspaces[rootPath]) {
-      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 {
+        return await ManifestFileUtil.readAsJson(cache);
+      } catch (err) {
         let out: PackageWorkspaceEntry[];
         switch (ctx.packageManager) {
           case 'npm': {
@@ -180,7 +168,7 @@ export class PackageUtil {
 
         this.#workspaces[rootPath] = out;
 
-        await fs.writeFile(cache, JSON.stringify(out), 'utf8');
+        await ManifestFileUtil.bufferedFileWrite(cache, out);
       }
     }
     return this.#workspaces[rootPath];

package/src/path.ts

@@ -9,7 +9,7 @@ const toPosix = (file: string): string => file.replaceAll('\\', '/');
 /**
  * Converts a given file name by replace all slashes, with platform dependent path separators
  */
-const toNative = (file: string): string => file.replaceAll('/', sep);
+const toNative = (file: string): string => file.replace(/[\\\/]+/g, sep);
 
 const cwd = (): string => toPosix(process.cwd());
 

package/src/root-index.ts

@@ -27,15 +27,6 @@ class $RootIndex extends ManifestIndex {
     return !!this.manifest.monoRepo && !this.manifest.mainFolder;
   }
 
-  /**
-   * Asynchronously load all source files from manifest
-   */
-  async loadSource(): Promise<void> {
-    for (const { import: imp } of this.findSrc()) {
-      await import(imp);
-    }
-  }
-
   /**
    * Get internal id from file name and optionally, class name
    */

package/src/types.ts

@@ -1,3 +1,5 @@
+export type NodeModuleType = 'module' | 'commonjs';
+
 export type ManifestModuleFileType = 'typings' | 'ts' | 'js' | 'json' | 'package-json' | 'unknown' | 'fixture' | 'md';
 export type ManifestModuleFolderType =
   '$root' | '$index' | '$package' |
@@ -5,10 +7,9 @@ export type ManifestModuleFolderType =
   'test/fixtures' | 'support/fixtures' | 'support/resources' |
   '$other' | '$transformer';
 
-export type ManifestProfile = 'compile' | 'test' | 'doc' | 'build' | 'std';
-export type PackageRel = 'dev' | 'prod' | 'peer' | 'opt' | 'root' | 'global';
+export type ManifestModuleRole = 'std' | 'test' | 'doc' | 'compile' | 'build';
 
-export type ManifestModuleFile = [string, ManifestModuleFileType, number] | [string, ManifestModuleFileType, number, ManifestProfile];
+export type ManifestModuleFile = [string, ManifestModuleFileType, number] | [string, ManifestModuleFileType, number, ManifestModuleRole];
 export type ManifestModuleCore = {
   name: string;
   main?: boolean;
@@ -16,7 +17,8 @@ export type ManifestModuleCore = {
   version: string;
   sourceFolder: string;
   outputFolder: string;
-  profiles: ManifestProfile[];
+  prod: boolean;
+  roles: ManifestModuleRole[];
   parents: string[];
   internal?: boolean;
 };
@@ -33,11 +35,12 @@ export type ManifestContext = {
   toolFolder: string;
   compilerFolder: string;
   monoRepo?: boolean;
-  moduleType: 'module' | 'commonjs';
+  moduleType: NodeModuleType;
   packageManager: 'yarn' | 'npm';
   frameworkVersion: string;
-  description: string;
+  description?: string;
   version: string;
+  compilerUrl: string;
 };
 
 export type ManifestRoot = ManifestContext & {
@@ -47,7 +50,7 @@ export type ManifestRoot = ManifestContext & {
 
 export type Package = {
   name: string;
-  type?: 'module' | 'commonjs';
+  type?: NodeModuleType;
   version: string;
   description?: string;
   license?: string;
@@ -75,7 +78,7 @@ export type Package = {
   travetto?: {
     isolated?: boolean;
     displayName?: string;
-    profiles?: ManifestProfile[];
+    roles?: ManifestModuleRole[];
     globalModules?: string[];
     mainSource?: string[];
     docOutput?: string[];
@@ -83,6 +86,9 @@ export type Package = {
     docBaseUrl?: string;
     docOutputs?: string[];
     outputFolder?: string;
+    toolFolder?: string;
+    compilerFolder?: string;
+    compilerUrl?: string;
   };
   workspaces?: string[];
   private?: boolean;
@@ -91,7 +97,7 @@ export type Package = {
 
 type OrProm<T> = T | Promise<T>;
 
-export type PackageVisitReq<T> = { pkg: Package, rel: PackageRel, sourcePath: string, parent?: T };
+export type PackageVisitReq<T> = { pkg: Package, prod: boolean, sourcePath: string, parent?: T, topLevel?: boolean };
 export type PackageVisitor<T> = {
   init?(req: PackageVisitReq<T>): OrProm<undefined | void | PackageVisitReq<T>[]>;
   valid?(req: PackageVisitReq<T>): boolean;

package/src/util.ts

@@ -1,10 +1,7 @@
-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';
+import { ManifestFileUtil } from './file';
 
 const MANIFEST_FILE = 'manifest.json';
 
@@ -12,20 +9,6 @@ const MANIFEST_FILE = 'manifest.json';
  * Manifest utils
  */
 export class ManifestUtil {
-  /**
-   * Write file and copy over when ready
-   */
-  static async writeFileWithBuffer(file: string, content: string): Promise<string> {
-    const ext = path.extname(file);
-    const tempName = `${path.basename(file, ext)}.${process.ppid}.${process.pid}.${Date.now()}.${Math.random()}${ext}`;
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    const temp = path.resolve(os.tmpdir(), tempName);
-    await fs.writeFile(temp, content, 'utf8');
-    await fs.copyFile(temp, file);
-    fs.unlink(temp);
-    return file;
-  }
-
   /**
    * Build a manifest context
    * @param folder
@@ -55,7 +38,7 @@ export class ManifestUtil {
       // If in prod mode, only include std modules
       modules: Object.fromEntries(
         Object.values(manifest.modules)
-          .filter(x => x.profiles.includes('std'))
+          .filter(x => x.prod)
           .map(m => [m.name, m])
       ),
       // Mark output folder/workspace path as portable
@@ -75,7 +58,7 @@ export class ManifestUtil {
     if (!file.endsWith('.json')) {
       file = path.resolve(file, MANIFEST_FILE);
     }
-    const manifest: ManifestRoot = JSON.parse(readFileSync(file, 'utf8'));
+    const manifest: ManifestRoot = ManifestFileUtil.readAsJsonSync(file);
     // Support packaged environments, by allowing empty outputFolder
     if (!manifest.outputFolder) {
       manifest.outputFolder = path.cwd();
@@ -88,7 +71,7 @@ export class ManifestUtil {
    * Write manifest for a given context, return location
    */
   static writeManifest(ctx: ManifestContext, manifest: ManifestRoot): Promise<string> {
-    return this.writeFileWithBuffer(
+    return ManifestFileUtil.bufferedFileWrite(
       path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule, MANIFEST_FILE),
       JSON.stringify(manifest)
     );
@@ -102,8 +85,7 @@ export class ManifestUtil {
       location = path.resolve(location, MANIFEST_FILE);
     }
 
-    await fs.mkdir(path.dirname(location), { recursive: true });
-    await fs.writeFile(location, JSON.stringify(manifest), 'utf8');
+    await ManifestFileUtil.bufferedFileWrite(location, JSON.stringify(manifest));
 
     return location;
   }

package/src/watch.ts

@@ -1,208 +0,0 @@
-import { watch, Stats } from 'fs';
-import fs from 'fs/promises';
-
-import { path } from './path';
-
-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;
-  }
-}
-
-export type WatchEvent = { action: 'create' | 'update' | 'delete', file: string, folder: string };
-
-export type WatchFolder = {
-  /**
-   * Source folder
-   */
-  src: string;
-  /**
-   * Target folder name, useful for deconstructing
-   */
-  target?: string;
-  /**
-   * Filter events
-   */
-  filter?: (ev: WatchEvent) => boolean;
-  /**
-   * Only look at immediate folder
-   */
-  immediate?: boolean;
-  /**
-   * List of top level folders to ignore
-   */
-  ignore?: string[];
-  /**
-   * If watching a folder that doesn't exist, should it be created?
-   */
-  createMissing?: boolean;
-  /**
-   * Include files that start with '.'
-   */
-  includeHidden?: boolean;
-};
-
-export type WatchStream = AsyncIterable<WatchEvent> & { close: () => Promise<void>, add: (item: WatchEvent | WatchEvent[]) => void };
-
-const DEDUPE_THRESHOLD = 50;
-
-class Queue<X> implements AsyncIterator<X>, AsyncIterable<X> {
-  #queue: X[] = [];
-  #done = false;
-  #ready: Promise<void>;
-  #fire: (() => void);
-  #onClose: (() => (void | Promise<void>))[] = [];
-  #recentKeys = new Map<string, number>();
-
-  constructor() {
-    this.#ready = new Promise(r => this.#fire = r);
-  }
-
-  // Allow for iteration
-  [Symbol.asyncIterator](): AsyncIterator<X> { return this; }
-
-  async next(): Promise<IteratorResult<X>> {
-    while (!this.#done && !this.#queue.length) {
-      this.#recentKeys = new Map([...this.#recentKeys.entries()] // Cull before waiting
-        .filter(([, time]) => (Date.now() - time) < DEDUPE_THRESHOLD));
-      await this.#ready;
-      this.#ready = new Promise(r => this.#fire = r);
-    }
-    return { value: this.#queue.shift()!, done: this.#done };
-  }
-
-  add(item: X | X[]): void {
-    const now = Date.now();
-    for (const value of Array.isArray(item) ? item : [item]) {
-      const key = JSON.stringify(value);
-      if ((now - (this.#recentKeys.get(key) ?? 0)) > DEDUPE_THRESHOLD) {
-        this.#queue.push(value);
-        this.#recentKeys.set(key, now);
-        this.#fire();
-      }
-    }
-  }
-
-  registerOnClose(handler: () => (void | Promise<void>)): void {
-    this.#onClose.push(handler);
-  }
-
-  async close(): Promise<void> {
-    this.#done = true;
-    this.#fire();
-    await Promise.all(this.#onClose.map(x => x()));
-  }
-}
-
-/**
- * Watch immediate files for a given folder
- */
-async function watchFolderImmediate(queue: Queue<WatchEvent>, options: WatchFolder): Promise<void> {
-  const watchPath = path.resolve(options.src);
-  const watcher = watch(watchPath, { persistent: true, encoding: 'utf8' });
-  const lastStats: Record<string, Stats | undefined> = {};
-  const invalidFilter = (el: string): boolean =>
-    (el === '.' || el === '..' || (!options.includeHidden && el.startsWith('.')) || !!options.ignore?.includes(el));
-
-  for (const el of await fs.readdir(watchPath)) {
-    if (invalidFilter(el)) {
-      continue;
-    }
-    const file = path.resolve(watchPath, el);
-    lastStats[file] = await fs.stat(file);
-  }
-
-  const target = options.target ?? options.src;
-
-  watcher.on('change', async (type: string, file: string): Promise<void> => {
-    if (invalidFilter(file)) {
-      return;
-    }
-
-    file = path.resolve(watchPath, file);
-
-    const stat = await fs.stat(file).catch(() => undefined);
-    const prevStat = lastStats[file];
-    lastStats[file] = stat;
-
-    if (prevStat?.mtimeMs === stat?.mtimeMs) {
-      return;
-    }
-    let ev: WatchEvent;
-    if (prevStat && !stat) {
-      ev = { action: 'delete', file, folder: target };
-    } else if (!prevStat && stat) {
-      ev = { action: 'create', file, folder: target };
-    } else {
-      ev = { action: 'update', file, folder: target };
-    }
-    if (!options.filter || options.filter(ev)) {
-      queue.add(ev);
-    }
-  });
-
-  queue.registerOnClose(() => watcher.close());
-}
-
-/**
- * Watch recursive files for a given folder
- */
-async function watchFolderRecursive(queue: Queue<WatchEvent>, options: WatchFolder): Promise<void> {
-  const lib = await getWatcher();
-  const target = options.target ?? options.src;
-
-  if (await fs.stat(options.src).then(() => true, () => options.createMissing)) {
-    await fs.mkdir(options.src, { recursive: true });
-    const ignore = (await fs.readdir(options.src)).filter(x => x.startsWith('.') && x.length > 2);
-    const cleanup = await lib.subscribe(options.src, async (err, events) => {
-      if (err) {
-        process.send?.({ type: 'log', message: `Watch error: ${err}` });
-      }
-      for (const ev of events) {
-        const finalEv = { action: ev.type, file: path.toPosix(ev.path), folder: target };
-        if (ev.type !== 'delete') {
-          const stats = await fs.stat(finalEv.file);
-          if ((stats.ctimeMs - Date.now()) < DEDUPE_THRESHOLD) {
-            ev.type = 'create'; // Force create on newly stated files
-          }
-        }
-
-        if (ev.type === 'delete' && finalEv.file === options.src) {
-          return queue.close();
-        }
-        const isHidden = !options.includeHidden && finalEv.file.replace(target, '').includes('/.');
-        const matches = !isHidden && (!options.filter || options.filter(finalEv));
-        if (matches) {
-          queue.add(finalEv);
-        }
-      }
-    }, { ignore: [...ignore, ...options.ignore ?? []] });
-    queue.registerOnClose(() => cleanup.unsubscribe());
-  }
-}
-
-/**
- * Watch a series of folders
- * @param folders
- * @param onEvent
- * @param options
- */
-export function watchFolders(
-  folders: string[] | WatchFolder[],
-  config: Omit<WatchFolder, 'src' | 'target'> = {}
-): WatchStream {
-  const queue = new Queue<WatchEvent>();
-  for (const folder of folders) {
-    if (typeof folder === 'string') {
-      watchFolderRecursive(queue, { ...config, src: folder });
-    } else if (!folder.immediate) {
-      watchFolderRecursive(queue, { ...config, ...folder });
-    } else {
-      watchFolderImmediate(queue, { ...config, ...folder });
-    }
-  }
-  return queue;
-}