@travetto/manifest 4.0.0-rc.0 → 4.0.0-rc.2

package/README.md

@@ -30,12 +30,12 @@ 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#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.
+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.
 
 ## 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. 
 
-`Ⲑid` is used heavily throughout the framework for determining which classes are owned by the framework, and being able to lookup the needed data from the [RuntimeIndex](https://github.com/travetto/travetto/tree/main/module/manifest/src/runtime.ts#L11) using the `getFunctionMetadata` method.
+`Ⲑid` is used heavily throughout the framework for determining which classes are owned by the framework, and being able to lookup the needed data from the [RuntimeIndex](https://github.com/travetto/travetto/tree/main/module/manifest/src/runtime.ts#L14) using the `getFunctionMetadata` method.
 
 **Code: Test Class**
 ```typescript
@@ -97,13 +97,15 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
     "path": "<generated>",
     "mono": true,
     "manager": "npm",
-    "type": "commonjs"
+    "type": "commonjs",
+    "defaultEnv": "local"
   },
   "build": {
     "compilerFolder": ".trv/compiler",
     "compilerUrl": "http://127.0.0.1:26803",
     "compilerModuleFolder": "module/compiler",
-    "outputFolder": ".trv/output"
+    "outputFolder": ".trv/output",
+    "toolFolder": ".trv/tool"
   },
   "main": {
     "name": "@travetto/manifest",
@@ -114,15 +116,15 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
   "modules": {
     "@travetto/manifest": {
       "main": true,
+      "prod": true,
       "name": "@travetto/manifest",
       "version": "x.x.x",
-      "local": true,
+      "workspace": true,
       "internal": false,
       "sourceFolder": "module/manifest",
       "outputFolder": "node_modules/@travetto/manifest",
       "roles": [ "std" ],
       "parents": [],
-      "prod": true,
       "files": {
         "$root": [
           [ "DOC.html", "unknown", 1868155200000 ],
@@ -160,8 +162,11 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
           [ "src/package.ts", "ts", 1868155200000 ],
           [ "src/path.ts", "ts", 1868155200000 ],
           [ "src/runtime.ts", "ts", 1868155200000 ],
-          [ "src/types.ts", "ts", 1868155200000 ],
-          [ "src/util.ts", "ts", 1868155200000 ]
+          [ "src/util.ts", "ts", 1868155200000 ],
+          [ "src/types/common.ts", "ts", 1868155200000 ],
+          [ "src/types/context.ts", "ts", 1868155200000 ],
+          [ "src/types/manifest.ts", "ts", 1868155200000 ],
+          [ "src/types/package.ts", "ts", 1868155200000 ]
         ],
         "bin": [
           [ "bin/context.d.ts", "typings", 1868155200000 ],

package/__index__.ts

@@ -8,4 +8,7 @@ export * from './src/runtime';
 export * from './src/package';
 export * from './src/util';
 export * from './src/file';
-export * from './src/types';
+export * from './src/types/context';
+export * from './src/types/package';
+export * from './src/types/manifest';
+export * from './src/types/common';

package/bin/context.d.ts

@@ -4,7 +4,7 @@ declare namespace ManifestBootstrap {
   /**
    * Get Context for building
    */
-  function getManifestContext(folder?: string): Promise<ManifestContext>;
+  function getManifestContext(folder?: string): ManifestContext;
 }
 
 export = ManifestBootstrap;

package/bin/context.js

@@ -1,11 +1,11 @@
 // @ts-check
 
 /**
- * @typedef {import('../src/types').Package & { path:string }} Pkg
+ * @typedef {import('../src/types/package').Package & { path:string }} Pkg
  * @typedef {Pkg & { mono: boolean, manager: 'yarn'|'npm', resolve: (file:string) => string}} Workspace
- * @typedef {import('../src/types').ManifestContext} ManifestContext
+ * @typedef {import('../src/types/context').ManifestContext} ManifestContext
  */
-import fs from 'node:fs/promises';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 
@@ -17,24 +17,26 @@ const OUTPUT_FOLDER = '.trv/output';
 /**
  * Read package.json or return undefined if missing
  * @param {string} dir
- * @returns {Promise<Pkg|undefined>}
+ * @returns {Pkg|undefined}
  */
-async function $readPackage(dir) {
+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);
+  try {
+    const v = readFileSync(path.resolve(dir, 'package.json'), 'utf8');
+    return ({ ...JSON.parse(v), path: path.resolve(dir) });
+  } catch { }
 }
 
 /**
  * Find package.json for a given folder
  * @param {string} dir
- * @return {Promise<Pkg>}
+ * @return {Pkg}
  */
-async function $findPackage(dir) {
+function $findPackage(dir) {
   let prev;
   let pkg, curr = path.resolve(dir);
   while (!pkg && curr !== prev) {
-    pkg = await $readPackage(curr);
+    pkg = $readPackage(curr);
     [prev, curr] = [curr, path.dirname(curr)];
   }
   if (!pkg) {
@@ -46,9 +48,9 @@ async function $findPackage(dir) {
 
 /**
  * Get workspace root
- * @return {Promise<Workspace>}
+ * @return {Workspace}
  */
-async function $resolveWorkspace(base = process.cwd()) {
+function $resolveWorkspace(base = process.cwd()) {
   if (base in WS_ROOT) { return WS_ROOT[base]; }
   let folder = base;
   let prev;
@@ -57,10 +59,10 @@ async function $resolveWorkspace(base = process.cwd()) {
 
   while (prev !== folder) {
     [prev, prevPkg] = [folder, pkg];
-    pkg = await $readPackage(folder) ?? pkg;
+    pkg = $readPackage(folder) ?? pkg;
     if (
       (pkg && (!!pkg.workspaces || !!pkg.travetto?.build?.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
+      existsSync(path.resolve(folder, '.git')) // we made it to the source repo root
     ) {
       break;
     }
@@ -75,7 +77,7 @@ async function $resolveWorkspace(base = process.cwd()) {
     ...pkg,
     name: pkg.name ?? 'untitled',
     type: pkg.type,
-    manager: await fs.stat(path.resolve(pkg.path, 'yarn.lock')).catch(() => { }) ? 'yarn' : 'npm',
+    manager: existsSync(path.resolve(pkg.path, 'yarn.lock')) ? 'yarn' : 'npm',
     resolve: createRequire(`${pkg.path}/node_modules`).resolve.bind(null),
     mono: !!pkg.workspaces || (!pkg.travetto?.build?.isolated && !!prevPkg)  // Workspaces or nested projects
   };
@@ -84,15 +86,16 @@ async function $resolveWorkspace(base = process.cwd()) {
 /**
  * Get Compiler url
  * @param {Workspace} ws
+ * @param {string} toolFolder
  */
-async function $getCompilerUrl(ws) {
-  const file = path.resolve(ws.path, TOOL_FOLDER, 'build.compilerUrl');
+function $getCompilerUrl(ws, toolFolder) {
+  const file = path.resolve(ws.path, toolFolder, 'build.compilerUrl');
   // eslint-disable-next-line no-bitwise
   const port = (Math.abs([...file].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
   const out = `http://localhost:${port}`;
-  try { await fs.stat(file); } catch {
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    await fs.writeFile(file, out, 'utf8');
+  if (!existsSync(file)) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, out, 'utf8');
   }
   return out;
 }
@@ -102,13 +105,16 @@ async function $getCompilerUrl(ws) {
  * @param {Workspace} workspace
  * @param {string|undefined} folder
  */
-async function $resolveModule(workspace, folder) {
+function $resolveModule(workspace, folder) {
   let mod;
   if (!folder && process.env.TRV_MODULE) {
     mod = process.env.TRV_MODULE;
     if (/[.](t|j)sx?$/.test(mod)) { // Rewrite from file to module
-      process.env.TRV_MODULE = mod = await $findPackage(path.dirname(mod))
-        .then(v => v.name, () => '');
+      try {
+        process.env.TRV_MODULE = mod = $findPackage(path.dirname(mod)).name;
+      } catch {
+        process.env.TRV_MODULE = mod = '';
+      }
     }
   }
 
@@ -116,7 +122,7 @@ async function $resolveModule(workspace, folder) {
     try {
       folder = path.dirname(workspace.resolve(`${mod}/package.json`));
     } catch {
-      const workspacePkg = await $readPackage(workspace.path);
+      const workspacePkg = $readPackage(workspace.path);
       if (workspacePkg?.name === mod) {
         folder = workspace.path;
       } else {
@@ -131,12 +137,13 @@ async function $resolveModule(workspace, folder) {
 /**
  * Gets build context
  * @param {string} [folder]
- * @return {Promise<ManifestContext>}
+ * @return {ManifestContext}
  */
-export async function getManifestContext(folder) {
-  const workspace = await $resolveWorkspace(folder);
-  const mod = await $resolveModule(workspace, folder);
+export function getManifestContext(folder) {
+  const workspace = $resolveWorkspace(folder);
+  const mod = $resolveModule(workspace, folder);
   const build = workspace.travetto?.build ?? {};
+  const toolFolder = build.toolFolder ?? TOOL_FOLDER;
 
   return {
     workspace: {
@@ -144,13 +151,15 @@ export async function getManifestContext(folder) {
       path: workspace.path,
       mono: workspace.mono,
       manager: workspace.manager,
-      type: workspace.type ?? 'commonjs'
+      type: workspace.type ?? 'commonjs',
+      defaultEnv: workspace.travetto?.defaultEnv ?? 'local'
     },
     build: {
       compilerFolder: build.compilerFolder ?? COMPILER_FOLDER,
-      compilerUrl: build.compilerUrl ?? await $getCompilerUrl(workspace),
+      compilerUrl: build.compilerUrl ?? $getCompilerUrl(workspace, toolFolder),
       compilerModuleFolder: path.dirname(workspace.resolve('@travetto/compiler/package.json')).replace(`${workspace.path}/`, ''),
       outputFolder: build.outputFolder ?? OUTPUT_FOLDER,
+      toolFolder
     },
     main: {
       name: mod.name ?? 'untitled',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "4.0.0-rc.0",
+  "version": "4.0.0-rc.2",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
     "path",

package/src/delta.ts

@@ -1,18 +1,19 @@
-import {
-  ManifestContext, ManifestModule, ManifestModuleCore, ManifestModuleFile,
-  ManifestModuleFileType, ManifestModuleFolderType, ManifestRoot
-} from './types';
+import fs from 'node:fs/promises';
 
 import { ManifestModuleUtil } from './module';
-import { ManifestFileUtil } from './file';
 import { path } from './path';
 
+import type { ManifestModule, ManifestModuleCore, ManifestModuleFile, ManifestRoot } from './types/manifest';
+import type { ManifestModuleFileType, ManifestModuleFolderType } from './types/common';
+import type { ManifestContext } from './types/context';
+
 type DeltaEventType = 'added' | 'changed' | 'removed' | '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', '$package', 'doc']);
-const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
+const VALID_OUTPUT_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
+const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>([...VALID_OUTPUT_TYPE, 'typings']);
 
 /**
  * Produce delta for the manifest
@@ -37,7 +38,7 @@ export class ManifestDeltaUtil {
       (await ManifestModuleUtil.scanFolder(root, left.main))
         .filter(x => {
           const type = ManifestModuleUtil.getFileType(x);
-          return type === 'ts' || type === 'typings' || type === 'js' || type === 'package-json';
+          return VALID_SOURCE_TYPE.has(type);
         })
         .map(x => ManifestModuleUtil.sourceToBlankExt(x.replace(`${root}/`, '')))
     );
@@ -45,7 +46,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 ManifestFileUtil.statFile(output);
+      const stat = await fs.stat(output).catch(() => undefined);
       right.delete(ManifestModuleUtil.sourceToBlankExt(el));
 
       if (!stat) {
@@ -77,7 +78,7 @@ export class ManifestDeltaUtil {
         continue;
       }
       for (const [name, type, date] of m.files?.[key] ?? []) {
-        if (VALID_SOURCE_TYPE.has(type)) {
+        if (VALID_OUTPUT_TYPE.has(type)) {
           out[name] = [name, type, date];
         }
       }

package/src/dependencies.ts

@@ -1,137 +1,126 @@
 import { PackageUtil } from './package';
 import { path } from './path';
-import { ManifestContext, ManifestModuleRole, PackageVisitor, PackageVisitReq, Package, ManifestDepCore } from './types';
 
-export type ModuleDep = ManifestDepCore & {
+import type { Package, PackageDepType } from './types/package';
+import type { ManifestContext } from './types/context';
+import type { PackageModule } from './types/manifest';
+
+type CreateOpts = Partial<Pick<PackageModule, 'main' | 'workspace' | 'prod'>> & { roleRoot?: boolean, parent?: PackageModule };
+
+type Req = {
+  /** Request package */
   pkg: Package;
-  mainLike?: boolean;
-  sourcePath: string;
-  childSet: Set<string>;
-  parentSet: Set<string>;
-  roleSet: Set<ManifestModuleRole>;
-  topLevel?: boolean;
+  /** Children to visit */
+  children: Record<string, string>;
+  /** Value */
+  value: PackageModule;
+  /** Parent */
+  parent?: PackageModule;
 };
 
 /**
  * Used for walking dependencies for collecting modules for the manifest
  */
-export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
+export class PackageModuleVisitor {
 
   constructor(public ctx: ManifestContext) {
     this.#mainSourcePath = path.resolve(this.ctx.workspace.path, this.ctx.main.folder);
   }
 
-  #mainLikeModules = new Set<string>();
   #mainSourcePath: string;
-
-  /**
-   * Main source path for searching
-   */
-  get rootPath(): string {
-    return this.#mainSourcePath;
-  }
+  #cache: Record<string, PackageModule> = {};
+  #workspaceModules: Map<string, string>;
 
   /**
    * Initialize visitor, and provide global dependencies
    */
-  async init(req: PackageVisitReq<ModuleDep>): Promise<PackageVisitReq<ModuleDep>[]> {
-    const pkg = PackageUtil.readPackage(req.sourcePath);
-    const workspacePkg = PackageUtil.readPackage(this.ctx.workspace.path);
-    const workspaceModules = pkg.workspaces?.length ? (await PackageUtil.resolveWorkspaces(this.ctx, req.sourcePath)) : [];
-
-    this.#mainLikeModules = new Set([
-      pkg.name,
-      ...Object.entries(pkg.travetto?.build?.withModules ?? []).filter(x => x[1] === 'main').map(x => x[0]),
-      // Add workspace folders, for tests and docs
-      ...workspaceModules.map(x => x.name)
-    ]);
-
-    const globals = Object.keys(workspacePkg.travetto?.build?.withModules ?? [])
-      .map(name => PackageUtil.packageReq<ModuleDep>(PackageUtil.resolvePackagePath(name), name in (workspacePkg.dependencies ?? {}), true));
-
-    const workspaceModuleDeps = workspaceModules
-      .map(entry => PackageUtil.packageReq<ModuleDep>(path.resolve(req.sourcePath, entry.sourcePath), false, true));
+  async init(): Promise<Iterable<Req>> {
+    const mainReq = this.#create(this.#mainSourcePath, { main: true, workspace: true, roleRoot: true, prod: true });
+    const globals = [mainReq];
+    this.#workspaceModules = new Map(
+      (await PackageUtil.resolveWorkspaces(this.ctx)).map(x => [x.name, x.path])
+    );
 
-    return [...globals, ...workspaceModuleDeps];
-  }
+    // Treat all workspace modules as main modules
+    if (this.ctx.workspace.mono && !this.ctx.main.folder) {
+      for (const [, loc] of this.#workspaceModules) {
+        globals.push(this.#create(loc, { main: true, workspace: true, roleRoot: true, parent: mainReq.value }));
+      }
+    } else {
+      // If we have 'withModules' at workspace root
+      const root = PackageUtil.readPackage(this.ctx.workspace.path);
+      for (const [name, type] of Object.entries(root.travetto?.build?.withModules ?? {})) {
+        globals.push(this.#create(PackageUtil.resolvePackagePath(name),
+          { main: type === 'main', workspace: true, parent: mainReq.value }
+        ));
+      }
+    }
 
-  /**
-   * Is valid dependency for searching
-   */
-  valid(req: PackageVisitReq<ModuleDep>): boolean {
-    return req.sourcePath === this.#mainSourcePath || (
-      (!!req.pkg.travetto || req.pkg.private === true || !req.sourcePath.includes('node_modules'))
-    );
+    return globals;
   }
 
   /**
-   * Create dependency from request
+   * Build a package module
    */
-  create(req: PackageVisitReq<ModuleDep>): ModuleDep {
-    const { pkg, sourcePath } = req;
-    const { name, version } = pkg;
-    const main = name === this.ctx.main.name;
-    const mainLike = main || this.#mainLikeModules.has(name);
-    const internal = pkg.private === true;
-    const local = internal || mainLike || !sourcePath.includes('node_modules');
-
-    const dep: ModuleDep = {
-      name, version, sourcePath, main, mainLike, local, internal, pkg: req.pkg,
-      parentSet: new Set([]), childSet: new Set([]), roleSet: new Set([]), prod: req.prod, topLevel: req.topLevel
+  #create(sourcePath: string, { main, workspace, prod = false, roleRoot = false, parent }: CreateOpts = {}): Req {
+    const pkg = PackageUtil.readPackage(sourcePath);
+    const value = this.#cache[sourcePath] ??= {
+      main,
+      prod,
+      name: pkg.name,
+      version: pkg.version,
+      workspace: workspace ?? this.#workspaceModules.has(pkg.name),
+      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, prodDeps: new Set(Object.keys(pkg.dependencies ?? {}))
+      }
     };
 
-    return dep;
-  }
-
-  /**
-   * Visit dependency
-   */
-  visit(req: PackageVisitReq<ModuleDep>, dep: ModuleDep): void {
-    const { parent } = req;
-    if (parent && dep.name !== this.ctx.main.name) {
-      dep.parentSet.add(parent.name);
-      parent.childSet.add(dep.name);
-    }
+    const deps: PackageDepType[] = ['dependencies', ...(value.main ? ['devDependencies'] as const : [])];
+    const children = Object.fromEntries(deps.flatMap(x => Object.entries(pkg[x] ?? {})));
+    return { pkg, value, children, parent };
   }
 
   /**
    * Propagate prod, role information through graph
    */
-  complete(deps: Set<ModuleDep>): Set<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 Set(el.childSet), el });
-    }
-
-    const main = mapping.get(this.ctx.main.name)!;
-
-    // Visit all direct dependencies and mark
-    for (const { el } of mapping.values()) {
-      if (!main.child.has(el.name)) { // Not a direct descendent
-        el.prod = false;
-      }
-      if (main.child.has(el.name) || (el.topLevel && el !== main.el)) { // Direct descendant
-        el.roleSet = new Set(el.pkg.travetto?.roles ?? []);
-        if (!el.roleSet.size) {
-          el.roleSet.add('std');
-        }
+  async #complete(mods: Iterable<PackageModule>): Promise<PackageModule[]> {
+    const mapping = new Map([...mods].map(el => [el.name, { parent: new Set(el.state.parentSet), el }]));
+
+    // All first-level dependencies should have role filled in (for propagation)
+    for (const dep of [...mods].filter(x => x.state.roleRoot)) {
+      dep.state.roleSet.clear(); // Ensure the roleRoot is empty
+      for (const c of dep.state.childSet) { // Visit children
+        const cDep = mapping.get(c)!.el;
+        if (cDep.state.roleRoot) { continue; }
+        // Set roles for all top level modules
+        cDep.state.roleSet = new Set(cDep.state.travetto?.roles ?? ['std']);
       }
     }
 
+    // Visit all nodes
     while (mapping.size > 0) {
       const toProcess = [...mapping.values()].filter(x => x.parent.size === 0);
       if (!toProcess.length) {
         throw new Error(`We have reached a cycle for ${[...mapping.keys()]}`);
       }
-      // Propagate
-      for (const { el, child } of toProcess) {
-        for (const c of child.keys()) {
-          const { el: cDep, parent } = mapping.get(c)!;
-          parent.delete(el.name); // Remove from child
-          for (const role of el.roleSet) {
-            cDep.roleSet.add(role);
+      // Propagate to children
+      for (const { el } of toProcess) {
+        for (const c of el.state.childSet) {
+          const child = mapping.get(c);
+          if (!child) { continue; }
+          child.parent.delete(el.name);
+          // Propagate roles from parent to child
+          if (!child.el.state.roleRoot) {
+            for (const role of el.state.roleSet) {
+              child.el.state.roleSet.add(role);
+            }
           }
-          cDep.prod ||= el.prod; // Allow prod to trickle down as needed
+          // Allow prod to trickle down as needed
+          child.el.prod ||= (el.prod && el.state.prodDeps.has(c));
         }
       }
       // Remove from mapping
@@ -140,10 +129,47 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
       }
     }
 
-    // Color parent as final step
-    main.el.prod = true;
-    main.el.roleSet.add('std');
+    // Mark as standard at the end
+    for (const dep of [...mods].filter(x => x.state.roleRoot)) {
+      dep.state.roleSet = new Set(['std']);
+    }
+
+    return [...mods].sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+
+  /**
+   * Visit packages with ability to track duplicates
+   */
+  async visit(): Promise<Iterable<PackageModule>> {
+    const seen = new Set<PackageModule>();
+    const queue = [...await this.init()];
+
+    while (queue.length) {
+      const { value: node, parent, children, pkg } = queue.shift()!; // Visit initial set first
+      if (!node || (!node.workspace && !node.state.travetto)) {
+        continue;
+      }
+
+      // Track parentage
+      if (node.name !== this.ctx.main.name && parent) {
+        node.state.parentSet.add(parent.name);
+        parent.state.childSet.add(node.name);
+      }
+
+      if (seen.has(node)) {
+        continue;
+      } else {
+        seen.add(node);
+      }
+
+      const next = Object.entries(children)
+        .map(([n, v]) => PackageUtil.resolveVersionPath(pkg, v) ?? PackageUtil.resolvePackagePath(n))
+        .map(loc => this.#create(loc, { parent: node }));
+
+      queue.push(...next);
+    }
 
-    return deps;
+    return await this.#complete(seen);
   }
 }

package/src/file.ts

@@ -3,7 +3,6 @@ import fs from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 
 import { path } from './path';
-import type { ManifestContext } from './types';
 
 export class ManifestFileUtil {
   /**
@@ -16,7 +15,7 @@ export class ManifestFileUtil {
     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);
+    fs.unlink(temp); // Don't wait for completion
     return file;
   }
 
@@ -33,23 +32,4 @@ export class ManifestFileUtil {
   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.main.name);
-    }
-    return path.resolve(ctx.workspace.path, '.trv/tool', ...parts);
-  }
 }