@eggjs/core 7.0.2-beta.5 → 7.0.2-beta.7

package/dist/egg.d.ts

@@ -18,6 +18,8 @@ interface EggCoreOptions {
   plugins?: any;
   serverScope?: string;
   env?: string;
+  /** Skip lifecycle hooks, only trigger loadMetadata for manifest generation */
+  metadataOnly?: boolean;
 }
 type EggCoreInitOptions = Partial<EggCoreOptions>;
 declare class Request$1 extends KoaRequest {

package/dist/egg.js

@@ -130,7 +130,8 @@ var EggCore = class EggCore extends KoaApplication {
 			logger: this.console,
 			serverScope: options.serverScope,
 			env: options.env ?? "",
-			EggCoreClass: EggCore
+			EggCoreClass: EggCore,
+			metadataOnly: options.metadataOnly
 		});
 	}
 	get logger() {

package/dist/index.d.ts

@@ -3,10 +3,11 @@ import { BaseContextClass } from "./base_context_class.js";
 import { Timing, TimingItem } from "./utils/timing.js";
 import { BootImplClass, FunWithFullPath, ILifecycleBoot, Lifecycle, LifecycleOptions } from "./lifecycle.js";
 import { CustomLoaderConfigItem, EggAppConfig, EggAppInfo, EggPluginInfo } from "./types.js";
+import { ManifestGenerateOptions, ManifestInvalidation, ManifestStore, StartupManifest } from "./loader/manifest.js";
 import { CaseStyle, CaseStyleFunction, EXPORTS, FULLPATH, FileLoader, FileLoaderFilter, FileLoaderInitializer, FileLoaderOptions, FileLoaderParseItem } from "./loader/file_loader.js";
 import { ClassLoader, ClassLoaderOptions, ContextLoader, ContextLoaderOptions } from "./loader/context_loader.js";
 import { EggDirInfo, EggDirInfoType, EggLoader, EggLoaderOptions } from "./loader/egg_loader.js";
 import { Singleton, SingletonCreateMethod, SingletonOptions } from "./singleton.js";
 import { Context, EGG_LOADER, EggCore, EggCoreInitOptions, EggCoreOptions, KoaApplication, KoaContext, KoaMiddlewareFunc, KoaRequest, KoaResponse, MiddlewareFunc, Next, Request, Response, Router } from "./egg.js";
 import { SequencifyResult, SequencifyTask, sequencify } from "./utils/sequencify.js";
-export { BaseContextClass, BootImplClass, CaseStyle, CaseStyleFunction, ClassLoader, ClassLoaderOptions, Context, ContextLoader, ContextLoaderOptions, CustomLoaderConfigItem, EGG_LOADER, EXPORTS, EggAppConfig, EggAppInfo, EggCore, EggCoreInitOptions, EggCoreOptions, EggDirInfo, EggDirInfoType, EggLoader, EggLoaderOptions, EggPluginInfo, FULLPATH, FileLoader, FileLoaderFilter, FileLoaderInitializer, FileLoaderOptions, FileLoaderParseItem, FunWithFullPath, ILifecycleBoot, KoaApplication, KoaContext, KoaMiddlewareFunc, KoaRequest, KoaResponse, Lifecycle, LifecycleOptions, MiddlewareFunc, Next, Request, Response, Router, SequencifyResult, SequencifyTask, Singleton, SingletonCreateMethod, SingletonOptions, Timing, TimingItem, sequencify, utils };
+export { BaseContextClass, BootImplClass, CaseStyle, CaseStyleFunction, ClassLoader, ClassLoaderOptions, Context, ContextLoader, ContextLoaderOptions, CustomLoaderConfigItem, EGG_LOADER, EXPORTS, EggAppConfig, EggAppInfo, EggCore, EggCoreInitOptions, EggCoreOptions, EggDirInfo, EggDirInfoType, EggLoader, EggLoaderOptions, EggPluginInfo, FULLPATH, FileLoader, FileLoaderFilter, FileLoaderInitializer, FileLoaderOptions, FileLoaderParseItem, FunWithFullPath, ILifecycleBoot, KoaApplication, KoaContext, KoaMiddlewareFunc, KoaRequest, KoaResponse, Lifecycle, LifecycleOptions, ManifestGenerateOptions, ManifestInvalidation, ManifestStore, MiddlewareFunc, Next, Request, Response, Router, SequencifyResult, SequencifyTask, Singleton, SingletonCreateMethod, SingletonOptions, StartupManifest, Timing, TimingItem, sequencify, utils };

package/dist/index.js

@@ -5,8 +5,9 @@ import { sequencify } from "./utils/sequencify.js";
 import { Timing } from "./utils/timing.js";
 import { CaseStyle, EXPORTS, FULLPATH, FileLoader } from "./loader/file_loader.js";
 import { ClassLoader, ContextLoader } from "./loader/context_loader.js";
+import { ManifestStore } from "./loader/manifest.js";
 import { EggLoader } from "./loader/egg_loader.js";
 import { Singleton } from "./singleton.js";
 import { Context, EGG_LOADER, EggCore, KoaApplication, KoaContext, KoaRequest, KoaResponse, Request, Response, Router } from "./egg.js";
 
-export { BaseContextClass, CaseStyle, ClassLoader, Context, ContextLoader, EGG_LOADER, EXPORTS, EggCore, EggLoader, FULLPATH, FileLoader, KoaApplication, KoaContext, KoaRequest, KoaResponse, Lifecycle, Request, Response, Router, Singleton, Timing, sequencify, utils_default as utils };
+export { BaseContextClass, CaseStyle, ClassLoader, Context, ContextLoader, EGG_LOADER, EXPORTS, EggCore, EggLoader, FULLPATH, FileLoader, KoaApplication, KoaContext, KoaRequest, KoaResponse, Lifecycle, ManifestStore, Request, Response, Router, Singleton, Timing, sequencify, utils_default as utils };

package/dist/lifecycle.d.ts

@@ -40,6 +40,12 @@ interface ILifecycleBoot {
   * Do some thing before app close
   */
   beforeClose?(): Promise<void>;
+  /**
+  * Collect metadata for manifest generation (metadataOnly mode).
+  * Called instead of configWillLoad/configDidLoad/didLoad/willReady
+  * when the application is started with metadataOnly: true.
+  */
+  loadMetadata?(): Promise<void> | void;
 }
 type BootImplClass<T = ILifecycleBoot> = new (...args: any[]) => T;
 interface LifecycleOptions {
@@ -78,6 +84,7 @@ declare class Lifecycle extends EventEmitter {
   triggerWillReady(): void;
   triggerDidReady(err?: Error): Promise<void>;
   triggerServerDidReady(): Promise<void>;
+  triggerLoadMetadata(): Promise<void>;
 }
 //#endregion
 export { BootImplClass, FunWithFullPath, ILifecycleBoot, Lifecycle, LifecycleOptions };

package/dist/lifecycle.js

@@ -15,6 +15,7 @@ var Lifecycle = class extends EventEmitter {
 	#bootHooks;
 	#boots;
 	#isClosed;
+	#metadataOnly;
 	#closeFunctionSet;
 	loadReady;
 	bootReady;
@@ -29,6 +30,7 @@ var Lifecycle = class extends EventEmitter {
 		this.#boots = [];
 		this.#closeFunctionSet = /* @__PURE__ */ new Set();
 		this.#isClosed = false;
+		this.#metadataOnly = false;
 		this.#init = false;
 		this.timing.start(`${this.options.app.type} Start`);
 		const eggReadyTimeoutEnv = Number.parseInt(process.env.EGG_READY_TIMEOUT_ENV || "10000");
@@ -41,7 +43,7 @@ var Lifecycle = class extends EventEmitter {
 			this.logger.warn("[egg/core/lifecycle:ready_timeout] %s seconds later %s was still unable to finish.", this.readyTimeout / 1e3, id);
 		});
 		this.ready((err) => {
-			this.triggerDidReady(err);
+			if (!this.#metadataOnly) this.triggerDidReady(err);
 			debug("app ready");
 			this.timing.end(`${this.options.app.type} Start`);
 		});
@@ -221,6 +223,24 @@ var Lifecycle = class extends EventEmitter {
 			debug("trigger serverDidReady end");
 		})();
 	}
+	async triggerLoadMetadata() {
+		this.#metadataOnly = true;
+		debug("trigger loadMetadata start");
+		let firstError;
+		for (const boot of this.#boots) if (typeof boot.loadMetadata === "function") {
+			debug("trigger loadMetadata at %o", boot.fullPath);
+			try {
+				await boot.loadMetadata();
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				if (!firstError) firstError = error;
+				debug("trigger loadMetadata error at %o, error: %s", boot.fullPath, error);
+				this.emit("error", error);
+			}
+		}
+		debug("trigger loadMetadata end");
+		this.ready(firstError ?? true);
+	}
 	#initReady() {
 		debug("loadReady init");
 		this.loadReady = new Ready$1({

package/dist/loader/egg_loader.d.ts

@@ -1,6 +1,7 @@
 import { Timing } from "../utils/timing.js";
 import { Lifecycle } from "../lifecycle.js";
 import { EggAppConfig, EggAppInfo, EggPluginInfo } from "../types.js";
+import { ManifestStore, StartupManifest } from "./manifest.js";
 import { FileLoader, FileLoaderOptions } from "./file_loader.js";
 import { ContextLoader, ContextLoaderOptions } from "./context_loader.js";
 import { EggCore } from "../egg.js";
@@ -21,6 +22,8 @@ interface EggLoaderOptions {
   serverScope?: string;
   /** custom plugins */
   plugins?: Record<string, EggPluginInfo>;
+  /** Skip lifecycle hooks, only trigger loadMetadata for manifest generation */
+  metadataOnly?: boolean;
 }
 type EggDirInfoType = "app" | "plugin" | "framework";
 interface EggDirInfo {
@@ -38,6 +41,8 @@ declare class EggLoader {
   readonly appInfo: EggAppInfo;
   readonly outDir?: string;
   dirs?: EggDirInfo[];
+  /** Startup manifest — loaded from cache or collecting for generation */
+  readonly manifest: ManifestStore;
   /**
   * @class
   * @param {Object} options - options
@@ -369,6 +374,11 @@ declare class EggLoader {
   get ContextLoader(): typeof ContextLoader;
   getTypeFiles(filename: string): string[];
   resolveModule(filepath: string): string | undefined;
+  /**
+  * Generate startup manifest from collected data.
+  * Should be called after all loading phases complete.
+  */
+  generateManifest(): StartupManifest;
 }
 //#endregion
 export { EggDirInfo, EggDirInfoType, EggLoader, EggLoaderOptions };

package/dist/loader/egg_loader.js

@@ -3,6 +3,7 @@ import { sequencify } from "../utils/sequencify.js";
 import { Timing } from "../utils/timing.js";
 import { CaseStyle, FULLPATH, FileLoader } from "./file_loader.js";
 import { ContextLoader } from "./context_loader.js";
+import { ManifestStore } from "./manifest.js";
 import fs from "node:fs";
 import path from "node:path";
 import { debuglog, inspect } from "node:util";
@@ -36,6 +37,8 @@ var EggLoader = class {
 	appInfo;
 	outDir;
 	dirs;
+	/** Startup manifest — loaded from cache or collecting for generation */
+	manifest;
 	/**
 	* @class
 	* @param {Object} options - options
@@ -104,6 +107,7 @@ var EggLoader = class {
 		* @since 1.0.0
 		*/
 		this.appInfo = this.getAppInfo();
+		this.manifest = ManifestStore.load(this.options.baseDir, this.serverEnv, this.serverScope) ?? ManifestStore.createCollector(this.options.baseDir);
 	}
 	get app() {
 		return this.options.app;
@@ -741,14 +745,16 @@ var EggLoader = class {
 	*/
 	async loadCustomApp() {
 		await this.#loadBootHook("app");
-		this.lifecycle.triggerConfigWillLoad();
+		if (this.options.metadataOnly) await this.lifecycle.triggerLoadMetadata();
+		else this.lifecycle.triggerConfigWillLoad();
 	}
 	/**
 	* Load agent.js, same as {@link EggLoader#loadCustomApp}
 	*/
 	async loadCustomAgent() {
 		await this.#loadBootHook("agent");
-		this.lifecycle.triggerConfigWillLoad();
+		if (this.options.metadataOnly) await this.lifecycle.triggerLoadMetadata();
+		else this.lifecycle.triggerConfigWillLoad();
 	}
 	loadBootHook() {}
 	async #loadBootHook(fileName) {
@@ -1041,7 +1047,8 @@ var EggLoader = class {
 			...options,
 			directory: options?.directory ?? directory,
 			target,
-			inject: this.app
+			inject: this.app,
+			manifest: this.manifest
 		};
 		const timingKey = `Load "${String(property)}" to Application`;
 		this.timing.start(timingKey);
@@ -1060,7 +1067,8 @@ var EggLoader = class {
 			...options,
 			directory: options?.directory || directory,
 			property,
-			inject: this.app
+			inject: this.app,
+			manifest: this.manifest
 		};
 		const timingKey = `Load "${String(property)}" to Context`;
 		this.timing.start(timingKey);
@@ -1090,6 +1098,9 @@ var EggLoader = class {
 		return files;
 	}
 	resolveModule(filepath) {
+		return this.manifest.resolveModule(filepath, () => this.#doResolveModule(filepath));
+	}
+	#doResolveModule(filepath) {
 		let fullPath;
 		try {
 			fullPath = utils_default.resolvePath(filepath);
@@ -1124,6 +1135,17 @@ var EggLoader = class {
 			}
 		}
 	}
+	/**
+	* Generate startup manifest from collected data.
+	* Should be called after all loading phases complete.
+	*/
+	generateManifest() {
+		return this.manifest.generateManifest({
+			serverEnv: this.serverEnv,
+			serverScope: this.serverScope,
+			typescriptEnabled: isSupportTypeScript()
+		});
+	}
 };
 function depCompatible(plugin) {
 	if (plugin.dep && !(Array.isArray(plugin.dependencies) && plugin.dependencies.length > 0)) {

package/dist/loader/file_loader.d.ts

@@ -1,4 +1,5 @@
 import { Fun } from "../utils/index.js";
+import { ManifestStore } from "./manifest.js";
 
 //#region src/loader/file_loader.d.ts
 declare const FULLPATH: unique symbol;
@@ -37,6 +38,8 @@ interface FileLoaderOptions {
   /** set property's case when converting a filepath to property list. */
   caseStyle?: CaseStyle | CaseStyleFunction;
   lowercaseFirst?: boolean;
+  /** Startup manifest for caching globby scans and collecting results */
+  manifest?: ManifestStore;
 }
 interface FileLoaderParseItem {
   fullpath: string;

package/dist/loader/file_loader.js

@@ -127,8 +127,9 @@ var FileLoader = class {
 		const items = [];
 		debug("[parse] parsing directories: %j", directories);
 		for (const directory of directories) {
-			const filepaths = globby.sync(files, { cwd: directory });
-			debug("[parse] globby files: %o, cwd: %o => %o", files, 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;

package/dist/loader/manifest.d.ts

@@ -0,0 +1,64 @@
+//#region src/loader/manifest.d.ts
+interface ManifestInvalidation {
+  lockfileFingerprint: string;
+  configFingerprint: string;
+  serverEnv: string;
+  serverScope: string;
+  typescriptEnabled: boolean;
+}
+interface StartupManifest {
+  version: number;
+  generatedAt: string;
+  invalidation: ManifestInvalidation;
+  /** Plugin-specific manifest data, keyed by plugin name */
+  extensions: Record<string, unknown>;
+  /** resolveModule cache: relative filepath -> resolved relative path | null */
+  resolveCache: Record<string, string | null>;
+  /** relative directory path -> file relative paths */
+  fileDiscovery: Record<string, string[]>;
+}
+declare class ManifestStore {
+  #private;
+  readonly data: StartupManifest;
+  readonly baseDir: string;
+  private constructor();
+  /**
+  * Load and validate manifest from `.egg/manifest.json`.
+  * Returns null if manifest doesn't exist or is invalid.
+  */
+  static load(baseDir: string, serverEnv: string, serverScope: string): ManifestStore | null;
+  /**
+  * Create a collector-only ManifestStore (no cached data).
+  * Used during normal startup to collect data for future manifest generation.
+  */
+  static createCollector(baseDir: string): ManifestStore;
+  /**
+  * Resolve a module path. Checks cache first, falls back to resolver, collects result.
+  */
+  resolveModule(filepath: string, fallback: () => string | undefined): string | undefined;
+  /**
+  * Get file list for a directory. Checks cache first, falls back to globber, collects result.
+  */
+  globFiles(directory: string, fallback: () => string[]): string[];
+  /**
+  * Look up a plugin extension by name.
+  */
+  getExtension(name: string): unknown;
+  /**
+  * Register plugin extension data for manifest generation.
+  */
+  setExtension(name: string, data: unknown): void;
+  /**
+  * Generate a StartupManifest from collected data.
+  */
+  generateManifest(options: ManifestGenerateOptions): StartupManifest;
+  static write(baseDir: string, manifest: StartupManifest): Promise<void>;
+  static clean(baseDir: string): void;
+}
+interface ManifestGenerateOptions {
+  serverEnv: string;
+  serverScope: string;
+  typescriptEnabled: boolean;
+}
+//#endregion
+export { ManifestGenerateOptions, ManifestInvalidation, ManifestStore, StartupManifest };

package/dist/loader/manifest.js

@@ -0,0 +1,245 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { debuglog } from "node:util";
+import { isSupportTypeScript } from "@eggjs/utils";
+import { createHash } from "node:crypto";
+
+//#region src/loader/manifest.ts
+const debug = debuglog("egg/core/loader/manifest");
+const MANIFEST_VERSION = 1;
+const LOCKFILE_NAMES = [
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"yarn.lock"
+];
+var ManifestStore = class ManifestStore {
+	data;
+	baseDir;
+	#resolveCacheCollector = {};
+	#fileDiscoveryCollector = {};
+	#extensionCollector = {};
+	constructor(data, baseDir) {
+		this.data = data;
+		this.baseDir = baseDir;
+	}
+	/**
+	* Load and validate manifest from `.egg/manifest.json`.
+	* Returns null if manifest doesn't exist or is invalid.
+	*/
+	static load(baseDir, serverEnv, serverScope) {
+		if (serverEnv === "local" && process.env.EGG_MANIFEST !== "true") {
+			debug("skip manifest in local env (set EGG_MANIFEST=true to enable)");
+			return null;
+		}
+		const manifestPath = path.join(baseDir, ".egg", "manifest.json");
+		let raw;
+		try {
+			raw = fs.readFileSync(manifestPath, "utf-8");
+		} catch {
+			debug("manifest not found at %s", manifestPath);
+			return null;
+		}
+		let data;
+		try {
+			data = JSON.parse(raw);
+		} catch (e) {
+			debug("failed to parse manifest: %s", e);
+			return null;
+		}
+		if (!ManifestStore.#validate(data, baseDir, serverEnv, serverScope)) return null;
+		debug("manifest loaded successfully");
+		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) {
+		return new ManifestStore({
+			version: MANIFEST_VERSION,
+			generatedAt: "",
+			invalidation: {
+				lockfileFingerprint: "",
+				configFingerprint: "",
+				serverEnv: "",
+				serverScope: "",
+				typescriptEnabled: false
+			},
+			extensions: {},
+			resolveCache: {},
+			fileDiscovery: {}
+		}, baseDir);
+	}
+	static #validate(data, baseDir, serverEnv, serverScope) {
+		if (data.version !== MANIFEST_VERSION) {
+			debug("manifest version mismatch: expected %d, got %d", MANIFEST_VERSION, data.version);
+			return false;
+		}
+		const inv = data.invalidation;
+		if (!inv) {
+			debug("manifest missing invalidation data");
+			return false;
+		}
+		if (inv.serverEnv !== serverEnv) {
+			debug("manifest serverEnv mismatch: expected %s, got %s", serverEnv, inv.serverEnv);
+			return false;
+		}
+		if (inv.serverScope !== serverScope) {
+			debug("manifest serverScope mismatch: expected %s, got %s", serverScope, inv.serverScope);
+			return false;
+		}
+		const currentTypescriptEnabled = isSupportTypeScript();
+		if (inv.typescriptEnabled !== currentTypescriptEnabled) {
+			debug("manifest typescriptEnabled mismatch: expected %s, got %s", currentTypescriptEnabled, inv.typescriptEnabled);
+			return false;
+		}
+		const currentLockfileFingerprint = ManifestStore.#lockfileFingerprint(baseDir);
+		if (inv.lockfileFingerprint !== currentLockfileFingerprint) {
+			debug("manifest lockfileFingerprint mismatch");
+			return false;
+		}
+		const currentConfigFingerprint = ManifestStore.#directoryFingerprint(path.join(baseDir, "config"));
+		if (inv.configFingerprint !== currentConfigFingerprint) {
+			debug("manifest configFingerprint mismatch");
+			return false;
+		}
+		return true;
+	}
+	/**
+	* Resolve a module path. Checks cache first, falls back to resolver, collects result.
+	*/
+	resolveModule(filepath, fallback) {
+		const relKey = this.#toRelative(filepath);
+		const cache = this.data.resolveCache;
+		if (cache && relKey in cache) {
+			const cached = cache[relKey];
+			debug("[resolveModule:manifest] %o => %o", filepath, cached);
+			return cached !== null ? this.#toAbsolute(cached) : void 0;
+		}
+		const result = fallback();
+		this.#resolveCacheCollector[relKey] = result !== void 0 ? this.#toRelative(result) : null;
+		return result;
+	}
+	/**
+	* Get file list for a directory. Checks cache first, falls back to globber, collects result.
+	*/
+	globFiles(directory, fallback) {
+		const relKey = this.#toRelative(directory);
+		const cache = this.data.fileDiscovery;
+		if (cache && relKey in cache) {
+			const cached = cache[relKey];
+			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) {
+		return this.data.extensions?.[name];
+	}
+	/**
+	* Register plugin extension data for manifest generation.
+	*/
+	setExtension(name, data) {
+		this.#extensionCollector[name] = data;
+	}
+	/**
+	* Generate a StartupManifest from collected data.
+	*/
+	generateManifest(options) {
+		return {
+			version: MANIFEST_VERSION,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			invalidation: {
+				lockfileFingerprint: ManifestStore.#lockfileFingerprint(this.baseDir),
+				configFingerprint: ManifestStore.#directoryFingerprint(path.join(this.baseDir, "config")),
+				serverEnv: options.serverEnv,
+				serverScope: options.serverScope,
+				typescriptEnabled: options.typescriptEnabled
+			},
+			extensions: this.#extensionCollector,
+			resolveCache: this.#resolveCacheCollector,
+			fileDiscovery: this.#fileDiscoveryCollector
+		};
+	}
+	static async write(baseDir, manifest) {
+		const dir = path.join(baseDir, ".egg");
+		await fsp.mkdir(dir, { recursive: true });
+		const manifestPath = path.join(dir, "manifest.json");
+		await fsp.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+		debug("manifest written to %s", manifestPath);
+	}
+	static clean(baseDir) {
+		const manifestPath = path.join(baseDir, ".egg", "manifest.json");
+		try {
+			fs.unlinkSync(manifestPath);
+			debug("manifest removed: %s", manifestPath);
+		} catch (err) {
+			if (err.code !== "ENOENT") throw err;
+		}
+	}
+	#toRelative(absPath) {
+		return (path.isAbsolute(absPath) ? path.relative(this.baseDir, absPath) : absPath).replaceAll(path.sep, "/");
+	}
+	#toAbsolute(relPath) {
+		if (path.isAbsolute(relPath)) return relPath;
+		return path.join(this.baseDir, relPath);
+	}
+	static #statFingerprint(filepath) {
+		try {
+			const stat$1 = fs.statSync(filepath);
+			return `${stat$1.mtimeMs}:${stat$1.size}`;
+		} catch {
+			return null;
+		}
+	}
+	static #lockfileFingerprint(baseDir) {
+		for (const name of LOCKFILE_NAMES) {
+			const fp = ManifestStore.#statFingerprint(path.join(baseDir, name));
+			if (fp) return `${name}:${fp}`;
+		}
+		return "";
+	}
+	static #directoryFingerprint(dirpath) {
+		const hash = createHash("md5");
+		const visited = /* @__PURE__ */ new Set();
+		ManifestStore.#fingerprintRecursive(dirpath, hash, visited);
+		return hash.digest("hex");
+	}
+	static #fingerprintRecursive(dirpath, hash, visited) {
+		let realPath;
+		try {
+			realPath = fs.realpathSync(dirpath);
+		} catch {
+			return;
+		}
+		if (visited.has(realPath)) return;
+		visited.add(realPath);
+		let entries;
+		try {
+			entries = fs.readdirSync(dirpath, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		entries.sort((a, b) => a.name.localeCompare(b.name));
+		for (const entry of entries) {
+			if (entry.isSymbolicLink()) continue;
+			const fullPath = path.join(dirpath, entry.name);
+			if (entry.isDirectory()) {
+				hash.update(`dir:${entry.name}\n`);
+				ManifestStore.#fingerprintRecursive(fullPath, hash, visited);
+			} else if (entry.isFile()) {
+				const fp = ManifestStore.#statFingerprint(fullPath);
+				hash.update(`file:${entry.name}:${fp ?? "missing"}\n`);
+			}
+		}
+	}
+};
+
+//#endregion
+export { ManifestStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/core",
-  "version": "7.0.2-beta.5",
+  "version": "7.0.2-beta.7",
   "description": "A core plugin framework based on @eggjs/koa",
   "keywords": [
     "egg",
@@ -41,11 +41,11 @@
     "ready-callback": "^4.0.0",
     "tsconfig-paths": "^4.2.0",
     "utility": "^2.5.0",
-    "@eggjs/extend2": "5.0.2-beta.5",
-    "@eggjs/koa": "3.1.2-beta.5",
-    "@eggjs/router": "4.0.2-beta.5",
-    "@eggjs/utils": "5.0.2-beta.5",
-    "@eggjs/path-matching": "3.0.2-beta.5"
+    "@eggjs/extend2": "5.0.2-beta.7",
+    "@eggjs/koa": "3.1.2-beta.7",
+    "@eggjs/path-matching": "3.0.2-beta.7",
+    "@eggjs/router": "4.0.2-beta.7",
+    "@eggjs/utils": "5.0.2-beta.7"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
@@ -57,9 +57,9 @@
     "mm": "^4.0.2",
     "typescript": "^5.9.3",
     "urllib": "^4.8.2",
-    "@eggjs/mock": "7.0.2-beta.5",
-    "@eggjs/tsconfig": "3.1.2-beta.5",
-    "@eggjs/supertest": "9.0.2-beta.5"
+    "@eggjs/mock": "7.0.2-beta.7",
+    "@eggjs/tsconfig": "3.1.2-beta.7",
+    "@eggjs/supertest": "9.0.2-beta.7"
   },
   "engines": {
     "node": ">=22.18.0"