@travetto/manifest 3.4.0 → 4.0.0-rc.1

package/src/dependencies.ts

@@ -1,153 +1,134 @@
 import { PackageUtil } from './package';
 import { path } from './path';
-import { ManifestContext, ManifestModuleRole, PackageVisitor, PackageVisitReq, Package } from './types';
-
-export type ModuleDep = {
-  pkg: Package;
-  version: string;
-  name: string;
-  main?: boolean;
-  mainSource?: boolean;
-  local?: boolean;
-  internal?: boolean;
-  sourcePath: string;
-  childSet: Set<string>;
-  parentSet: Set<string>;
-  roleSet: Set<ManifestModuleRole>;
-  prod: boolean;
-  topLevel?: boolean;
-};
+
+import type { Package, PackageDepType, PackageVisitReq, PackageVisitor } 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 };
 
 /**
  * Used for walking dependencies for collecting modules for the manifest
  */
-export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
-
-  /**
-   * Get main patterns for detecting if a module should be treated as main
-   */
-  static getMainPatterns(mainModule: string, mergeModules: string[]): RegExp[] {
-    const groups: Record<string, string[]> = { [mainModule]: [] };
-    for (const el of mergeModules) {
-      if (el.includes('/')) {
-        const [grp, sub] = el.split('/');
-        (groups[`${grp}/`] ??= []).push(sub);
-      } else {
-        (groups[el] ??= []);
-      }
-    }
-
-    return Object.entries(groups)
-      .map(([root, subs]) => subs.length ? `${root}(${subs.join('|')})` : root)
-      .map(x => new RegExp(`^${x.replace(/[*]/g, '.*?')}$`));
-  }
+export class PackageModuleVisitor implements PackageVisitor<PackageModule> {
 
   constructor(public ctx: ManifestContext) {
-    this.#mainSourcePath = path.resolve(this.ctx.workspacePath, this.ctx.mainFolder);
+    this.#mainSourcePath = path.resolve(this.ctx.workspace.path, this.ctx.main.folder);
   }
 
-  #mainPatterns: RegExp[] = [];
   #mainSourcePath: string;
+  #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.workspacePath);
-    const workspaceModules = pkg.workspaces?.length ? (await PackageUtil.resolveWorkspaces(this.ctx, req.sourcePath)) : [];
-
-    this.#mainPatterns = ModuleDependencyVisitor.getMainPatterns(pkg.name, [
-      ...pkg.travetto?.mainSource ?? [],
-      // Add workspace folders, for tests and docs
-      ...workspaceModules.map(x => x.name)
-    ]);
-
-    const globals = (workspacePkg.travetto?.globalModules ?? [])
-      .map(name => PackageUtil.packageReq<ModuleDep>(PackageUtil.resolvePackagePath(name), name in (workspacePkg.dependencies ?? {}), true));
+  async init(): Promise<Iterable<PackageVisitReq<PackageModule>>> {
+    const mainPkg = PackageUtil.readPackage(this.#mainSourcePath);
+    const mainReq = this.create(mainPkg, { 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])
+    );
 
-    const workspaceModuleDeps = workspaceModules
-      .map(entry => PackageUtil.packageReq<ModuleDep>(path.resolve(req.sourcePath, entry.sourcePath), false, true));
+    // Treat all workspace modules as main modules
+    if (this.ctx.workspace.mono && !this.ctx.main.folder) {
+      for (const [, loc] of this.#workspaceModules) {
+        const depPkg = PackageUtil.readPackage(loc);
+        globals.push(this.create(depPkg, { main: true, workspace: true, roleRoot: true }));
+      }
+    } 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 ?? {})) {
+        const depPkg = PackageUtil.readPackage(PackageUtil.resolvePackagePath(name));
+        globals.push(this.create(depPkg, { main: type === 'main', workspace: true }));
+      }
+    }
 
-    return [...globals, ...workspaceModuleDeps];
+    return globals.map((x, i) => i === 0 ? x : { ...x, 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'))
-    );
+  valid({ value: node }: PackageVisitReq<PackageModule>): boolean {
+    return node.workspace || !!node.state.travetto; // Workspace or travetto module
   }
 
   /**
-   * 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.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, pkg: req.pkg,
-      parentSet: new Set([]), childSet: new Set([]), roleSet: new Set([]), prod: req.prod, topLevel: req.topLevel
+  create(pkg: Package, { main, workspace, prod = false, roleRoot = false }: CreateOpts = {}): PackageVisitReq<PackageModule> {
+    const sourcePath = PackageUtil.getPackagePath(pkg);
+    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;
+    const deps: PackageDepType[] = ['dependencies', ...(value.main ? ['devDependencies'] as const : [])];
+    const children = Object.fromEntries(deps.flatMap(x => Object.entries(pkg[x] ?? {})));
+    return { pkg, value, children };
   }
 
   /**
    * Visit dependency
    */
-  visit(req: PackageVisitReq<ModuleDep>, dep: ModuleDep): void {
-    const { parent } = req;
-    if (parent && dep.name !== this.ctx.mainModule) {
-      dep.parentSet.add(parent.name);
-      parent.childSet.add(dep.name);
+  visit({ value: mod, parent }: PackageVisitReq<PackageModule>): void {
+    if (mod.name === this.ctx.main.name) { return; } // Skip root
+    if (parent) {
+      mod.state.parentSet.add(parent.name);
+      parent.state.childSet.add(mod.name);
     }
   }
 
   /**
    * 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.mainModule)!;
-
-    // Visit all direct dependencies and mark
-    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;
+  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
@@ -156,10 +137,11 @@ 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 deps;
+    return [...mods].sort((a, b) => a.name.localeCompare(b.name));
   }
 }

package/src/file.ts

@@ -1,9 +1,8 @@
-import os from 'os';
-import fs from 'fs/promises';
-import { readFileSync } from 'fs';
+import os from 'node:os';
+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.mainModule);
-    }
-    return path.resolve(ctx.workspacePath, ctx.toolFolder, ...parts);
-  }
 }

package/src/manifest-index.ts

@@ -1,36 +1,11 @@
+import { existsSync } from 'node:fs';
+
 import { ManifestModuleUtil } from './module';
 import { path } from './path';
-
-import {
-  ManifestModule, ManifestModuleCore, ManifestModuleFile,
-  ManifestModuleFileType, ManifestModuleFolderType, ManifestModuleRole, ManifestRoot
-} from './types';
-
 import { ManifestUtil } from './util';
 
-export type FindConfig = {
-  folder?: (folder: ManifestModuleFolderType) => boolean;
-  module?: (module: IndexedModule) => boolean;
-  file?: (file: IndexedFile) => boolean;
-  sourceOnly?: boolean;
-};
-
-export type IndexedFile = {
-  id: string;
-  import: string;
-  module: string;
-  sourceFile: string;
-  outputFile: string;
-  relativeFile: string;
-  role: ManifestModuleRole;
-  type: ManifestModuleFileType;
-};
-
-export type IndexedModule = ManifestModuleCore & {
-  sourcePath: string;
-  outputPath: string;
-  files: Record<ManifestModuleFolderType, IndexedFile[]>;
-};
+import type { ManifestModuleFolderType } from './types/common';
+import type { ManifestModule, ManifestRoot, ManifestModuleFile, IndexedModule, IndexedFile, FindConfig } from './types/manifest';
 
 const TypedObject: {
   keys<T = unknown, K extends keyof T = keyof T>(o: T): K[];
@@ -43,7 +18,7 @@ const TypedObject: {
  */
 export class ManifestIndex {
 
-  #manifestFile: string;
+  #arbitraryLookup?: (parts: string[]) => ManifestModule | undefined;
   #manifest: ManifestRoot;
   #modules: IndexedModule[];
   #modulesByName: Record<string, IndexedModule> = {};
@@ -69,22 +44,16 @@ export class ManifestIndex {
     return this.#outputRoot;
   }
 
-  get manifestFile(): string {
-    return this.#manifestFile;
-  }
-
   init(manifestInput: string): void {
-    const { manifest, file } = ManifestUtil.readManifestSync(manifestInput);
-    this.#manifest = manifest;
-    this.#manifestFile = file;
-    this.#outputRoot = path.resolve(this.#manifest.workspacePath, this.#manifest.outputFolder);
+    this.#manifest = ManifestUtil.readManifestSync(manifestInput);
+    this.#outputRoot = path.resolve(this.#manifest.workspace.path, this.#manifest.build.outputFolder);
     this.#index();
   }
 
   #moduleFiles(m: ManifestModule, files: ManifestModuleFile[]): IndexedFile[] {
     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 sourceFile = path.resolve(this.#manifest.workspace.path, m.sourceFolder, f);
       const js = isSource ? ManifestModuleUtil.sourceToOutputExt(f) : f;
       const outputFile = this.#resolveOutput(m.outputFolder, js);
       const modImport = `${m.name}/${js}`;
@@ -104,12 +73,14 @@ export class ManifestIndex {
     this.#outputToEntry.clear();
     this.#importToEntry.clear();
     this.#sourceToEntry.clear();
+    this.#arbitraryLookup = undefined;
 
     this.#modules = Object.values(this.#manifest.modules)
       .map(m => ({
         ...m,
         outputPath: this.#resolveOutput(m.outputFolder),
-        sourcePath: path.resolve(this.#manifest.workspacePath, m.sourceFolder),
+        sourcePath: path.resolve(this.#manifest.workspace.path, m.sourceFolder),
+        children: new Set(),
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         files: Object.fromEntries(
           Object.entries(m.files).map(([folder, files]) => [folder, this.#moduleFiles(m, files ?? [])])
@@ -128,6 +99,13 @@ export class ManifestIndex {
     }
     this.#modulesByName = Object.fromEntries(this.#modules.map(x => [x.name, x]));
     this.#modulesByFolder = Object.fromEntries(this.#modules.map(x => [x.sourceFolder, x]));
+
+    // Store child information
+    for (const mod of this.#modules) {
+      for (const p of mod.parents) {
+        this.#modulesByName[p]?.children.add(mod.name);
+      }
+    }
   }
 
   /**
@@ -138,11 +116,11 @@ export class ManifestIndex {
   }
 
   /**
-   * Get all local modules
+   * Get all workspace modules
    * @returns
    */
-  getLocalModules(): IndexedModule[] {
-    return this.#modules.filter(x => x.local);
+  getWorkspaceModules(): IndexedModule[] {
+    return this.#modules.filter(x => x.workspace);
   }
 
   /**
@@ -237,12 +215,9 @@ export class ManifestIndex {
   /**
    * Build module list from an expression list (e.g. `@travetto/rest,-@travetto/log)
    */
-  getModuleList(mode: 'local' | 'all', exprList: string = ''): Set<string> {
+  getModuleList(mode: 'workspace' | 'all', exprList: string = ''): Set<string> {
     const allMods = Object.keys(this.#manifest.modules);
-    const active = new Set<string>(
-      mode === 'local' ? this.getLocalModules().map(x => x.name) :
-        (mode === 'all' ? allMods : [])
-    );
+    const active = new Set<string>(mode === 'workspace' ? this.getWorkspaceModules().map(x => x.name) : allMods);
 
     for (const expr of exprList.split(/\s*,\s*/g)) {
       const [, neg, mod] = expr.match(/(-|[+])?([^+\- ]+)$/) ?? [];
@@ -257,21 +232,38 @@ export class ManifestIndex {
   }
 
   /**
-   * Get all modules (transitively) that depend on this module
+   * Get all modules, parents or children, (transitively) of the provided root, in a DFS fashion
    */
-  getDependentModules(root: IndexedModule): Set<IndexedModule> {
+  getDependentModules(root: IndexedModule | string, field: 'parents' | 'children'): IndexedModule[] {
     const seen = new Set<string>();
-    const out = new Set<IndexedModule>();
-    const toProcess = [root.name];
+    const out: IndexedModule[] = [];
+    const toProcess = [typeof root === 'string' ? root : root.name];
     while (toProcess.length) {
       const next = toProcess.shift()!;
-      if (seen.has(next)) {
-        continue;
+      if (!seen.has(next)) {
+        seen.add(next);
+        const mod = this.getModule(next)!;
+        toProcess.push(...mod[field]);
+        if (next !== this.#manifest.main.name) { // Do not include self
+          out.push(mod);
+        }
       }
-      const mod = this.getModule(next)!;
-      toProcess.push(...mod.parents);
-      out.add(mod);
     }
     return out;
   }
+
+  /**
+   * Find the module for an arbitrary source file, if it falls under a given workspace module
+   */
+  findModuleForArbitraryFile(file: string): ManifestModule | undefined {
+    const base = this.#manifest.workspace.path;
+    const lookup = this.#arbitraryLookup ??= ManifestUtil.lookupTrie(
+      Object.values(this.#manifest.modules),
+      x => x.sourceFolder.split('/'),
+      sub =>
+        !existsSync(path.resolve(base, ...sub, 'package.json')) &&
+        !existsSync(path.resolve(base, ...sub, '.git'))
+    );
+    return lookup(file.replace(`${base}/`, '').split('/'));
+  }
 }

package/src/module.ts

@@ -1,14 +1,12 @@
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
 
 import { path } from './path';
-import {
-  ManifestContext,
-  ManifestModule, ManifestModuleFile, ManifestModuleFileType,
-  ManifestModuleFolderType,
-  ManifestModuleRole
-} from './types';
-import { ModuleDep, ModuleDependencyVisitor } from './dependencies';
 import { PackageUtil } from './package';
+import { PackageModuleVisitor } from './dependencies';
+
+import type { ManifestModuleFileType, ManifestModuleRole, ManifestModuleFolderType } from './types/common';
+import type { ManifestModuleFile, ManifestModule, PackageModule } from './types/manifest';
+import type { ManifestContext } from './types/context';
 
 const EXT_MAPPING: Record<string, ManifestModuleFileType> = {
   '.js': 'js',
@@ -26,6 +24,9 @@ const INDEX_FILES = new Set(
   )
 );
 
+const STD_TOP_FOLDERS = new Set(['src', 'bin', 'support']);
+const STD_TOP_FILES = new Set([...INDEX_FILES, 'package.json']);
+
 export class ManifestModuleUtil {
 
   static #scanCache: Record<string, string[]> = {};
@@ -44,17 +45,16 @@ export class ManifestModuleUtil {
   /**
    * Simple file scanning
    */
-  static async scanFolder(folder: string, mainSource = false): Promise<string[]> {
-    if (!mainSource && folder in this.#scanCache) {
-      return this.#scanCache[folder];
+  static async scanFolder(folder: string, full = false): Promise<string[]> {
+    const key = `${folder}|${full}`;
+    if (key in this.#scanCache) {
+      return this.#scanCache[key];
     }
 
     if (!await fs.stat(folder).catch(() => false)) {
       return [];
     }
 
-    const topFolders = new Set(mainSource ? [] : ['src', 'bin', 'support']);
-    const topFiles = new Set(mainSource ? [] : [...INDEX_FILES, 'package.json']);
     const out: string[] = [];
 
     const stack: [string, number][] = [[folder, 0]];
@@ -72,24 +72,21 @@ export class ManifestModuleUtil {
       }
 
       for (const sub of await fs.readdir(top)) {
+        const valid = !sub.startsWith('.') && (depth > 0 || full);
         const stat = await fs.stat(`${top}/${sub}`);
         if (stat.isFile()) {
-          if (!sub.startsWith('.') && (depth > 0 || !topFiles.size || topFiles.has(sub))) {
+          if (valid || STD_TOP_FILES.has(sub)) {
             out.push(`${top}/${sub}`);
           }
         } else {
-          if (!sub.includes('node_modules') && !sub.startsWith('.') && (depth > 0 || !topFolders.size || topFolders.has(sub))) {
+          if (!sub.includes('node_modules') && (valid || STD_TOP_FOLDERS.has(sub))) {
             stack.push([`${top}/${sub}`, depth + 1]);
           }
         }
       }
     }
 
-    if (!mainSource) {
-      this.#scanCache[folder] = out;
-    }
-
-    return out;
+    return this.#scanCache[key] = out;
   }
 
   /**
@@ -175,12 +172,13 @@ export class ManifestModuleUtil {
   /**
    * Visit a module and describe files, and metadata
    */
-  static async describeModule(ctx: ManifestContext, dep: ModuleDep): Promise<ManifestModule> {
-    const { main, mainSource, local, name, version, sourcePath, roleSet, prod, parentSet, internal } = dep;
+  static async describeModule(ctx: ManifestContext, mod: PackageModule): Promise<ManifestModule> {
+    const { state, ...rest } = mod;
+    const sourcePath = path.resolve(ctx.workspace.path, rest.sourceFolder);
 
     const files: ManifestModule['files'] = {};
 
-    for (const file of await this.scanFolder(sourcePath, mainSource)) {
+    for (const file of await this.scanFolder(sourcePath, rest.main)) {
       // Group by top folder
       const moduleFile = file.replace(`${sourcePath}/`, '');
       const entry = await this.transformFile(moduleFile, file);
@@ -188,29 +186,20 @@ export class ManifestModuleUtil {
       (files[key] ??= []).push(entry);
     }
 
-    // Refine non-main source
-    if (!mainSource) {
-      files.$root = files.$root?.filter(([file, type]) => type !== 'ts');
-    }
-
-    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, roles, parents, prod, files };
-    return res;
+    return {
+      ...rest,
+      roles: [...state.roleSet].sort(),
+      parents: [...state.parentSet].sort(),
+      files
+    };
   }
 
   /**
    * Produce all modules for a given manifest folder, adding in some given modules when developing framework
    */
   static async produceModules(ctx: ManifestContext): Promise<Record<string, ManifestModule>> {
-    const visitor = new ModuleDependencyVisitor(ctx);
-    const mainPath = path.resolve(ctx.workspacePath, ctx.mainFolder);
-    const declared = await PackageUtil.visitPackages(mainPath, visitor);
-    const sorted = [...declared].sort((a, b) => a.name.localeCompare(b.name));
-    const modules = await Promise.all(sorted.map(x => this.describeModule(ctx, x)));
+    const pkgs = await PackageUtil.visitPackages(new PackageModuleVisitor(ctx));
+    const modules = await Promise.all([...pkgs].map(x => this.describeModule(ctx, x)));
     return Object.fromEntries(modules.map(m => [m.name, m]));
   }