refactor(core): converge manifest logic into ManifestStore + relative paths

- Move cache-check and collector logic from EggLoader/FileLoader into
  ManifestStore.resolveModule() and ManifestStore.globFiles() methods
- Remove resolveCacheCollector/fileDiscoveryCollector from EggLoader
- Remove fileDiscoveryCollector from FileLoaderOptions
- Remove invalidation.baseDir — build and runtime paths may differ
- Store all paths as relative (to baseDir) in manifest JSON
- ManifestStore is now baseDir-aware, converts abs↔rel internally
- Add ManifestStore.createCollector() factory for collection-only mode
- EggLoader.manifest is always set (loaded or collector)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: killagu

packages/core/src/loader/egg_loader.ts

@@ -70,12 +70,8 @@ export class EggLoader {
   readonly appInfo: EggAppInfo;
   readonly outDir?: string;
   dirs?: EggDirInfo[];
-  /** Pre-computed startup manifest for skipping file I/O */
-  readonly manifest: ManifestStore | null;
-  /** Collected resolveModule results for manifest generation */
-  readonly resolveCacheCollector: Record<string, string | null> = {};
-  /** Collected file discovery results for manifest generation */
-  readonly fileDiscoveryCollector: Record<string, string[]> = {};
+  /** Startup manifest — loaded from cache or collecting for generation */
+  readonly manifest: ManifestStore;
 
   /**
    * @class
@@ -164,11 +160,10 @@ export class EggLoader {
      */
     this.appInfo = this.getAppInfo();
 
-    // Load pre-computed startup manifest if available
-    this.manifest = ManifestStore.load(this.options.baseDir, this.serverEnv, this.serverScope);
-    if (this.manifest) {
-      debug('startup manifest loaded, will skip redundant file I/O');
-    }
+    // Load pre-computed manifest or create a collector for future generation
+    this.manifest =
+      ManifestStore.load(this.options.baseDir, this.serverEnv, this.serverScope) ??
+      ManifestStore.createCollector(this.options.baseDir);
   }
 
   get app(): EggCore {
@@ -1651,7 +1646,6 @@ export class EggLoader {
       target,
       inject: this.app,
       manifest: this.manifest,
-      fileDiscoveryCollector: this.fileDiscoveryCollector,
     };
 
     const timingKey = `Load "${String(property)}" to Application`;
@@ -1678,7 +1672,6 @@ export class EggLoader {
       property,
       inject: this.app,
       manifest: this.manifest,
-      fileDiscoveryCollector: this.fileDiscoveryCollector,
     };
 
     const timingKey = `Load "${String(property)}" to Context`;
@@ -1715,28 +1708,19 @@ export class EggLoader {
   }
 
   resolveModule(filepath: string): string | undefined {
-    // Check manifest cache first
-    if (this.manifest) {
-      const cached = this.manifest.getResolveCache(filepath);
-      if (cached !== undefined) {
-        debug('[resolveModule:manifest] %o => %o', filepath, cached);
-        return cached ?? undefined;
-      }
-    }
+    return this.manifest.resolveModule(filepath, () => this.#doResolveModule(filepath));
+  }
 
+  #doResolveModule(filepath: string): string | undefined {
     let fullPath: string | undefined;
     try {
       fullPath = utils.resolvePath(filepath);
     } catch {
-      // debug('[resolveModule] Module %o resolve error: %s', filepath, err.stack);
+      // ignore resolve errors
     }
     if (!fullPath) {
       fullPath = this.#resolveFromOutDir(filepath);
     }
-
-    // Collect for manifest generation
-    this.resolveCacheCollector[filepath] = fullPath ?? null;
-
     return fullPath;
   }
 
@@ -1780,14 +1764,11 @@ export class EggLoader {
    * Should be called after all loading phases complete.
    */
   generateManifest(extensions?: Record<string, unknown>): StartupManifest {
-    return ManifestStore.generate({
-      baseDir: this.options.baseDir,
+    return this.manifest.generateManifest({
       serverEnv: this.serverEnv,
       serverScope: this.serverScope,
       typescriptEnabled: isSupportTypeScript(),
       extensions,
-      resolveCache: this.resolveCacheCollector,
-      fileDiscovery: this.fileDiscoveryCollector,
     });
   }
 }

packages/core/src/loader/file_loader.ts

@@ -50,10 +50,8 @@ export interface FileLoaderOptions {
   /** set property's case when converting a filepath to property list. */
   caseStyle?: CaseStyle | CaseStyleFunction;
   lowercaseFirst?: boolean;
-  /** Pre-computed startup manifest for skipping globby scans */
-  manifest?: ManifestStore | null;
-  /** Collector for file discovery results during manifest generation */
-  fileDiscoveryCollector?: Record<string, string[]>;
+  /** Startup manifest for caching globby scans and collecting results */
+  manifest?: ManifestStore;
 }
 
 export interface FileLoaderParseItem {
@@ -198,17 +196,11 @@ export class FileLoader {
     const items: FileLoaderParseItem[] = [];
     debug('[parse] parsing directories: %j', directories);
     for (const directory of directories) {
-      const cachedFiles = this.options.manifest?.getFileDiscovery(directory);
-      const filepaths = cachedFiles ?? globby.sync(files, { cwd: directory });
-      if (cachedFiles) {
-        debug('[parse:manifest] using cached files for %o, count: %d', directory, cachedFiles.length);
-      } else {
-        debug('[parse] globby files: %o, cwd: %o => %o', files, directory, filepaths);
-        // Collect for manifest generation
-        if (this.options.fileDiscoveryCollector) {
-          this.options.fileDiscoveryCollector[directory] = filepaths;
-        }
-      }
+      const manifest = this.options.manifest;
+      const filepaths = manifest
+        ? manifest.globFiles(directory, () => globby.sync(files, { cwd: directory }))
+        : globby.sync(files, { cwd: directory });
+      debug('[parse] files: %o, cwd: %o => %o', files, directory, filepaths);
       for (const filepath of filepaths) {
         const fullpath = path.join(directory, filepath);
         if (!fs.statSync(fullpath).isFile()) continue;

packages/core/src/loader/manifest.ts

@@ -15,7 +15,6 @@ export interface ManifestInvalidation {
   configFingerprint: string;
   serverEnv: string;
   serverScope: string;
-  baseDir: string;
   typescriptEnabled: boolean;
 }
 
@@ -25,19 +24,27 @@ export interface StartupManifest {
   invalidation: ManifestInvalidation;
   /** Plugin-specific manifest data, keyed by plugin name */
   extensions: Record<string, unknown>;
-  /** resolveModule cache: filepath -> resolved path | null */
+  /** resolveModule cache: relative filepath -> resolved relative path | null */
   resolveCache: Record<string, string | null>;
-  /** directory path -> file relative paths (filtered) */
+  /** relative directory path -> file relative paths */
   fileDiscovery: Record<string, string[]>;
 }
 
 export class ManifestStore {
   readonly data: StartupManifest;
+  readonly baseDir: string;
 
-  private constructor(data: StartupManifest) {
+  // Collectors for manifest generation (populated during loading)
+  readonly #resolveCacheCollector: Record<string, string | null> = {};
+  readonly #fileDiscoveryCollector: Record<string, string[]> = {};
+
+  private constructor(data: StartupManifest, baseDir: string) {
     this.data = data;
+    this.baseDir = baseDir;
   }
 
+  // --- Factory Methods ---
+
   /**
    * Load and validate manifest from `.egg/manifest.json`.
    * Returns null if manifest doesn't exist or is invalid.
@@ -70,7 +77,29 @@ export class ManifestStore {
     }
 
     debug('manifest loaded successfully');
-    return new ManifestStore(data);
+    return new ManifestStore(data, baseDir);
+  }
+
+  /**
+   * Create a collector-only ManifestStore (no cached data).
+   * Used during normal startup to collect data for future manifest generation.
+   */
+  static createCollector(baseDir: string): ManifestStore {
+    const emptyData: StartupManifest = {
+      version: MANIFEST_VERSION,
+      generatedAt: '',
+      invalidation: {
+        lockfileFingerprint: '',
+        configFingerprint: '',
+        serverEnv: '',
+        serverScope: '',
+        typescriptEnabled: false,
+      },
+      extensions: {},
+      resolveCache: {},
+      fileDiscovery: {},
+    };
+    return new ManifestStore(emptyData, baseDir);
   }
 
   static #validate(data: StartupManifest, baseDir: string, serverEnv: string, serverScope: string): boolean {
@@ -85,8 +114,6 @@ export class ManifestStore {
       return false;
     }
 
-    // Note: baseDir is NOT validated — build env and runtime env may have different paths
-
     if (inv.serverEnv !== serverEnv) {
       debug('manifest serverEnv mismatch: expected %s, got %s', serverEnv, inv.serverEnv);
       return false;
@@ -97,7 +124,6 @@ export class ManifestStore {
       return false;
     }
 
-    // Use stat-based fingerprint (mtime+size) for cheap validation
     const currentLockfileFingerprint = ManifestStore.#lockfileFingerprint(baseDir);
     if (inv.lockfileFingerprint !== currentLockfileFingerprint) {
       debug('manifest lockfileFingerprint mismatch');
@@ -113,43 +139,67 @@ export class ManifestStore {
     return true;
   }
 
-  // --- Query APIs ---
+  // --- High-level APIs (cache + collect) ---
 
   /**
-   * Look up a cached resolveModule result.
-   * @returns resolved path (cache hit), `null` (known missing), or `undefined` (not in cache)
+   * Resolve a module path. Checks cache first, falls back to resolver, collects result.
    */
-  getResolveCache(filepath: string): string | null | undefined {
+  resolveModule(filepath: string, fallback: () => string | undefined): string | undefined {
+    const relKey = this.#toRelative(filepath);
     const cache = this.data.resolveCache;
-    if (!cache || !(filepath in cache)) return undefined;
-    return cache[filepath];
+    if (cache && relKey in cache) {
+      const cached = cache[relKey];
+      debug('[resolveModule:manifest] %o => %o', filepath, cached);
+      return cached !== null ? this.#toAbsolute(cached) : undefined;
+    }
+
+    const result = fallback();
+    this.#resolveCacheCollector[relKey] = result !== undefined ? this.#toRelative(result) : null;
+    return result;
   }
 
-  getFileDiscovery(directory: string): string[] | undefined {
-    return this.data.fileDiscovery?.[directory];
+  /**
+   * Get file list for a directory. Checks cache first, falls back to globber, collects result.
+   */
+  globFiles(directory: string, fallback: () => string[]): string[] {
+    const relKey = this.#toRelative(directory);
+    const cached = this.data.fileDiscovery?.[relKey];
+    if (cached) {
+      debug('[globFiles:manifest] using cached files for %o, count: %d', directory, cached.length);
+      return cached;
+    }
+
+    const result = fallback();
+    this.#fileDiscoveryCollector[relKey] = result;
+    return result;
   }
 
+  /**
+   * Look up a plugin extension by name.
+   */
   getExtension(name: string): unknown {
     return this.data.extensions?.[name];
   }
 
   // --- Generation APIs ---
 
-  static generate(options: ManifestGenerateOptions): StartupManifest {
+  /**
+   * Generate a StartupManifest from collected data.
+   */
+  generateManifest(options: ManifestGenerateOptions): StartupManifest {
     return {
       version: MANIFEST_VERSION,
       generatedAt: new Date().toISOString(),
       invalidation: {
-        lockfileFingerprint: ManifestStore.#lockfileFingerprint(options.baseDir),
-        configFingerprint: ManifestStore.#directoryFingerprint(path.join(options.baseDir, 'config')),
+        lockfileFingerprint: ManifestStore.#lockfileFingerprint(this.baseDir),
+        configFingerprint: ManifestStore.#directoryFingerprint(path.join(this.baseDir, 'config')),
         serverEnv: options.serverEnv,
         serverScope: options.serverScope,
-        baseDir: options.baseDir,
         typescriptEnabled: options.typescriptEnabled,
       },
       extensions: options.extensions ?? {},
-      resolveCache: options.resolveCache ?? {},
-      fileDiscovery: options.fileDiscovery ?? {},
+      resolveCache: this.#resolveCacheCollector,
+      fileDiscovery: this.#fileDiscoveryCollector,
     };
   }
 
@@ -171,9 +221,24 @@ export class ManifestStore {
     }
   }
 
-  // --- Fingerprint Utilities (stat-based, no content reads) ---
+  // --- Path Utilities ---
+
+  #toRelative(absPath: string): string {
+    if (path.isAbsolute(absPath)) {
+      return path.relative(this.baseDir, absPath);
+    }
+    return absPath;
+  }
+
+  #toAbsolute(relPath: string): string {
+    if (path.isAbsolute(relPath)) {
+      return relPath;
+    }
+    return path.join(this.baseDir, relPath);
+  }
+
+  // --- Fingerprint Utilities ---
 
-  /** Fingerprint a file by mtime+size — avoids reading file content. */
   static #statFingerprint(filepath: string): string | null {
     try {
       const stat = fs.statSync(filepath);
@@ -183,7 +248,6 @@ export class ManifestStore {
     }
   }
 
-  /** Find and fingerprint the project's lockfile. */
   static #lockfileFingerprint(baseDir: string): string {
     for (const name of LOCKFILE_NAMES) {
       const fp = ManifestStore.#statFingerprint(path.join(baseDir, name));
@@ -192,7 +256,6 @@ export class ManifestStore {
     return '';
   }
 
-  /** Fingerprint a directory tree by file names, mtimes, and sizes. */
   static #directoryFingerprint(dirpath: string): string {
     const hash = createHash('md5');
     const visited = new Set<string>();
@@ -207,7 +270,6 @@ export class ManifestStore {
     } catch {
       return;
     }
-    // Prevent symlink cycles
     if (visited.has(realPath)) return;
     visited.add(realPath);
 
@@ -225,7 +287,6 @@ export class ManifestStore {
         hash.update(`dir:${entry.name}\n`);
         ManifestStore.#fingerprintRecursive(fullPath, hash, visited);
       } else if (entry.isFile()) {
-        // Use stat metadata instead of reading file contents
         const fp = ManifestStore.#statFingerprint(fullPath);
         hash.update(`file:${entry.name}:${fp ?? 'missing'}\n`);
       }
@@ -234,11 +295,8 @@ export class ManifestStore {
 }
 
 export interface ManifestGenerateOptions {
-  baseDir: string;
   serverEnv: string;
   serverScope: string;
   typescriptEnabled: boolean;
   extensions?: Record<string, unknown>;
-  resolveCache?: Record<string, string | null>;
-  fileDiscovery?: Record<string, string[]>;
 }