@travetto/manifest 3.4.0-rc.3 → 4.0.0-rc.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 ArcSine Technologies
+Copyright (c) 2023 ArcSine Technologies
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -35,7 +35,7 @@ During the compilation process, it is helpful to know how the output content dif
 ## 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 [RootIndex](https://github.com/travetto/travetto/tree/main/module/manifest/src/root-index.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#L11) using the `getFunctionMetadata` method.
 
 **Code: Test Class**
 ```typescript
@@ -50,10 +50,10 @@ export class TestClass {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestClass = void 0;
 const tslib_1 = require("tslib");
-const Ⲑ_root_index_1 = tslib_1.__importStar(require("@travetto/manifest/src/root-index.js"));
+const Ⲑ_runtime_1 = tslib_1.__importStar(require("@travetto/manifest/src/runtime.js"));
 var ᚕf = "@travetto/manifest/doc/test-class.js";
 class TestClass {
-    static Ⲑinit = Ⲑ_root_index_1.RootIndex.registerFunction(TestClass, ᚕf, 197152026, { doStuff: { hash: 51337554 } }, false, false);
+    static Ⲑinit = Ⲑ_runtime_1.RuntimeIndex.registerFunction(TestClass, ᚕf, 197152026, { doStuff: { hash: 51337554 } }, false, false);
     async doStuff() { }
 }
 exports.TestClass = TestClass;
@@ -92,19 +92,25 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
 ```typescript
 {
   "generated": 1868155200000,
-  "workspacePath": "<generated>",
-  "monoRepo": true,
-  "packageManager": "npm",
-  "moduleType": "commonjs",
-  "outputFolder": ".trv/output",
-  "toolFolder": ".trv/tool",
-  "compilerFolder": ".trv/compiler",
-  "compilerUrl": "http://127.0.0.1:26803",
-  "frameworkVersion": "x.x.x",
-  "mainModule": "@travetto/manifest",
-  "mainFolder": "module/manifest",
-  "version": "x.x.x",
-  "description": "Support for project indexing, manifesting, along with file watching",
+  "workspace": {
+    "name": "@travetto/mono-repo",
+    "path": "<generated>",
+    "mono": true,
+    "manager": "npm",
+    "type": "commonjs"
+  },
+  "build": {
+    "compilerFolder": ".trv/compiler",
+    "compilerUrl": "http://127.0.0.1:26803",
+    "compilerModuleFolder": "module/compiler",
+    "outputFolder": ".trv/output"
+  },
+  "main": {
+    "name": "@travetto/manifest",
+    "folder": "module/manifest",
+    "version": "x.x.x",
+    "description": "Support for project indexing, manifesting, along with file watching"
+  },
   "modules": {
     "@travetto/manifest": {
       "main": true,
@@ -136,7 +142,7 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
         ],
         "test": [
           [ "test/path.ts", "ts", 1868155200000, "test" ],
-          [ "test/root-index.ts", "ts", 1868155200000, "test" ]
+          [ "test/runtime.ts", "ts", 1868155200000, "test" ]
         ],
         "test/fixtures": [
           [ "test/fixtures/simple.ts", "fixture", 1868155200000, "test" ]
@@ -148,13 +154,13 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
           [ "src/delta.ts", "ts", 1868155200000 ],
           [ "src/dependencies.ts", "ts", 1868155200000 ],
           [ "src/file.ts", "ts", 1868155200000 ],
+          [ "src/global.d.ts", "typings", 1868155200000 ],
           [ "src/manifest-index.ts", "ts", 1868155200000 ],
           [ "src/module.ts", "ts", 1868155200000 ],
           [ "src/package.ts", "ts", 1868155200000 ],
           [ "src/path.ts", "ts", 1868155200000 ],
-          [ "src/root-index.ts", "ts", 1868155200000 ],
+          [ "src/runtime.ts", "ts", 1868155200000 ],
           [ "src/types.ts", "ts", 1868155200000 ],
-          [ "src/typings.d.ts", "typings", 1868155200000 ],
           [ "src/util.ts", "ts", 1868155200000 ]
         ],
         "bin": [

package/__index__.ts

@@ -1,10 +1,10 @@
-/// <reference path="./src/typings.d.ts" />
+/// <reference path="./src/global.d.ts" />
 
 export * from './src/path';
 export * from './src/module';
 export * from './src/delta';
 export * from './src/manifest-index';
-export * from './src/root-index';
+export * from './src/runtime';
 export * from './src/package';
 export * from './src/util';
 export * from './src/file';

package/bin/context.js

@@ -5,9 +5,9 @@
  * @typedef {Pkg & { mono: boolean, manager: 'yarn'|'npm', resolve: (file:string) => string}} Workspace
  * @typedef {import('../src/types').ManifestContext} ManifestContext
  */
-import fs from 'fs/promises';
-import path from 'path';
-import { createRequire } from 'module';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
 
 /** @type {Record<string, Workspace>} */ const WS_ROOT = {};
 const TOOL_FOLDER = '.trv/tool';
@@ -59,7 +59,7 @@ async function $resolveWorkspace(base = process.cwd()) {
     [prev, prevPkg] = [folder, pkg];
     pkg = await $readPackage(folder) ?? pkg;
     if (
-      (pkg && (!!pkg.workspaces || !!pkg.travetto?.isolated)) || // if we have a monorepo root, or we are isolated
+      (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
     ) {
       break;
@@ -73,9 +73,11 @@ async function $resolveWorkspace(base = process.cwd()) {
 
   return WS_ROOT[base] = {
     ...pkg,
+    name: pkg.name ?? 'untitled',
+    type: pkg.type,
     manager: await fs.stat(path.resolve(pkg.path, 'yarn.lock')).catch(() => { }) ? 'yarn' : 'npm',
     resolve: createRequire(`${pkg.path}/node_modules`).resolve.bind(null),
-    mono: !!pkg.workspaces || (!pkg.travetto?.isolated && !!prevPkg)  // Workspaces or nested projects
+    mono: !!pkg.workspaces || (!pkg.travetto?.build?.isolated && !!prevPkg)  // Workspaces or nested projects
   };
 }
 
@@ -84,18 +86,15 @@ async function $resolveWorkspace(base = process.cwd()) {
  * @param {Workspace} ws
  */
 async function $getCompilerUrl(ws) {
-  let out = ws.travetto?.compilerUrl;
-  if (!out) {
-    const file = path.resolve(ws.path, ws.travetto?.toolFolder ?? TOOL_FOLDER, 'compiler.url');
-    // eslint-disable-next-line no-bitwise
-    const port = (Math.abs([...file].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
-    out = `http://localhost:${port}`;
-    try { await fs.stat(file); } catch {
-      await fs.mkdir(path.dirname(file), { recursive: true });
-      await fs.writeFile(file, out, 'utf8');
-    }
+  const file = path.resolve(ws.path, TOOL_FOLDER, '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');
   }
-  return out.replace('localhost', '127.0.0.1');
+  return out;
 }
 
 /**
@@ -107,7 +106,7 @@ async function $resolveModule(workspace, folder) {
   let mod;
   if (!folder && process.env.TRV_MODULE) {
     mod = process.env.TRV_MODULE;
-    if (/[.](t|j)s$/.test(mod)) { // Rewrite from file to 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, () => '');
     }
@@ -136,26 +135,28 @@ async function $resolveModule(workspace, folder) {
  */
 export async function getManifestContext(folder) {
   const workspace = await $resolveWorkspace(folder);
-
-  const [mod, framework, compilerUrl] = await Promise.all([
-    $resolveModule(workspace, folder),
-    $readPackage(workspace.resolve('@travetto/manifest/package.json')),
-    $getCompilerUrl(workspace),
-  ]);
+  const mod = await $resolveModule(workspace, folder);
+  const build = workspace.travetto?.build ?? {};
 
   return {
-    workspacePath: workspace.path,
-    monoRepo: workspace.mono,
-    packageManager: workspace.manager,
-    moduleType: workspace.type ?? 'commonjs',
-    outputFolder: workspace.travetto?.outputFolder ?? OUTPUT_FOLDER,
-    toolFolder: workspace.travetto?.toolFolder ?? TOOL_FOLDER,
-    compilerFolder: workspace.travetto?.compilerFolder ?? COMPILER_FOLDER,
-    compilerUrl,
-    frameworkVersion: framework?.version ?? '1.0.0',
-    mainModule: mod.name ?? 'untitled',
-    mainFolder: mod.path === workspace.path ? '' : mod.path.replace(`${workspace.path}/`, ''),
-    version: mod.version,
-    description: mod.description
+    workspace: {
+      name: workspace.name,
+      path: workspace.path,
+      mono: workspace.mono,
+      manager: workspace.manager,
+      type: workspace.type ?? 'commonjs'
+    },
+    build: {
+      compilerFolder: build.compilerFolder ?? COMPILER_FOLDER,
+      compilerUrl: build.compilerUrl ?? await $getCompilerUrl(workspace),
+      compilerModuleFolder: path.dirname(workspace.resolve('@travetto/compiler/package.json')).replace(`${workspace.path}/`, ''),
+      outputFolder: build.outputFolder ?? OUTPUT_FOLDER,
+    },
+    main: {
+      name: mod.name ?? 'untitled',
+      folder: mod.path === workspace.path ? '' : mod.path.replace(`${workspace.path}/`, ''),
+      version: mod.version,
+      description: mod.description
+    }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "3.4.0-rc.3",
+  "version": "4.0.0-rc.0",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
     "path",
@@ -32,7 +32,9 @@
   },
   "travetto": {
     "displayName": "Manifest",
-    "docBaseUrl": "https://github.com/travetto/travetto/tree/main"
+    "doc": {
+      "baseUrl": "https://github.com/travetto/travetto/tree/main"
+    }
   },
   "publishConfig": {
     "access": "public"

package/src/delta.ts

@@ -9,7 +9,7 @@ import { path } from './path';
 
 type DeltaEventType = 'added' | 'changed' | 'removed' | 'missing' | 'dirty';
 type DeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFile> };
-export type DeltaEvent = { file: string, type: DeltaEventType, module: string };
+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']);
@@ -30,9 +30,9 @@ export class ManifestDeltaUtil {
     const out: DeltaEvent[] = [];
 
     const add = (file: string, type: DeltaEvent['type']): unknown =>
-      out.push({ file, module: left.name, type });
+      out.push({ file, module: left.name, type, sourceFile: path.resolve(ctx.workspace.path, left.sourceFolder, file) });
 
-    const root = `${ctx.workspacePath}/${ctx.outputFolder}/${left.outputFolder}`;
+    const root = path.resolve(ctx.workspace.path, ctx.build.outputFolder, left.outputFolder);
     const right = new Set(
       (await ManifestModuleUtil.scanFolder(root, left.main))
         .filter(x => {
@@ -88,14 +88,14 @@ export class ManifestDeltaUtil {
   /**
    * Produce delta between manifest root and the output folder
    */
-  static async produceDelta(ctx: ManifestContext, manifest: ManifestRoot): Promise<DeltaEvent[]> {
+  static async produceDelta(manifest: ManifestRoot): Promise<DeltaEvent[]> {
     const deltaLeft = Object.fromEntries(
       Object.values(manifest.modules)
         .map(m => [m.name, { ...m, files: this.#flattenModuleFiles(m) }])
     );
 
     const out: DeltaEvent[] = [];
-    const outputFolder = path.resolve(ctx.workspacePath, ctx.outputFolder);
+    const outputFolder = path.resolve(manifest.workspace.path, manifest.build.outputFolder);
 
     for (const lMod of Object.values(deltaLeft)) {
       out.push(...await this.#deltaModules(manifest, outputFolder, lMod));

package/src/dependencies.ts

@@ -1,20 +1,14 @@
 import { PackageUtil } from './package';
 import { path } from './path';
-import { ManifestContext, ManifestModuleRole, PackageVisitor, PackageVisitReq, Package } from './types';
+import { ManifestContext, ManifestModuleRole, PackageVisitor, PackageVisitReq, Package, ManifestDepCore } from './types';
 
-export type ModuleDep = {
+export type ModuleDep = ManifestDepCore & {
   pkg: Package;
-  version: string;
-  name: string;
-  main?: boolean;
-  mainSource?: boolean;
-  local?: boolean;
-  internal?: boolean;
+  mainLike?: boolean;
   sourcePath: string;
   childSet: Set<string>;
   parentSet: Set<string>;
   roleSet: Set<ManifestModuleRole>;
-  prod: boolean;
   topLevel?: boolean;
 };
 
@@ -23,47 +17,36 @@ export type ModuleDep = {
  */
 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, '.*?')}$`));
-  }
-
   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[] = [];
+  #mainLikeModules = new Set<string>();
   #mainSourcePath: string;
 
+  /**
+   * Main source path for searching
+   */
+  get rootPath(): string {
+    return this.#mainSourcePath;
+  }
+
   /**
    * 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 workspacePkg = PackageUtil.readPackage(this.ctx.workspace.path);
     const workspaceModules = pkg.workspaces?.length ? (await PackageUtil.resolveWorkspaces(this.ctx, req.sourcePath)) : [];
 
-    this.#mainPatterns = ModuleDependencyVisitor.getMainPatterns(pkg.name, [
-      ...pkg.travetto?.mainSource ?? [],
+    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 = (workspacePkg.travetto?.globalModules ?? [])
+    const globals = Object.keys(workspacePkg.travetto?.build?.withModules ?? [])
       .map(name => PackageUtil.packageReq<ModuleDep>(PackageUtil.resolvePackagePath(name), name in (workspacePkg.dependencies ?? {}), true));
 
     const workspaceModuleDeps = workspaceModules
@@ -87,13 +70,13 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
   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 main = name === this.ctx.main.name;
+    const mainLike = main || this.#mainLikeModules.has(name);
     const internal = pkg.private === true;
-    const local = internal || mainSource || !sourcePath.includes('node_modules');
+    const local = internal || mainLike || !sourcePath.includes('node_modules');
 
-    const dep = {
-      name, version, sourcePath, main, mainSource, local, internal, pkg: req.pkg,
+    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
     };
 
@@ -105,7 +88,7 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
    */
   visit(req: PackageVisitReq<ModuleDep>, dep: ModuleDep): void {
     const { parent } = req;
-    if (parent && dep.name !== this.ctx.mainModule) {
+    if (parent && dep.name !== this.ctx.main.name) {
       dep.parentSet.add(parent.name);
       parent.childSet.add(dep.name);
     }
@@ -120,17 +103,18 @@ export class ModuleDependencyVisitor implements PackageVisitor<ModuleDep> {
       mapping.set(el.name, { parent: new Set(el.parentSet), child: new Set(el.childSet), el });
     }
 
-    const main = mapping.get(this.ctx.mainModule)!;
+    const main = mapping.get(this.ctx.main.name)!;
 
     // Visit all direct dependencies and mark
     for (const { el } of mapping.values()) {
-      if (el.topLevel) {
+      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');
         }
-      } else if (!main.child.has(el.name)) { // Not a direct descendent
-        el.prod = false;
       }
     }
 

package/src/file.ts

@@ -1,6 +1,6 @@
-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';
@@ -48,8 +48,8 @@ export class ManifestFileUtil {
     ctx = 'manifest' in ctx ? ctx.manifest : ctx;
     const parts = [rel];
     if (moduleSpecific) {
-      parts.unshift('node_modules', ctx.mainModule);
+      parts.unshift('node_modules', ctx.main.name);
     }
-    return path.resolve(ctx.workspacePath, ctx.toolFolder, ...parts);
+    return path.resolve(ctx.workspace.path, '.trv/tool', ...parts);
   }
 }

package/src/manifest-index.ts

@@ -77,14 +77,14 @@ export class ManifestIndex {
     const { manifest, file } = ManifestUtil.readManifestSync(manifestInput);
     this.#manifest = manifest;
     this.#manifestFile = file;
-    this.#outputRoot = path.resolve(this.#manifest.workspacePath, this.#manifest.outputFolder);
+    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}`;
@@ -109,7 +109,7 @@ export class ManifestIndex {
       .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),
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         files: Object.fromEntries(
           Object.entries(m.files).map(([folder, files]) => [folder, this.#moduleFiles(m, files ?? [])])

package/src/module.ts

@@ -1,4 +1,4 @@
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
 
 import { path } from './path';
 import {
@@ -26,6 +26,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,8 +47,8 @@ export class ManifestModuleUtil {
   /**
    * Simple file scanning
    */
-  static async scanFolder(folder: string, mainSource = false): Promise<string[]> {
-    if (!mainSource && folder in this.#scanCache) {
+  static async scanFolder(folder: string, mainLike = false): Promise<string[]> {
+    if (!mainLike && folder in this.#scanCache) {
       return this.#scanCache[folder];
     }
 
@@ -53,8 +56,6 @@ export class ManifestModuleUtil {
       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,20 +73,21 @@ export class ManifestModuleUtil {
       }
 
       for (const sub of await fs.readdir(top)) {
+        const valid = !sub.startsWith('.') && (depth > 0 || mainLike);
         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) {
+    if (!mainLike) {
       this.#scanCache[folder] = out;
     }
 
@@ -176,11 +178,11 @@ 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;
+    const { main, mainLike, local, name, version, sourcePath, roleSet, prod, parentSet, internal } = dep;
 
     const files: ManifestModule['files'] = {};
 
-    for (const file of await this.scanFolder(sourcePath, mainSource)) {
+    for (const file of await this.scanFolder(sourcePath, mainLike)) {
       // Group by top folder
       const moduleFile = file.replace(`${sourcePath}/`, '');
       const entry = await this.transformFile(moduleFile, file);
@@ -188,17 +190,19 @@ export class ManifestModuleUtil {
       (files[key] ??= []).push(entry);
     }
 
-    // Refine non-main source
-    if (!mainSource) {
+    // Refine non-main source, remove anything in root that is source (doesn't include $index)
+    if (!mainLike) {
       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 sourceFolder = sourcePath === ctx.workspace.path ? '' : sourcePath.replace(`${ctx.workspace.path}/`, '');
 
-    const res = { main, name, version, local, internal, sourceFolder, outputFolder, roles, parents, prod, files };
+    const res: ManifestModule = {
+      main, name, version, local, internal, sourceFolder, outputFolder, roles, parents, prod, files
+    };
     return res;
   }
 
@@ -207,8 +211,7 @@ export class ManifestModuleUtil {
    */
   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 declared = await PackageUtil.visitPackages(visitor);
     const sorted = [...declared].sort((a, b) => a.name.localeCompare(b.name));
     const modules = await Promise.all(sorted.map(x => this.describeModule(ctx, x)));
     return Object.fromEntries(modules.map(m => [m.name, m]));

package/src/package.ts

@@ -1,7 +1,7 @@
-import { createRequire } from 'module';
-import { execSync } from 'child_process';
+import { createRequire } from 'node:module';
+import { execSync } from 'node:child_process';
 
-import { ManifestContext, Package, PackageVisitor, PackageVisitReq, PackageWorkspaceEntry } from './types';
+import type { ManifestContext, NodePackageManager, Package, PackageVisitor, PackageVisitReq, PackageWorkspaceEntry } from './types';
 import { path } from './path';
 import { ManifestFileUtil } from './file';
 
@@ -10,7 +10,7 @@ import { ManifestFileUtil } from './file';
  */
 export class PackageUtil {
 
-  static #req = createRequire(path.resolve('node_modules'));
+  static #resolvers: Record<string, (imp: string) => string> = {};
   static #cache: Record<string, Package> = {};
   static #workspaces: Record<string, PackageWorkspaceEntry[]> = {};
 
@@ -21,15 +21,13 @@ export class PackageUtil {
   }
 
   /**
-   * Clear out cached package file reads
+   * Resolve import given a manifest context
    */
-  static clearCache(): void {
-    this.#cache = {};
-    this.#workspaces = {};
+  static resolveImport(imp: string, root?: string): string {
+    const loc = path.resolve(root ?? '.', 'node_modules');
+    return (this.#resolvers[loc] ??= createRequire(loc).resolve.bind(null))(imp);
   }
 
-  static resolveImport = (library: string): string => this.#req.resolve(library);
-
   /**
    * Resolve version path, if file: url
    */
@@ -44,12 +42,12 @@ export class PackageUtil {
   /**
    * Find package.json folder for a given dependency
    */
-  static resolvePackagePath(name: string): string {
+  static resolvePackagePath(name: string, root?: string): string {
     try {
-      return path.dirname(this.resolveImport(`${name}/package.json`));
+      return path.dirname(this.resolveImport(`${name}/package.json`, root));
     } catch {
       try {
-        const resolved = this.resolveImport(name);
+        const resolved = this.resolveImport(name, root);
         return path.join(resolved.split(name)[0], name);
       } catch { }
     }
@@ -107,14 +105,9 @@ export class PackageUtil {
   /**
    * Visit packages with ability to track duplicates
    */
-  static async visitPackages<T>(
-    rootOrPath: PackageVisitReq<T> | string,
-    visitor: PackageVisitor<T>
-  ): Promise<Set<T>> {
+  static async visitPackages<T>(visitor: PackageVisitor<T>): Promise<Set<T>> {
 
-    const root = typeof rootOrPath === 'string' ?
-      this.packageReq<T>(rootOrPath, false, true) :
-      rootOrPath;
+    const root = this.packageReq<T>(visitor.rootPath, false, true);
 
     const seen = new Map<string, T>();
     const queue: PackageVisitReq<T>[] = [...await visitor.init?.(root) ?? [], root];
@@ -155,12 +148,12 @@ export class PackageUtil {
    */
   static async resolveWorkspaces(ctx: ManifestContext, rootPath: string): Promise<PackageWorkspaceEntry[]> {
     if (!this.#workspaces[rootPath]) {
-      const cache = path.resolve(ctx.workspacePath, ctx.outputFolder, 'workspaces.json');
+      const cache = path.resolve(ctx.workspace.path, ctx.build.outputFolder, 'workspaces.json');
       try {
         return await ManifestFileUtil.readAsJson(cache);
       } catch (err) {
         let out: PackageWorkspaceEntry[];
-        switch (ctx.packageManager) {
+        switch (ctx.workspace.manager) {
           case 'npm': {
             const res = await this.#exec<{ location: string, name: string }[]>(rootPath, 'npm query .workspace');
             out = res.map(d => ({ sourcePath: d.location, name: d.name }));
@@ -180,4 +173,16 @@ export class PackageUtil {
     }
     return this.#workspaces[rootPath];
   }
+
+  /**
+   * Get an install command for a given npm module
+   */
+  static getInstallCommand(ctx: { workspace: { manager: NodePackageManager } }, pkg: string, prod = false): string {
+    let install: string;
+    switch (ctx.workspace.manager) {
+      case 'npm': install = `npm i ${prod ? '' : '--save-dev '}${pkg}`; break;
+      case 'yarn': install = `yarn add ${prod ? '' : '--dev '}${pkg}`; break;
+    }
+    return install;
+  }
 }

package/src/path.ts

@@ -1,6 +1,6 @@
-import type * as pathMod from 'path';
-import { extname, dirname, basename, resolve, join } from 'path/posix';
-import { sep, resolve as nativeResolve, join as nativeJoin } from 'path';
+import type * as pathMod from 'node:path';
+import { extname, dirname, basename, resolve, join } from 'node:path/posix';
+import { sep, resolve as nativeResolve, join as nativeJoin } from 'node:path';
 
 /**
  * Converts a given file name by replace all slashes, with forward slashes

package/src/{root-index.ts → runtime.ts}

@@ -1,6 +1,6 @@
 import { path } from './path';
 import { IndexedModule, ManifestIndex } from './manifest-index';
-import { FunctionMetadata, ManifestContext } from './types';
+import { FunctionMetadata, ManifestContext, ManifestModule } from './types';
 
 const METADATA = Symbol.for('@travetto/manifest:metadata');
 type Metadated = { [METADATA]: FunctionMetadata };
@@ -8,7 +8,7 @@ type Metadated = { [METADATA]: FunctionMetadata };
 /**
  * Extended manifest index geared for application execution
  */
-class $RootIndex extends ManifestIndex {
+class $RuntimeIndex extends ManifestIndex {
 
   #metadata = new Map<string, FunctionMetadata>();
 
@@ -20,13 +20,6 @@ class $RootIndex extends ManifestIndex {
     this.init(`${this.outputRoot}/node_modules/${module}`);
   }
 
-  /**
-   * Determines if the manifest root is the root for a monorepo
-   */
-  isMonoRepoRoot(): boolean {
-    return !!this.manifest.monoRepo && !this.manifest.mainFolder;
-  }
-
   /**
    * Get internal id from file name and optionally, class name
    */
@@ -36,29 +29,11 @@ class $RootIndex extends ManifestIndex {
     return clsName ? `${id}￮${clsName}` : id;
   }
 
-  /**
-   * Get main module name
-   */
-  get mainModuleName(): string {
-    return this.manifest.mainModule;
-  }
-
   /**
    * Get main module for manifest
    */
   get mainModule(): IndexedModule {
-    return this.getModule(this.mainModuleName)!;
-  }
-
-  /**
-   * Digest manifest
-   */
-  manifestDigest(): Pick<ManifestContext, 'mainModule' | 'frameworkVersion' | 'version'> {
-    return {
-      mainModule: this.manifest.mainModule,
-      frameworkVersion: this.manifest.frameworkVersion,
-      version: this.manifest.version,
-    };
+    return this.getModule(this.manifest.main.name)!;
   }
 
   /**
@@ -102,16 +77,50 @@ class $RootIndex extends ManifestIndex {
     const id = clsId === undefined ? '' : typeof clsId === 'string' ? clsId : clsId.Ⲑid;
     return this.#metadata.get(id);
   }
-}
 
-let index: $RootIndex | undefined;
+  /**
+   * Resolve module path to folder, with support for main module and monorepo support
+   */
+  resolveModulePath(modulePath: string): string {
+    const main = this.manifest.main.name;
+    const workspace = this.manifest.workspace.path;
+    const [base, sub] = modulePath
+      .replace(/^(@@?)(#|$)/g, (_, v, r) => `${v === '@' ? main : workspace}${r}`)
+      .split('#');
+    return path.resolve(this.hasModule(base) ? this.getModule(base)!.sourcePath : base, sub ?? '.');
+  }
+
+  /**
+   * Get manifest module by name
+   */
+  getManifestModule(mod: string): ManifestModule {
+    return this.manifest.modules[mod];
+  }
 
-try {
-  index = new $RootIndex(process.env.TRV_MANIFEST!);
-} catch (err) {
-  if (/prod/i.test(process.env.NODE_ENV ?? '')) {
-    throw err;
+  /**
+   * Get manifest modules
+   */
+  getManifestModules(): ManifestModule[] {
+    return Object.values(this.manifest.modules);
   }
 }
 
-export const RootIndex: $RootIndex = index!;
+export const RuntimeIndex = new $RuntimeIndex(process.env.TRV_MANIFEST!);
+
+const build = <T extends object>(inp: T, props: (keyof ManifestContext)[]): T & ManifestContext => {
+  for (const prop of props) {
+    Object.defineProperty(inp, prop, { configurable: false, get: () => RuntimeIndex.manifest[prop] });
+  }
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return inp as T & ManifestContext;
+};
+
+export const RuntimeContext = build({
+  /**
+   * Produce a workspace relative path
+   * @param rel The relative path
+   */
+  workspaceRelative(...rel: string[]): string {
+    return path.resolve(RuntimeIndex.manifest.workspace.path, ...rel);
+  }
+}, ['main', 'workspace']);

package/src/types.ts

@@ -1,4 +1,5 @@
 export type NodeModuleType = 'module' | 'commonjs';
+export type NodePackageManager = 'yarn' | 'npm';
 
 export type ManifestModuleFileType = 'typings' | 'ts' | 'js' | 'json' | 'package-json' | 'unknown' | 'fixture' | 'md';
 export type ManifestModuleFolderType =
@@ -10,17 +11,19 @@ export type ManifestModuleFolderType =
 export type ManifestModuleRole = 'std' | 'test' | 'doc' | 'compile' | 'build';
 
 export type ManifestModuleFile = [string, ManifestModuleFileType, number] | [string, ManifestModuleFileType, number, ManifestModuleRole];
-export type ManifestModuleCore = {
+export type ManifestDepCore = {
   name: string;
   main?: boolean;
   local?: boolean;
   version: string;
+  prod: boolean;
+  internal?: boolean;
+};
+export type ManifestModuleCore = ManifestDepCore & {
   sourceFolder: string;
   outputFolder: string;
-  prod: boolean;
   roles: ManifestModuleRole[];
   parents: string[];
-  internal?: boolean;
 };
 
 export type ManifestModule = ManifestModuleCore & {
@@ -28,19 +31,38 @@ export type ManifestModule = ManifestModuleCore & {
 };
 
 export type ManifestContext = {
-  mainModule: string;
-  mainFolder: string;
-  workspacePath: string;
-  outputFolder: string;
-  toolFolder: string;
-  compilerFolder: string;
-  monoRepo?: boolean;
-  moduleType: NodeModuleType;
-  packageManager: 'yarn' | 'npm';
-  frameworkVersion: string;
-  description?: string;
-  version: string;
-  compilerUrl: string;
+  workspace: {
+    /** Workspace path for module */
+    path: string;
+    /** The module name for the workspace root */
+    name: string;
+    /** Is the workspace a monorepo? */
+    mono?: boolean;
+    /** The module type of the workspace */
+    type: NodeModuleType;
+    /** The package manager of the workspace */
+    manager: NodePackageManager;
+  };
+  build: {
+    /** Compiler folder, relative to workspace */
+    compilerFolder: string;
+    /** Compiler module folder */
+    compilerModuleFolder: string;
+    /** URL for the compiler server */
+    compilerUrl: string;
+    /** Code output folder, relative to workspace */
+    outputFolder: string;
+  };
+  main: {
+    /** Main module for manifest */
+    name: string;
+    /** Folder, relative to workspace for main module */
+    folder: string;
+    /** Description of the main module */
+    description?: string;
+    /** Version of the main module */
+    version: string;
+  };
 };
 
 export type ManifestRoot = ManifestContext & {
@@ -76,19 +98,18 @@ export type Package = {
   peerDependenciesMeta?: Record<string, { optional?: boolean }>;
   optionalDependencies?: Record<string, string>;
   travetto?: {
-    isolated?: boolean;
     displayName?: string;
     roles?: ManifestModuleRole[];
-    globalModules?: string[];
-    mainSource?: string[];
-    docOutput?: string[];
-    docRoot?: string;
-    docBaseUrl?: string;
-    docOutputs?: string[];
-    outputFolder?: string;
-    toolFolder?: string;
-    compilerFolder?: string;
-    compilerUrl?: string;
+    doc?: {
+      output?: string[];
+      root?: string;
+      baseUrl?: string;
+      outputs?: string[];
+    };
+    build?: Partial<ManifestContext['build']> & {
+      isolated?: boolean;
+      withModules?: Record<string, 'main' | true>;
+    };
   };
   workspaces?: string[];
   private?: boolean;
@@ -99,6 +120,7 @@ type OrProm<T> = T | Promise<T>;
 
 export type PackageVisitReq<T> = { pkg: Package, prod: boolean, sourcePath: string, parent?: T, topLevel?: boolean };
 export type PackageVisitor<T> = {
+  rootPath: string;
   init?(req: PackageVisitReq<T>): OrProm<undefined | void | PackageVisitReq<T>[]>;
   valid?(req: PackageVisitReq<T>): boolean;
   create(req: PackageVisitReq<T>): OrProm<T>;

package/src/util.ts

@@ -2,6 +2,7 @@ import { path } from './path';
 import { ManifestContext, ManifestRoot } from './types';
 import { ManifestModuleUtil } from './module';
 import { ManifestFileUtil } from './file';
+import { PackageUtil } from './package';
 
 const MANIFEST_FILE = 'manifest.json';
 
@@ -9,15 +10,6 @@ const MANIFEST_FILE = 'manifest.json';
  * Manifest utils
  */
 export class ManifestUtil {
-  /**
-   * Build a manifest context
-   * @param folder
-   */
-  static async buildContext(folder?: string): Promise<ManifestContext> {
-    const { getManifestContext } = await import('../bin/context.js');
-    return getManifestContext(folder);
-  }
-
   /**
    * Produce manifest in memory
    */
@@ -41,9 +33,11 @@ export class ManifestUtil {
           .filter(x => x.prod)
           .map(m => [m.name, m])
       ),
-      // Mark output folder/workspace path as portable
-      outputFolder: '',
-      workspacePath: '',
+      build: {
+        ...manifest.build,
+        // Mark output folder/workspace path as portable
+        outputFolder: '$$PRODUCTION$$',
+      }
     };
   }
 
@@ -59,10 +53,10 @@ export class ManifestUtil {
       file = path.resolve(file, MANIFEST_FILE);
     }
     const manifest: ManifestRoot = ManifestFileUtil.readAsJsonSync(file);
-    // Support packaged environments, by allowing empty outputFolder
-    if (!manifest.outputFolder) {
-      manifest.outputFolder = path.cwd();
-      manifest.workspacePath = path.cwd();
+    // Support packaged environments, by allowing empty manifest.build.outputFolder
+    if (manifest.build.outputFolder === '$$PRODUCTION$$') {
+      manifest.build.outputFolder = path.cwd();
+      manifest.workspace.path = path.cwd();
     }
     return { manifest, file };
   }
@@ -70,10 +64,10 @@ export class ManifestUtil {
   /**
    * Write manifest for a given context, return location
    */
-  static writeManifest(ctx: ManifestContext, manifest: ManifestRoot): Promise<string> {
-    return ManifestFileUtil.bufferedFileWrite(
-      path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule, MANIFEST_FILE),
-      JSON.stringify(manifest)
+  static writeManifest(manifest: ManifestRoot): Promise<string> {
+    return this.writeManifestToFile(
+      path.resolve(manifest.workspace.path, manifest.build.outputFolder, 'node_modules', manifest.main.name),
+      manifest
     );
   }
 
@@ -91,11 +85,34 @@ export class ManifestUtil {
   }
 
   /**
-   * Rewrite manifest for a given folder
+   * Produce the manifest context for the workspace module
    */
-  static async rewriteManifest(source: string): Promise<void> {
-    const subCtx = await this.buildContext(source);
-    const subManifest = await this.buildManifest(subCtx);
-    await this.writeManifest(subCtx, subManifest);
+  static getWorkspaceContext(ctx: ManifestContext): ManifestContext {
+    return ctx.workspace.mono ? {
+      ...ctx,
+      main: {
+        name: ctx.workspace.name,
+        folder: '',
+        version: '0.0.0',
+      }
+    } : ctx;
+  }
+
+  /**
+   * Produce the manifest context for a given module module
+   */
+  static getModuleContext(ctx: ManifestContext, folder: string): ManifestContext {
+    const modPath = path.resolve(ctx.workspace.path, folder);
+    const pkg = PackageUtil.readPackage(modPath);
+
+    return {
+      ...ctx,
+      main: {
+        name: pkg.name,
+        folder,
+        version: pkg.version,
+        description: pkg.description
+      }
+    };
   }
 }

package/support/transformer.function-metadata.ts

@@ -9,16 +9,16 @@ const MANIFEST_MOD = '@travetto/manifest';
 const MANIFEST_IDX = `${MANIFEST_MOD}/__index__`;
 const ENTRY_POINT = 'support/entry';
 
-const ROOT_IDX_IMPORT = `${MANIFEST_MOD}/src/root-index`;
-const ROOT_IDX_CLS = 'RootIndex';
+const RUNTIME_IDX_IMPORT = `${MANIFEST_MOD}/src/runtime`;
+const RUNTIME_IDX_CLS = 'RuntimeIndex';
 
 const methods = Symbol.for(`${MANIFEST_MOD}:methods`);
 const cls = Symbol.for(`${MANIFEST_MOD}:class`);
 const fn = Symbol.for(`${MANIFEST_MOD}:function`);
-const rootIdx = Symbol.for(`${MANIFEST_MOD}:rootIndex`);
+const runtimeIdx = Symbol.for(`${MANIFEST_MOD}:runtimeIndex`);
 
 interface MetadataInfo {
-  [rootIdx]?: Import;
+  [runtimeIdx]?: Import;
   [methods]?: {
     [key: string]: { hash: number };
   };
@@ -72,8 +72,8 @@ export class RegisterTransformer {
       return node;
     }
 
-    state[rootIdx] ??= state.importFile(ROOT_IDX_IMPORT);
-    const ident = state.createAccess(state[rootIdx].ident, ROOT_IDX_CLS);
+    state[runtimeIdx] ??= state.importFile(RUNTIME_IDX_IMPORT);
+    const ident = state.createAccess(state[runtimeIdx].ident, RUNTIME_IDX_CLS);
 
     const name = node.name?.escapedText.toString() ?? '';
 
@@ -117,8 +117,8 @@ export class RegisterTransformer {
 
     if (ts.isFunctionDeclaration(node) && node.name && node.parent && ts.isSourceFile(node.parent)) {
       // If we have a class like function
-      state[rootIdx] ??= state.importFile(ROOT_IDX_IMPORT);
-      const ident = state.createAccess(state[rootIdx].ident, ROOT_IDX_CLS);
+      state[runtimeIdx] ??= state.importFile(RUNTIME_IDX_IMPORT);
+      const ident = state.createAccess(state[runtimeIdx].ident, RUNTIME_IDX_CLS);
       const meta = state.factory.createCallExpression(
         state.createAccess(ident, 'registerFunction'),
         [],