@travetto/manifest 8.0.0-alpha.9 → 8.0.0

package/README.md

@@ -13,7 +13,7 @@ npm install @travetto/manifest
 yarn add @travetto/manifest
 ```
 
-This module aims to be the boundary between the file system and the code.  The module provides:
+This module aims to be the boundary between the file system and the code. The module provides:
    *  Project Manifesting
    *  Manifest Delta
    *  Class and Function Metadata
@@ -30,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#L23) 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#L31) 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.
 
 ## Module Indexing
 Once the manifest is created, the application runtime can now read this manifest, which allows for influencing runtime behavior. The most common patterns include:
@@ -43,7 +43,7 @@ Once the manifest is created, the application runtime can now read this manifest
    *  Providing contextual information when provided a filename, import name, etc (e.g. logging, testing output)
 
 ## 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#L46) as an equivalent to [Node](https://nodejs.org)'s [path](https://nodejs.org/api/path.html) library.  This allows for consistent behavior across all file-interactions.
+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#L48) as an equivalent to [Node](https://nodejs.org)'s [path](https://nodejs.org/api/path.html) library. This allows for consistent behavior across all file-interactions.
 
 ## Anatomy of a Manifest
 
@@ -131,7 +131,7 @@ The context contains:
    *  The main module to execute. (*This primarily pertains to mono-repo support when there are multiple modules in the project*)
    *  The root path of the project/workspace
    *  Whether or not the project is a mono-repo. (*This is determined by using the 'workspaces' field in your [Package JSON](https://docs.npmjs.com/cli/v9/configuring-npm/package-json)*)
-   *  The location where all compiled code will be stored.  Defaults to: `.trv_output`. (*Can be overridden in your [Package JSON](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) in 'travetto.outputFolder'*)
+   *  The location where all compiled code will be stored. Defaults to: `.trv_output`. (*Can be overridden in your [Package JSON](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) in 'travetto.outputFolder'*)
    *  The location where the intermediate compiler will be created. Defaults to: `.trv_compiler`
    *  The location where tooling will be able to write to. Defaults to: `.trv_output`
    *  Which package manager is in use [Npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)/[Yarn](https://yarnpkg.com)
@@ -140,7 +140,7 @@ The context contains:
    *  The framework version (based on @travetto/manifest)
 
 ### Modules
-The modules represent all of the [Travetto](https://travetto.dev)-aware dependencies (including dev dependencies) used for compiling, testing and executing.  A production-only version is produced when packaging the final output. Each module contains:
+The modules represent all of the [Travetto](https://travetto.dev)-aware dependencies (including dev dependencies) used for compiling, testing and executing. A production-only version is produced when packaging the final output. Each module contains:
    *  The dependency npm name
    *  The dependency version
    *  A flag to determine if its a local module
@@ -148,7 +148,7 @@ The modules represent all of the [Travetto](https://travetto.dev)-aware dependen
    *  The path to the source folder, relative to the workspace root
    *  The path to the output folder, relative to the workspace output root
    *  The list of all files
-   *  The profiles a module applies to.  Values are std, test, compile, doc.  Any empty value implies std
+   *  The profiles a module applies to. Values are std, test, compile, doc. Any empty value implies std
    *  Parent modules that imported this module
 
 ### Module Files
@@ -162,10 +162,10 @@ The module files are a simple categorization of files into a predetermined set o
    *  `resources` - Packaged resource, meant to pertain to the main module only. Files, under `resources/`
    *  `support` - All .ts files under the `support/` folder
    *  `support/resources` - Packaged resource files, meant to be included by other modules, under `support/resources/`
-   *  `support/fixtures` - Test resources meant to shared across modules.  Under `support/fixtures/`
+   *  `support/fixtures` - Test resources meant to shared across modules. Under `support/fixtures/`
    *  `doc` - Documentation files. `DOC.tsx` and All .ts/.tsx files under the `doc/` folder
-   *  `$transformer` - All .ts files under the pattern `support/transform*`.  These are used during compilation and never at runtime
-   *  `bin` - Entry point .js files.  All .js files under the `bin/` folder
+   *  `$transformer` - All .ts files under the pattern `support/transform*`. These are used during compilation and never at runtime
+   *  `bin` - Entry point .js files. All .js files under the `bin/` folder
 
 Within each file there is a pattern of either a 3 or 4 element array:
 

package/__index__.ts

@@ -1,12 +1,12 @@
 export * from './src/context.ts';
-export * from './src/module.ts';
 export * from './src/delta.ts';
+export * from './src/file.ts';
 export * from './src/manifest-index.ts';
+export * from './src/module.ts';
 export * from './src/package.ts';
-export * from './src/util.ts';
-export * from './src/file.ts';
+export { default as path } from './src/path.ts';
+export * from './src/types/common.ts';
 export * from './src/types/context.ts';
-export * from './src/types/package.ts';
 export * from './src/types/manifest.ts';
-export * from './src/types/common.ts';
-export { default as path } from './src/path.ts';
+export * from './src/types/package.ts';
+export * from './src/util.ts';

package/package.json

@@ -1,43 +1,43 @@
 {
   "name": "@travetto/manifest",
-  "version": "8.0.0-alpha.9",
-  "type": "module",
+  "version": "8.0.0",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
-    "path",
-    "package",
     "manifest",
+    "package",
+    "path",
     "travetto",
     "typescript"
   ],
   "homepage": "https://travetto.io",
   "license": "MIT",
   "author": {
-    "email": "travetto.framework@gmail.com",
-    "name": "Travetto Framework"
+    "name": "Travetto Framework",
+    "email": "travetto.framework@gmail.com"
+  },
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/manifest"
   },
   "files": [
     "__index__.ts",
     "src"
   ],
+  "type": "module",
   "main": "__index__.ts",
-  "engines": {
-    "node": ">=25.7.0"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@types/node": "^25.9.2"
+    "@types/node": "^26.2.0"
   },
-  "repository": {
-    "url": "git+https://github.com/travetto/travetto.git",
-    "directory": "module/manifest"
+  "engines": {
+    "node": ">=25.7.0"
   },
   "travetto": {
     "displayName": "Manifest",
     "doc": {
       "baseUrl": "https://github.com/travetto/travetto/tree/main"
     }
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/context.ts

@@ -1,13 +1,12 @@
 import { existsSync, readFileSync } from 'node:fs';
-import path from 'node:path';
 import { createRequire } from 'node:module';
+import path from 'node:path';
 
-import { type Package, PACKAGE_MANAGERS } from './types/package.ts';
 import type { ManifestContext } from './types/context.ts';
+import { PACKAGE_MANAGERS, type Package } from './types/package.ts';
 
 type Pkg = Package & { path: string };
 
-// eslint-disable-next-line no-bitwise
 const toPort = (location: string): number => (Math.abs([...location].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
 const toPosix = (location: string): string => location.replaceAll('\\', '/');
 const readPackage = (file: string): Pkg => ({ ...JSON.parse(readFileSync(file, 'utf8')), path: toPosix(path.dirname(file)) });
@@ -47,10 +46,12 @@ const WORKSPACE_FILES = PACKAGE_MANAGERS.map(x => x.workspaceFile!).filter(Boole
  * Gets build context
  */
 export function getManifestContext(root: string = process.cwd()): ManifestContext {
-  const workspace = findPackage(root, pkg =>
-    !!pkg?.workspaces ||
-    !!pkg?.travetto?.build?.isolated ||
-    (!!pkg && WORKSPACE_FILES.some(file => existsSync(path.resolve(pkg.path, file))))
+  const workspace = findPackage(
+    root,
+    pkg =>
+      !!pkg?.workspaces ||
+      !!pkg?.travetto?.build?.isolated ||
+      (!!pkg && WORKSPACE_FILES.some(file => existsSync(path.resolve(pkg.path, file))))
   );
   if (workspace.type !== 'module') {
     throw new Error('Only ESM modules are supported, package.json must be of type module');
@@ -60,9 +61,10 @@ export function getManifestContext(root: string = process.cwd()): ManifestContex
   const resolve = createRequire(path.resolve(workspace.path, 'node_modules')).resolve.bind(null);
   const wsPrefix = `${workspace.path}/`;
   const moduleName = process.env.TRV_MODULE === workspace.name ? workspace.path : process.env.TRV_MODULE;
-  const modulePkg = (!!workspace.workspaces && moduleName) ?
-    readPackage(resolve(`${moduleName}/package.json`)) :
-    findPackage(root, pkg => !!pkg) ?? workspace;
+  const modulePkg =
+    workspace.workspaces && moduleName
+      ? readPackage(resolve(`${moduleName}/package.json`))
+      : (findPackage(root, pkg => !!pkg) ?? workspace);
 
   return {
     workspace: {
@@ -84,4 +86,4 @@ export function getManifestContext(root: string = process.cwd()): ManifestContex
       description: modulePkg.description
     }
   };
-}
+}

package/src/delta.ts

@@ -2,16 +2,24 @@ import fs from 'node:fs/promises';
 
 import { ManifestModuleUtil } from './module.ts';
 import path from './path.ts';
-
-import type { ManifestModule, ManifestModuleCore, ManifestModuleFile, ManifestRoot } from './types/manifest.ts';
 import type { ChangeEventType, ManifestModuleFileType, ManifestModuleFolderType } from './types/common.ts';
 import type { ManifestContext } from './types/context.ts';
+import type { ManifestModule, ManifestModuleCore, ManifestModuleFile, ManifestRoot } from './types/manifest.ts';
 
 type DeltaEventType = ChangeEventType | 'missing' | 'dirty';
 type DeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFile> };
-export type DeltaEvent = { file: string, type: DeltaEventType, module: string, sourceFile: string };
-
-const VALID_SOURCE_FOLDERS = new Set<ManifestModuleFolderType>(['bin', 'src', 'test', 'support', '$index', '$transformer', '$package', 'doc']);
+export type DeltaEvent = { file: string; type: DeltaEventType; module: string; sourceFile: string };
+
+const VALID_SOURCE_FOLDERS = new Set<ManifestModuleFolderType>([
+  'bin',
+  'src',
+  'test',
+  'support',
+  '$index',
+  '$transformer',
+  '$package',
+  'doc'
+]);
 const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
 const VALID_OUTPUT_TYPE = new Set<ManifestModuleFileType>([...VALID_SOURCE_TYPE, 'typings']);
 
@@ -21,8 +29,7 @@ const TypedObject: { keys<T = unknown, K extends keyof T = keyof T>(item: T): K[
  * Produce delta for the manifest
  */
 export class ManifestDeltaUtil {
-
-  static #getNewest(stat: { mtimeMs: number, ctimeMs: number }): number {
+  static #getNewest(stat: { mtimeMs: number; ctimeMs: number }): number {
     return Math.max(stat.mtimeMs, stat.ctimeMs);
   }
 
@@ -92,17 +99,16 @@ export class ManifestDeltaUtil {
    */
   static async produceDelta(manifest: ManifestRoot): Promise<DeltaEvent[]> {
     const deltaLeft = Object.fromEntries(
-      Object.values(manifest.modules)
-        .map(module => [module.name, { ...module, files: this.#flattenModuleFiles(module) }])
+      Object.values(manifest.modules).map(module => [module.name, { ...module, files: this.#flattenModuleFiles(module) }])
     );
 
     const out: DeltaEvent[] = [];
     const outputFolder = path.resolve(manifest.workspace.path, manifest.build.outputFolder);
 
     for (const leftModule of Object.values(deltaLeft)) {
-      out.push(...await this.#deltaModules(manifest, outputFolder, leftModule));
+      out.push(...(await this.#deltaModules(manifest, outputFolder, leftModule)));
     }
 
     return out;
   }
-}
+}

package/src/dependencies.ts

@@ -1,11 +1,10 @@
 import { PackageUtil } from './package.ts';
 import path from './path.ts';
-
-import type { Package, PackageDependencyType } from './types/package.ts';
 import type { ManifestContext } from './types/context.ts';
 import type { PackageModule } from './types/manifest.ts';
+import type { Package, PackageDependencyType } from './types/package.ts';
 
-type CreateOpts = Partial<Pick<PackageModule, 'main' | 'workspace' | 'production'>> & { roleRoot?: boolean, parent?: PackageModule };
+type CreateOpts = Partial<Pick<PackageModule, 'main' | 'workspace' | 'production'>> & { roleRoot?: boolean; parent?: PackageModule };
 
 type VisitableNode = {
   /** Request package */
@@ -22,10 +21,11 @@ type VisitableNode = {
  * Used for walking dependencies for collecting modules for the manifest
  */
 export class PackageModuleVisitor {
-
   static async visit(ctx: ManifestContext): Promise<Iterable<PackageModule>> {
-    const visitor = new PackageModuleVisitor(ctx, Object.fromEntries((await PackageUtil.resolveWorkspaces(ctx))
-      .map(workspace => [workspace.name, workspace.path])));
+    const visitor = new PackageModuleVisitor(
+      ctx,
+      Object.fromEntries((await PackageUtil.resolveWorkspaces(ctx)).map(workspace => [workspace.name, workspace.path]))
+    );
     return visitor.visit();
   }
 
@@ -45,22 +45,26 @@ export class PackageModuleVisitor {
    */
   #create(sourcePath: string, { main, workspace, production = false, roleRoot = false, parent }: CreateOpts = {}): VisitableNode {
     const pkg = PackageUtil.readPackage(sourcePath);
-    const value = this.#cache[sourcePath] ??= {
+    const value = (this.#cache[sourcePath] ??= {
       main,
       production,
       name: pkg.name,
       version: pkg.version,
-      workspace: workspace ?? (pkg.name in this.#workspaceModules),
+      workspace: workspace ?? pkg.name in this.#workspaceModules,
       internal: pkg.private === true,
       sourceFolder: sourcePath === this.#ctx.workspace.path ? '' : sourcePath.replace(`${this.#ctx.workspace.path}/`, ''),
       outputFolder: `node_modules/${pkg.name}`,
       state: {
-        childSet: new Set(), parentSet: new Set(), roleSet: new Set(), roleRoot,
-        travetto: pkg.travetto, dependencies: new Set(Object.keys(pkg.dependencies ?? {}))
+        childSet: new Set(),
+        parentSet: new Set(),
+        roleSet: new Set(),
+        roleRoot,
+        travetto: pkg.travetto,
+        dependencies: new Set(Object.keys(pkg.dependencies ?? {}))
       }
-    };
+    });
 
-    const dependencies: PackageDependencyType[] = ['dependencies', ...(value.main ? ['devDependencies'] as const : [])];
+    const dependencies: PackageDependencyType[] = ['dependencies', ...(value.main ? (['devDependencies'] as const) : [])];
     const children = Object.fromEntries(dependencies.flatMap(dependency => Object.entries(pkg[dependency] ?? {})));
     return { pkg, value, children, parent };
   }
@@ -69,19 +73,22 @@ export class PackageModuleVisitor {
    * Get monorepo root includes
    */
   #getMonoRootIncludes(parent: VisitableNode): VisitableNode[] {
-    if (!(this.#ctx.workspace.mono && !this.#ctx.main.folder)) { // If not mono root, bail
+    if (!(this.#ctx.workspace.mono && !this.#ctx.main.folder)) {
+      // If not mono root, bail
       return [];
     }
 
-    return Object.values(this.#workspaceModules)
-      .map(folder => this.#create(folder, { main: true, workspace: true, roleRoot: true, parent: parent.value }));
+    return Object.values(this.#workspaceModules).map(folder =>
+      this.#create(folder, { main: true, workspace: true, roleRoot: true, parent: parent.value })
+    );
   }
 
   /**
    * Determine default includes
    */
   #getIncludes(parent: VisitableNode): VisitableNode[] {
-    if (this.#ctx.workspace.mono && !this.#ctx.main.folder) { // If mono and not at mono root, bail
+    if (this.#ctx.workspace.mono && !this.#ctx.main.folder) {
+      // If mono and not at mono root, bail
       return [];
     }
 
@@ -92,7 +99,7 @@ export class PackageModuleVisitor {
       );
     } else {
       return Object.values(this.#workspaceModules)
-        .filter((folder) => PackageUtil.readPackage(folder).travetto?.workspaceInclude)
+        .filter(folder => PackageUtil.readPackage(folder).travetto?.workspaceInclude)
         .map(folder => this.#create(folder, { workspace: true, parent: parent.value }));
     }
   }
@@ -106,9 +113,12 @@ export class PackageModuleVisitor {
     // All first-level dependencies should have role filled in (for propagation)
     for (const dependency of [...modules].filter(module => module.state.roleRoot)) {
       dependency.state.roleSet.clear(); // Ensure the roleRoot is empty
-      for (const child of dependency.state.childSet) { // Visit children
+      for (const child of dependency.state.childSet) {
+        // Visit children
         const childDependency = mapping.get(child)!.item;
-        if (childDependency.state.roleRoot) { continue; }
+        if (childDependency.state.roleRoot) {
+          continue;
+        }
         // Set roles for all top level modules
         childDependency.state.roleSet = new Set(childDependency.state.travetto?.roles ?? ['std']);
       }
@@ -124,7 +134,9 @@ export class PackageModuleVisitor {
       for (const { item } of toProcess) {
         for (const childName of item.state.childSet) {
           const child = mapping.get(childName);
-          if (!child) { continue; }
+          if (!child) {
+            continue;
+          }
           child.parent.delete(item.name);
           // Propagate roles from parent to child
           if (!child.item.state.roleRoot) {
@@ -133,7 +145,7 @@ export class PackageModuleVisitor {
             }
           }
           // Allow production to trickle down as needed
-          child.item.production ||= (item.production && item.state.dependencies.has(childName));
+          child.item.production ||= item.production && item.state.dependencies.has(childName);
         }
       }
       // Remove from mapping
@@ -144,7 +156,7 @@ export class PackageModuleVisitor {
 
     // Mark as standard at the end
     for (const dependency of [...modules].filter(module => module.state.roleRoot)) {
-      dependency.state.roleSet = new Set(['std', ...dependency.state.travetto?.roles ?? []]);
+      dependency.state.roleSet = new Set(['std', ...(dependency.state.travetto?.roles ?? [])]);
     }
 
     return [...modules].toSorted((a, b) => a.name.localeCompare(b.name));
@@ -157,11 +169,7 @@ export class PackageModuleVisitor {
     const seen = new Set<PackageModule>();
     const mainRequire = this.#create(this.#mainSourcePath, { main: true, workspace: true, roleRoot: true, production: true });
 
-    const queue = [
-      mainRequire,
-      ...this.#getMonoRootIncludes(mainRequire),
-      ...this.#getIncludes(mainRequire)
-    ];
+    const queue = [mainRequire, ...this.#getMonoRootIncludes(mainRequire), ...this.#getIncludes(mainRequire)];
 
     while (queue.length) {
       const { value: node, parent, children, pkg } = queue.shift()!; // Visit initial set first
@@ -190,4 +198,4 @@ export class PackageModuleVisitor {
 
     return await this.#complete(seen);
   }
-}
+}

package/src/file.ts

@@ -1,5 +1,5 @@
-import fs from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
+import fs from 'node:fs/promises';
 import os from 'node:os';
 
 import path from './path.ts';
@@ -25,4 +25,4 @@ export class ManifestFileUtil {
   static readAsJsonSync<T = unknown>(file: string): T {
     return JSON.parse(readFileSync(file, 'utf8'));
   }
-}
+}

package/src/manifest-index.ts

@@ -2,10 +2,9 @@ import { existsSync } from 'node:fs';
 
 import { ManifestModuleUtil } from './module.ts';
 import path from './path.ts';
+import type { FindConfig, IndexedFile, IndexedModule, ManifestModule, ManifestModuleFile, ManifestRoot } from './types/manifest.ts';
 import { ManifestUtil } from './util.ts';
 
-import type { ManifestModule, ManifestRoot, ManifestModuleFile, IndexedModule, IndexedFile, FindConfig } from './types/manifest.ts';
-
 const TypedObject: {
   keys<T = unknown, K extends keyof T = keyof T>(item: T): K[];
   fromEntries<K extends string | symbol, V>(items: ([K, V] | readonly [K, V])[]): Record<K, V>;
@@ -16,7 +15,6 @@ const TypedObject: {
  * Manifest index
  */
 export class ManifestIndex {
-
   #arbitraryLookup?: (parts: string[]) => ManifestModule | undefined;
   #manifest: ManifestRoot;
   #modules: IndexedModule[];
@@ -81,16 +79,15 @@ export class ManifestIndex {
     this.#sourceToEntry.clear();
     this.#arbitraryLookup = undefined;
 
-    this.#modules = Object.values(this.#manifest.modules)
-      .map(module => ({
-        ...module,
-        outputPath: this.#resolveOutput(module.outputFolder),
-        sourcePath: path.resolve(this.#manifest.workspace.path, module.sourceFolder),
-        children: new Set(),
-        files: TypedObject.fromEntries(
-          TypedObject.entries(module.files).map(([folder, files]) => [folder, this.#moduleFiles(module, files ?? [])])
-        )
-      }));
+    this.#modules = Object.values(this.#manifest.modules).map(module => ({
+      ...module,
+      outputPath: this.#resolveOutput(module.outputFolder),
+      sourcePath: path.resolve(this.#manifest.workspace.path, module.sourceFolder),
+      children: new Set(),
+      files: TypedObject.fromEntries(
+        TypedObject.entries(module.files).map(([folder, files]) => [folder, this.#moduleFiles(module, files ?? [])])
+      )
+    }));
 
     for (const module of this.#modules) {
       for (const files of Object.values(module.files ?? {})) {
@@ -139,10 +136,7 @@ export class ManifestIndex {
         for (const [folder, files] of TypedObject.entries(module.files)) {
           if (config.folder?.(folder) ?? true) {
             for (const file of files) {
-              if (
-                (config.file?.(file) ?? true) &&
-                (config.sourceOnly === false || file.type === 'ts')
-              ) {
+              if ((config.file?.(file) ?? true) && (config.sourceOnly === false || file.type === 'ts')) {
                 searchSpace.push(file);
               }
             }
@@ -241,7 +235,8 @@ export class ManifestIndex {
         seen.add(next);
         const module = this.getModule(next)!;
         toProcess.push(...module[field]);
-        if (next !== this.#manifest.main.name) { // Do not include self
+        if (next !== this.#manifest.main.name) {
+          // Do not include self
           out.push(module);
         }
       }
@@ -254,13 +249,11 @@ export class ManifestIndex {
    */
   findModuleForArbitraryFile(file: string): ManifestModule | undefined {
     const base = this.#manifest.workspace.path;
-    const lookup = this.#arbitraryLookup ??= ManifestUtil.lookupTrie(
+    const lookup = (this.#arbitraryLookup ??= ManifestUtil.lookupTrie(
       Object.values(this.#manifest.modules),
       module => module.sourceFolder.split('/'),
-      sub =>
-        !existsSync(path.resolve(base, ...sub, 'package.json')) &&
-        !existsSync(path.resolve(base, ...sub, '.git'))
-    );
+      sub => !existsSync(path.resolve(base, ...sub, 'package.json')) && !existsSync(path.resolve(base, ...sub, '.git'))
+    ));
     return lookup(file.replace(`${base}/`, '').split('/'));
   }
 
@@ -306,7 +299,7 @@ export class ManifestIndex {
   /**
    * Group by lineage, data can be duplicated
    */
-  groupByLineage<T extends { action: string }>(items: { item: T, module: string }[]): Map<string, T[]> {
+  groupByLineage<T extends { action: string }>(items: { item: T; module: string }[]): Map<string, T[]> {
     const itemsByModule = new Map<string, T[]>();
     for (const event of items) {
       const moduleSet = new Set(this.getDependentModules(event.module, 'parents').map(module => module.name));
@@ -332,4 +325,4 @@ export class ManifestIndex {
   resolvePackageCommand(cmd: string): string {
     return path.resolve(this.manifest.workspace.path, 'node_modules', '.bin', cmd);
   }
-}
+}

package/src/module.ts

@@ -1,11 +1,10 @@
 import fs from 'node:fs/promises';
 
-import path from './path.ts';
 import { PackageModuleVisitor } from './dependencies.ts';
-
-import type { ManifestModuleFileType, ManifestModuleRole, ManifestModuleFolderType } from './types/common.ts';
-import type { ManifestModuleFile, ManifestModule, PackageModule } from './types/manifest.ts';
+import path from './path.ts';
+import type { ManifestModuleFileType, ManifestModuleFolderType, ManifestModuleRole } from './types/common.ts';
 import type { ManifestContext } from './types/context.ts';
+import type { ManifestModule, ManifestModuleFile, PackageModule } from './types/manifest.ts';
 
 const EXT_MAPPING: Record<string, ManifestModuleFileType> = {
   '.js': 'js',
@@ -17,11 +16,7 @@ const EXT_MAPPING: Record<string, ManifestModuleFileType> = {
   '.md': 'md'
 };
 
-const INDEX_FILES = new Set(
-  ['__index__', '__index', 'index'].flatMap(file =>
-    ['ts', 'tsx', 'js'].map(ext => `${file}.${ext}`)
-  )
-);
+const INDEX_FILES = new Set(['__index__', '__index', 'index'].flatMap(file => ['ts', 'tsx', 'js'].map(ext => `${file}.${ext}`)));
 
 const STD_TOP_FOLDERS = new Set(['src', 'bin', 'support']);
 const FULL_TOP_FOLDERS = new Set([...STD_TOP_FOLDERS, 'doc', 'test', 'resources']);
@@ -40,7 +35,6 @@ const SUPPORT_FILE_MAP: Record<string, ManifestModuleRole> = {
 const SUPPORT_FILE_REGEX = new RegExp(`^support[/](?<name>${Object.keys(SUPPORT_FILE_MAP).join('|')})[./]`);
 
 export class ManifestModuleUtil {
-
   static TYPINGS_EXT = '.d.ts';
   static OUTPUT_EXT = '.js';
   static SOURCE_DEF_EXT = '.ts';
@@ -50,7 +44,7 @@ export class ManifestModuleUtil {
 
   static #scanCache: Record<string, string[]> = {};
 
-  static #getNewest(stat: { mtimeMs: number, ctimeMs: number }): number {
+  static #getNewest(stat: { mtimeMs: number; ctimeMs: number }): number {
     return Math.max(stat.mtimeMs, stat.ctimeMs);
   }
 
@@ -70,7 +64,7 @@ export class ManifestModuleUtil {
       return this.#scanCache[key];
     }
 
-    if (!await fs.stat(folder, { throwIfNoEntry: false })) {
+    if (!(await fs.stat(folder, { throwIfNoEntry: false }))) {
       return [];
     }
 
@@ -78,7 +72,7 @@ export class ManifestModuleUtil {
 
     const exclude = new Set([
       path.resolve(ctx.workspace.path, ctx.build.outputFolder),
-      path.resolve(ctx.workspace.path, ctx.build.toolFolder),
+      path.resolve(ctx.workspace.path, ctx.build.toolFolder)
     ]);
 
     const topFolders = full ? FULL_TOP_FOLDERS : STD_TOP_FOLDERS;
@@ -94,7 +88,7 @@ export class ManifestModuleUtil {
       const [top, depth] = popped;
 
       // Don't navigate into sub-folders with package.json's
-      if (top !== folder && await fs.stat(`${top}/package.json`, { throwIfNoEntry: false })) {
+      if (top !== folder && (await fs.stat(`${top}/package.json`, { throwIfNoEntry: false }))) {
         continue;
       } else if (exclude.has(top)) {
         continue;
@@ -118,7 +112,7 @@ export class ManifestModuleUtil {
       }
     }
 
-    return this.#scanCache[key] = out;
+    return (this.#scanCache[key] = out);
   }
 
   /**
@@ -179,8 +173,10 @@ export class ManifestModuleUtil {
         case 'test':
         case 'doc':
         case 'resources':
-        case 'support': return key;
-        default: throw new Error(`Unknown folder: ${key}`);
+        case 'support':
+          return key;
+        default:
+          throw new Error(`Unknown folder: ${key}`);
       }
     } else if (/^DOC[.]tsx?$/.test(moduleFile)) {
       return 'doc';
@@ -197,7 +193,7 @@ export class ManifestModuleUtil {
    * Convert file (by ext) to a known file type and also retrieve its latest timestamp
    */
   static async transformFile(moduleFile: string, full: string): Promise<ManifestModuleFile> {
-    const updated = this.#getNewest(await fs.stat(full, { throwIfNoEntry: false }) ?? { mtimeMs: 0, ctimeMs: 0 });
+    const updated = this.#getNewest((await fs.stat(full, { throwIfNoEntry: false })) ?? { mtimeMs: 0, ctimeMs: 0 });
     const moduleFileTuple: ManifestModuleFile = [moduleFile, this.getFileType(moduleFile), updated];
     const role = this.getFileRole(moduleFile);
     return role ? [...moduleFileTuple, role] : moduleFileTuple;
@@ -266,4 +262,4 @@ export class ManifestModuleUtil {
     }
     return type === 'ts' || type === 'package-json' || type === 'js' || type === 'typings';
   }
-}
+}

package/src/package.ts

@@ -1,18 +1,16 @@
-import { createRequire } from 'node:module';
 import { execSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
 
-import path from './path.ts';
 import { ManifestFileUtil } from './file.ts';
-
-import { PackagePathSymbol, type Package, type PackageWorkspaceEntry } from './types/package.ts';
+import path from './path.ts';
 import type { ManifestContext } from './types/context.ts';
+import { type Package, PackagePathSymbol, type PackageWorkspaceEntry } from './types/package.ts';
 
 /**
  * Utilities for querying, traversing and reading package.json files.
  */
 export class PackageUtil {
-
   static #resolvers: Record<string, (imp: string) => string> = {};
   static #cache: Record<string, Package> = {};
   static #workspaces: Record<string, PackageWorkspaceEntry[]> = {};
@@ -46,7 +44,8 @@ export class PackageUtil {
       try {
         const resolved = this.resolveImport(name, root);
         return path.join(resolved.split(name)[0], name);
-      } catch { // When import lookup fails
+      } catch {
+        // When import lookup fails
         let folder = root ?? process.cwd();
         let previous = '';
         while (folder !== previous) {
@@ -69,9 +68,9 @@ export class PackageUtil {
     if (forceRead) {
       delete this.#cache[modulePath];
     }
-    const nodePackage = this.#cache[modulePath] ??= ManifestFileUtil.readAsJsonSync(
-      modulePath.endsWith('.json') ? modulePath : path.resolve(modulePath, 'package.json'),
-    );
+    const nodePackage = (this.#cache[modulePath] ??= ManifestFileUtil.readAsJsonSync(
+      modulePath.endsWith('.json') ? modulePath : path.resolve(modulePath, 'package.json')
+    ));
 
     nodePackage.name ??= 'untitled'; // If a package.json (root-only) is missing a name, allows for execution
 
@@ -93,21 +92,30 @@ export class PackageUtil {
     const rootPath = ctx.workspace.path;
     const cache = path.resolve(rootPath, ctx.build.outputFolder, 'workspaces.json');
     try {
-      return this.#workspaces[rootPath] ??= ManifestFileUtil.readAsJsonSync(cache);
+      return (this.#workspaces[rootPath] ??= ManifestFileUtil.readAsJsonSync(cache));
     } catch {
       let args: string[];
       switch (ctx.workspace.manager) {
         case 'yarn':
-        case 'npm': args = ['query', '.workspace']; break;
-        case 'pnpm': args = ['ls', '-r', '--depth', '-1', '--json']; break;
+        case 'npm':
+          args = ['query', '.workspace'];
+          break;
+        case 'pnpm':
+          args = ['ls', '-r', '--depth', '-1', '--json'];
+          break;
       }
 
       const env = { PATH: process.env.PATH, NODE_PATH: process.env.NODE_PATH };
-      const text = execSync(`${ctx.workspace.manager} ${args.join(' ')}`, { cwd: rootPath, encoding: 'utf8', env, stdio: ['pipe', 'pipe'] });
+      const text = execSync(`${ctx.workspace.manager} ${args.join(' ')}`, {
+        cwd: rootPath,
+        encoding: 'utf8',
+        env,
+        stdio: ['pipe', 'pipe']
+      });
       const out: PackageWorkspaceEntry[] = JSON.parse(text.trim());
       const filtered = out.map(item => ({ name: item.name, path: item.path }));
       await ManifestFileUtil.bufferedFileWrite(cache, JSON.stringify(filtered));
       return filtered;
     }
   }
-}
+}

package/src/path.ts

@@ -1,9 +1,9 @@
+import native from 'node:path';
 import posix from 'node:path/posix';
 import win32 from 'node:path/win32';
-import native from 'node:path';
 
 const toPosix = (file: string): string => file.replaceAll('\\', '/');
-const toNative = (file: string): string => file.replace(/[\/]/g, native.sep);
+const toNative = (file: string): string => file.replace(/[/\\]/g, native.sep);
 const cwd = (): string => toPosix(process.cwd());
 
 const path: typeof posix & {
@@ -22,25 +22,27 @@ const path: typeof posix & {
   toNative,
   toPosix,
   matchesGlob: (file, pattern) => posix.matchesGlob(toPosix(file), toPosix(pattern)),
-  ...process.platform === 'win32' ? {
-    resolve: (...args) => toPosix(native.resolve(cwd(), ...args.map(toPosix))),
-    join: (root, ...args) => toPosix(native.join(toPosix(root), ...args.map(toPosix))),
-    relative: (from, to) => toPosix(native.relative(toPosix(from), toPosix(to))),
-    isAbsolute: (file) => native.isAbsolute(toPosix(file)),
-    normalize: (file) => toPosix(native.normalize(toPosix(file))),
-    parse: (file) => native.parse(toPosix(file)),
-    format: (value) => toPosix(native.format(value)),
-    toNamespacedPath: (file) => toPosix(native.toNamespacedPath(toPosix(file))),
-  } : {
-    relative: (from, to) => posix.relative(toPosix(from), toPosix(to)),
-    resolve: (...args) => posix.resolve(cwd(), ...args.map(toPosix)),
-    join: (...args) => posix.join(...args.map(toPosix)),
-    isAbsolute: file => posix.isAbsolute(toPosix(file)),
-    normalize: file => posix.normalize(toPosix(file)),
-    parse: file => posix.parse(toPosix(file)),
-    format: value => posix.format(value),
-    toNamespacedPath: file => toPosix(file),
-  }
+  ...(process.platform === 'win32'
+    ? {
+        resolve: (...args) => toPosix(native.resolve(cwd(), ...args.map(toPosix))),
+        join: (root, ...args) => toPosix(native.join(toPosix(root), ...args.map(toPosix))),
+        relative: (from, to) => toPosix(native.relative(toPosix(from), toPosix(to))),
+        isAbsolute: file => native.isAbsolute(toPosix(file)),
+        normalize: file => toPosix(native.normalize(toPosix(file))),
+        parse: file => native.parse(toPosix(file)),
+        format: value => toPosix(native.format(value)),
+        toNamespacedPath: file => toPosix(native.toNamespacedPath(toPosix(file)))
+      }
+    : {
+        relative: (from, to) => posix.relative(toPosix(from), toPosix(to)),
+        resolve: (...args) => posix.resolve(cwd(), ...args.map(toPosix)),
+        join: (...args) => posix.join(...args.map(toPosix)),
+        isAbsolute: file => posix.isAbsolute(toPosix(file)),
+        normalize: file => posix.normalize(toPosix(file)),
+        parse: file => posix.parse(toPosix(file)),
+        format: value => posix.format(value),
+        toNamespacedPath: file => toPosix(file)
+      })
 };
 
-export default path;
+export default path;

package/src/types/common.ts

@@ -1,10 +1,19 @@
 export type ManifestModuleFileType = 'typings' | 'ts' | 'js' | 'json' | 'package-json' | 'unknown' | 'fixture' | 'md';
 export type ManifestModuleFolderType =
-  '$root' | '$index' | '$package' |
-  'src' | 'bin' | 'support' | 'resources' | 'test' | 'doc' |
-  'test/fixtures' | 'support/fixtures' | 'support/resources' |
-  '$transformer';
+  | '$root'
+  | '$index'
+  | '$package'
+  | 'src'
+  | 'bin'
+  | 'support'
+  | 'resources'
+  | 'test'
+  | 'doc'
+  | 'test/fixtures'
+  | 'support/fixtures'
+  | 'support/resources'
+  | '$transformer';
 
 export type ManifestModuleRole = 'std' | 'test' | 'doc' | 'compile' | 'build';
 
-export type ChangeEventType = 'create' | 'update' | 'delete';
+export type ChangeEventType = 'create' | 'update' | 'delete';

package/src/types/context.ts

@@ -31,4 +31,4 @@ export type ManifestContext = {
     /** Version of the main module */
     version: string;
   };
-};
+};

package/src/types/manifest.ts

@@ -3,8 +3,8 @@ import type { ManifestContext } from './context.ts';
 import type { Package } from './package.ts';
 
 export type ManifestModuleFile =
-  [path: string, type: ManifestModuleFileType, updated: number] |
-  [path: string, type: ManifestModuleFileType, updated: number, role: ManifestModuleRole];
+  | [path: string, type: ManifestModuleFileType, updated: number]
+  | [path: string, type: ManifestModuleFileType, updated: number, role: ManifestModuleRole];
 
 export type ManifestDepCore = {
   /** Package name */

package/src/types/package.ts

@@ -66,4 +66,4 @@ export type Package = {
 
 export type PackageDependencyType = 'dependencies' | 'devDependencies' | 'optionalDependencies' | 'peerDependencies';
 
-export type PackageWorkspaceEntry = { name: string, path: string };
+export type PackageWorkspaceEntry = { name: string; path: string };

package/src/util.ts

@@ -1,11 +1,10 @@
-import path from './path.ts';
-import { ManifestModuleUtil } from './module.ts';
 import { ManifestFileUtil } from './file.ts';
+import { ManifestModuleUtil } from './module.ts';
 import { PackageUtil } from './package.ts';
-
+import path from './path.ts';
+import type { ChangeEventType } from './types/common.ts';
 import type { ManifestContext } from './types/context.ts';
 import type { ManifestRoot } from './types/manifest.ts';
-import type { ChangeEventType } from './types/common.ts';
 
 const MANIFEST_FILE = 'manifest.json';
 
@@ -22,7 +21,7 @@ export class ManifestUtil {
       workspace: ctx.workspace,
       build: ctx.build,
       main: ctx.main,
-      modules: await ManifestModuleUtil.produceModules(ctx),
+      modules: await ManifestModuleUtil.produceModules(ctx)
     };
   }
 
@@ -45,14 +44,17 @@ export class ManifestUtil {
       build: {
         ...manifest.build,
         // Mark output folder/workspace path as portable
-        outputFolder: '$$PRODUCTION$$',
+        outputFolder: '$$PRODUCTION$$'
       },
       main: manifest.main,
       modules: Object.fromEntries(
-        modules.map(module => [module.name, Object.assign(module, {
-          parents: module.parents.filter(parent => moduleNames.has(parent))
-        })])
-      ),
+        modules.map(module => [
+          module.name,
+          Object.assign(module, {
+            parents: module.parents.filter(parent => moduleNames.has(parent))
+          })
+        ])
+      )
     };
   }
 
@@ -117,15 +119,17 @@ export class ManifestUtil {
    * Produce the manifest context for the workspace module
    */
   static getWorkspaceContext(ctx: ManifestContext): ManifestContext {
-    return ctx.workspace.mono ? {
-      workspace: ctx.workspace,
-      build: ctx.build,
-      main: {
-        name: ctx.workspace.name,
-        folder: '',
-        version: '0.0.0',
-      }
-    } : ctx;
+    return ctx.workspace.mono
+      ? {
+          workspace: ctx.workspace,
+          build: ctx.build,
+          main: {
+            name: ctx.workspace.name,
+            folder: '',
+            version: '0.0.0'
+          }
+        }
+      : ctx;
   }
 
   /**
@@ -151,9 +155,11 @@ export class ManifestUtil {
    * Efficient lookup for path-based graphs
    */
   static lookupTrie<T>(
-    inputs: T[], getPath: (value: T) => string[], validateUnknown?: (inputPath: string[]) => boolean
+    inputs: T[],
+    getPath: (value: T) => string[],
+    validateUnknown?: (inputPath: string[]) => boolean
   ): (inputPath: string[]) => T | undefined {
-    type TrieNode = { value?: T, subPaths: Record<string, TrieNode> };
+    type TrieNode = { value?: T; subPaths: Record<string, TrieNode> };
     const root: TrieNode = { subPaths: {} };
     for (const item of inputs) {
       const inputPath = getPath(item);
@@ -197,13 +203,17 @@ export class ManifestUtil {
     const fileType = ManifestModuleUtil.getFileType(relativeFile);
     const roleType = ManifestModuleUtil.getFileRole(relativeFile)!;
 
-    const manifestModuleFiles = manifest.modules[moduleName].files[folderKey] ??= [];
+    const manifestModuleFiles = (manifest.modules[moduleName].files[folderKey] ??= []);
     const idx = manifestModuleFiles.findIndex(indexedFile => indexedFile[0] === relativeFile);
     const wrappedIdx = idx < 0 ? manifestModuleFiles.length : idx;
 
     switch (action) {
-      case 'create': manifestModuleFiles[wrappedIdx] = [relativeFile, fileType, Date.now(), roleType]; break;
-      case 'delete': idx >= 0 && manifestModuleFiles.splice(idx, 1); break;
+      case 'create':
+        manifestModuleFiles[wrappedIdx] = [relativeFile, fileType, Date.now(), roleType];
+        break;
+      case 'delete':
+        idx >= 0 && manifestModuleFiles.splice(idx, 1);
+        break;
     }
   }
-}
+}