@eggjs/core 7.0.2-beta.2 → 7.0.2-beta.22

package/dist/loader/loader_fs.js

@@ -0,0 +1,271 @@
+import fs from "node:fs";
+import path from "node:path";
+import { RealLoaderFS as RealLoaderFS$1 } from "@eggjs/loader-fs";
+import multimatch from "multimatch";
+
+//#region src/loader/loader_fs.ts
+var ManifestLoaderFS = class {
+	#manifest;
+	#fallback;
+	#manifestFiles;
+	#manifestDirectories;
+	#resolveCacheTargets;
+	constructor(manifest, fallback = new RealLoaderFS$1()) {
+		this.#manifest = manifest;
+		this.#fallback = fallback;
+		this.#resolveCacheTargets = new Set(Object.values(manifest.data.resolveCache).filter((target) => typeof target === "string"));
+		const manifestFiles = /* @__PURE__ */ new Set();
+		const manifestDirectories = /* @__PURE__ */ new Set();
+		for (const [dir, files] of Object.entries(manifest.data.fileDiscovery)) {
+			addManifestDirectory(manifestDirectories, dir);
+			for (const file of files) {
+				const fullRel = path.posix.join(dir, file);
+				manifestFiles.add(fullRel);
+				addManifestDirectory(manifestDirectories, path.posix.dirname(fullRel));
+			}
+		}
+		for (const target of this.#resolveCacheTargets) {
+			manifestFiles.add(target);
+			addManifestDirectory(manifestDirectories, path.posix.dirname(target));
+		}
+		this.#manifestFiles = manifestFiles;
+		this.#manifestDirectories = manifestDirectories;
+	}
+	exists(filepath) {
+		const entry = this.#getManifestEntry(filepath);
+		if (entry) return entry.type !== "missing";
+		return this.#fallback.exists(filepath);
+	}
+	stat(filepath) {
+		const entry = this.#getManifestEntry(filepath);
+		if (entry?.type === "file" || entry?.type === "directory") return createVirtualStats(entry.type);
+		if (entry?.type === "missing") throw createNotFoundError("stat", filepath);
+		return this.#fallback.stat(filepath);
+	}
+	realpath(filepath) {
+		const entry = this.#getManifestEntry(filepath);
+		if (entry?.type === "file" || entry?.type === "directory") return this.#toAbsolute(entry.rel);
+		if (entry?.type === "missing") throw createNotFoundError("realpath", filepath);
+		return this.#fallback.realpath(filepath);
+	}
+	readJSON(filepath) {
+		const entry = this.#getManifestEntry(filepath);
+		if (entry?.type === "file") {
+			const bundled = this.#loadBundledModule(entry.rel);
+			if (bundled !== void 0) return unwrapDefaultExport(bundled);
+		}
+		if (entry?.type === "missing") throw createNotFoundError("open", filepath);
+		return this.#fallback.readJSON(filepath);
+	}
+	glob(patterns, options) {
+		const cwd = options?.cwd === void 0 ? process.cwd() : String(options.cwd);
+		const absoluteCwd = path.resolve(cwd);
+		const cwdRel = this.#toRelative(absoluteCwd);
+		const manifestFiles = this.#listManifestFilesUnder(cwdRel);
+		if (manifestFiles === void 0) return this.#fallback.glob(patterns, options);
+		const matched = filterManifestGlob(manifestFiles, patterns, options);
+		if (options?.absolute) return matched.map((file) => path.join(absoluteCwd, file));
+		return matched;
+	}
+	async loadFile(filepath) {
+		const entry = this.#getManifestEntry(filepath);
+		if (entry?.type === "file") {
+			const bundled = this.#loadBundledModule(entry.rel);
+			if (bundled !== void 0) return unwrapDefaultExport(bundled);
+		}
+		if (entry?.type === "missing") throw createNotFoundError("open", filepath);
+		return this.#fallback.loadFile(filepath);
+	}
+	#getManifestEntry(filepath) {
+		const rel = this.#toRelative(filepath);
+		const resolved = this.#resolveManifestFile(rel);
+		if (resolved?.type === "file") return {
+			type: "file",
+			rel: resolved.rel
+		};
+		if (resolved?.type === "missing") return {
+			type: "missing",
+			rel
+		};
+		if (this.#isManifestDirectory(rel)) return {
+			type: "directory",
+			rel
+		};
+	}
+	#resolveManifestFile(rel) {
+		const cache = this.#manifest.data.resolveCache;
+		if (Object.hasOwn(cache, rel)) {
+			const cached = cache[rel];
+			return cached === null ? { type: "missing" } : {
+				type: "file",
+				rel: cached
+			};
+		}
+		if (this.#isManifestFile(rel)) return {
+			type: "file",
+			rel
+		};
+		const discovered = this.#resolveFromFileDiscovery(rel);
+		if (discovered) return {
+			type: "file",
+			rel: discovered
+		};
+	}
+	#resolveFromFileDiscovery(rel) {
+		const matchedDir = this.#nearestManifestDiscoveryDir(rel);
+		if (matchedDir === void 0 || rel === matchedDir) return;
+		const request = matchedDir === "" ? rel : rel.slice(matchedDir.length + 1);
+		for (const file of this.#manifest.data.fileDiscovery[matchedDir]) {
+			if (file === request) return path.posix.join(matchedDir, file);
+			const ext = path.posix.extname(file);
+			if (!ext || ext === ".map") continue;
+			const extensionlessFile = file.slice(0, -ext.length);
+			if (extensionlessFile === request || extensionlessFile === `${request}/index`) return path.posix.join(matchedDir, file);
+		}
+	}
+	#nearestManifestDiscoveryDir(rel) {
+		let current = path.posix.dirname(rel);
+		while (true) {
+			const dir = current === "." ? "" : current;
+			if (Object.hasOwn(this.#manifest.data.fileDiscovery, dir)) return dir;
+			if (dir === "") return;
+			current = path.posix.dirname(dir);
+		}
+	}
+	#isManifestFile(rel) {
+		return this.#manifestFiles.has(rel);
+	}
+	#isManifestDirectory(rel) {
+		return this.#manifestDirectories.has(rel);
+	}
+	#listManifestFilesUnder(cwdRel) {
+		if (!this.#isManifestDirectory(cwdRel)) return;
+		const files = /* @__PURE__ */ new Set();
+		for (const [dir, entries] of Object.entries(this.#manifest.data.fileDiscovery)) {
+			const prefix = dir === cwdRel ? "" : relativePrefix(cwdRel, dir);
+			if (prefix === void 0) continue;
+			for (const entry of entries) files.add(path.posix.join(prefix, entry));
+		}
+		for (const target of Object.values(this.#manifest.data.resolveCache)) {
+			if (!target) continue;
+			const prefix = relativePrefix(cwdRel, path.posix.dirname(target));
+			if (prefix !== void 0) files.add(path.posix.join(prefix, path.posix.basename(target)));
+		}
+		return [...files].sort();
+	}
+	#loadBundledModule(rel) {
+		const loader = globalThis.__EGG_BUNDLE_MODULE_LOADER__;
+		if (!loader) return void 0;
+		for (const key of this.#bundleKeys(rel)) {
+			const loaded = loader(key);
+			if (loaded !== void 0) return loaded;
+		}
+	}
+	#bundleKeys(rel) {
+		const abs = this.#toAbsolute(rel);
+		return [...new Set([rel, normalizePath(abs)])];
+	}
+	#toRelative(filepath) {
+		return normalizePath(path.relative(this.#manifest.baseDir, path.resolve(filepath)));
+	}
+	#toAbsolute(rel) {
+		return path.isAbsolute(rel) ? rel : path.join(this.#manifest.baseDir, rel);
+	}
+};
+function normalizePath(filepath) {
+	return filepath.replaceAll(path.sep, "/");
+}
+function addManifestDirectory(directories, dir) {
+	let current = dir === "." ? "" : dir;
+	while (true) {
+		directories.add(current);
+		if (current === "") return;
+		const parent = path.posix.dirname(current);
+		current = parent === "." ? "" : parent;
+	}
+}
+function relativePrefix(cwdRel, dirRel) {
+	if (cwdRel === "") return dirRel;
+	if (dirRel === cwdRel) return "";
+	if (dirRel.startsWith(cwdRel + "/")) return dirRel.slice(cwdRel.length + 1);
+}
+function filterManifestGlob(files, patterns, options) {
+	const patternList = Array.isArray(patterns) ? patterns : [patterns];
+	if (!patternList.some((pattern) => !pattern.startsWith("!"))) return [];
+	const ignoreList = Array.isArray(options?.ignore) ? options.ignore.map(String) : options?.ignore ? [String(options.ignore)] : [];
+	return multimatch(files, patternList.map(normalizeAlternationGroups).concat(ignoreList.map((pattern) => `!${normalizeAlternationGroups(pattern)}`)), toMultimatchOptions(options));
+}
+function toMultimatchOptions(options) {
+	return {
+		...options?.dot !== void 0 ? { dot: options.dot } : {},
+		...options?.caseSensitiveMatch !== void 0 ? { nocase: !options.caseSensitiveMatch } : {},
+		...options?.braceExpansion !== void 0 ? { nobrace: !options.braceExpansion } : {},
+		...options?.extglob !== void 0 ? { noext: !options.extglob } : {},
+		...options?.globstar !== void 0 ? { noglobstar: !options.globstar } : {},
+		...options?.baseNameMatch !== void 0 ? { matchBase: options.baseNameMatch } : {}
+	};
+}
+function normalizeAlternationGroups(pattern) {
+	let normalized = "";
+	for (let index = 0; index < pattern.length; index++) {
+		const char = pattern[index];
+		if (char !== "(" || isExtglobPrefix(pattern[index - 1])) {
+			normalized += char;
+			continue;
+		}
+		const end = pattern.indexOf(")", index + 1);
+		if (end === -1) {
+			normalized += char;
+			continue;
+		}
+		const group = pattern.slice(index + 1, end);
+		if (group.includes("|")) {
+			normalized += `{${group.replaceAll("|", ",")}}`;
+			index = end;
+		} else normalized += char;
+	}
+	return normalized;
+}
+function isExtglobPrefix(char) {
+	return char === "@" || char === "!" || char === "?" || char === "+" || char === "*";
+}
+function unwrapDefaultExport(value) {
+	let unwrapped = value;
+	if (isRecord(unwrapped) && isRecord(unwrapped.default) && unwrapped.default.__esModule === true) unwrapped = unwrapped.default;
+	if (isRecord(unwrapped) && "default" in unwrapped) return unwrapped.default;
+	return unwrapped;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object";
+}
+function createVirtualStats(type) {
+	const stat = Object.create(fs.Stats.prototype);
+	const isFile = type === "file";
+	const timestamp = /* @__PURE__ */ new Date(0);
+	Object.defineProperties(stat, {
+		size: { value: 0 },
+		atimeMs: { value: 0 },
+		mtimeMs: { value: 0 },
+		ctimeMs: { value: 0 },
+		birthtimeMs: { value: 0 },
+		atime: { value: timestamp },
+		mtime: { value: timestamp },
+		ctime: { value: timestamp },
+		birthtime: { value: timestamp },
+		isFile: { value: () => isFile },
+		isDirectory: { value: () => !isFile },
+		isSymbolicLink: { value: () => false }
+	});
+	return stat;
+}
+function createNotFoundError(syscall, filepath) {
+	const err = /* @__PURE__ */ new Error(`ENOENT: no such file or directory, ${syscall} '${filepath}'`);
+	err.code = "ENOENT";
+	err.errno = -2;
+	err.syscall = syscall;
+	err.path = filepath;
+	return err;
+}
+
+//#endregion
+export { ManifestLoaderFS };

package/dist/loader/manifest.d.ts

@@ -0,0 +1,98 @@
+//#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();
+  /**
+  * Register a pre-built manifest store for bundled egg apps. When set,
+  * `ManifestStore.load()` returns this store for matching baseDir requests,
+  * bypassing disk reads and invalidation checks. The bundler-generated entry
+  * calls this at startup before creating the Application.
+  *
+  * Uses globalThis so that bundled and external copies of @eggjs/core
+  * share the same store instance.
+  */
+  static setBundleStore(store: ManifestStore | undefined): void;
+  /**
+  * Return the registered bundle store, if any.
+  */
+  static getBundleStore(): ManifestStore | undefined;
+  /**
+  * 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 ManifestStore from pre-validated bundled data.
+  * Skips invalidation checks — the caller (bundler) is responsible for
+  * guaranteeing the data matches the shipped artifact.
+  */
+  static fromBundle(data: StartupManifest, baseDir: string): ManifestStore;
+  /**
+  * 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;
+  /**
+  * Enable Node.js module compile cache for the current process.
+  * Sets NODE_COMPILE_CACHE and NODE_COMPILE_CACHE_PORTABLE env vars
+  * so forked child processes also inherit compile cache.
+  */
+  static enableCompileCache(baseDir: string): void;
+  /**
+  * Flush accumulated compile cache entries to disk.
+  */
+  static flushCompileCache(): void;
+  /**
+  * Remove the compile cache directory.
+  */
+  static cleanCompileCache(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,341 @@
+import BuiltinModule from "node:module";
+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"
+];
+const BUNDLE_STORE_KEY = "__EGG_BUNDLE_STORE__";
+var ManifestStore = class ManifestStore {
+	data;
+	baseDir;
+	#resolveCacheCollector = {};
+	#fileDiscoveryCollector = {};
+	#extensionCollector = {};
+	constructor(data, baseDir) {
+		this.data = data;
+		this.baseDir = baseDir;
+	}
+	/**
+	* Register a pre-built manifest store for bundled egg apps. When set,
+	* `ManifestStore.load()` returns this store for matching baseDir requests,
+	* bypassing disk reads and invalidation checks. The bundler-generated entry
+	* calls this at startup before creating the Application.
+	*
+	* Uses globalThis so that bundled and external copies of @eggjs/core
+	* share the same store instance.
+	*/
+	static setBundleStore(store) {
+		globalThis[BUNDLE_STORE_KEY] = store;
+	}
+	/**
+	* Return the registered bundle store, if any.
+	*/
+	static getBundleStore() {
+		return globalThis[BUNDLE_STORE_KEY];
+	}
+	/**
+	* Load and validate manifest from `.egg/manifest.json`.
+	* Returns null if manifest doesn't exist or is invalid.
+	*/
+	static load(baseDir, serverEnv, serverScope) {
+		const bundleStore = ManifestStore.getBundleStore();
+		if (bundleStore && bundleStore.baseDir === baseDir) {
+			debug("load: returning registered bundle store for %s", baseDir);
+			return bundleStore;
+		}
+		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 ManifestStore from pre-validated bundled data.
+	* Skips invalidation checks — the caller (bundler) is responsible for
+	* guaranteeing the data matches the shipped artifact.
+	*/
+	static fromBundle(data, baseDir) {
+		if (!data || data.version !== MANIFEST_VERSION) throw new Error(`[@eggjs/core] bundled manifest version mismatch: expected ${MANIFEST_VERSION}, got ${data?.version}`);
+		if (!data.invalidation) throw new Error("[@eggjs/core] bundled manifest missing invalidation data");
+		debug("manifest loaded from bundle");
+		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 discovered = this.#resolveFromFileDiscovery(relKey);
+		if (discovered) {
+			debug("[resolveModule:fileDiscovery] %o => %o", filepath, discovered);
+			return discovered;
+		}
+		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) {
+		if (Object.hasOwn(this.#extensionCollector, name)) return this.#extensionCollector[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;
+		}
+		ManifestStore.cleanCompileCache(baseDir);
+	}
+	/**
+	* Enable Node.js module compile cache for the current process.
+	* Sets NODE_COMPILE_CACHE and NODE_COMPILE_CACHE_PORTABLE env vars
+	* so forked child processes also inherit compile cache.
+	*/
+	static enableCompileCache(baseDir) {
+		if (process.env.NODE_COMPILE_CACHE || process.env.NODE_DISABLE_COMPILE_CACHE) return;
+		const cacheDir = path.join(baseDir, ".egg", "compile-cache");
+		process.env.NODE_COMPILE_CACHE = cacheDir;
+		process.env.NODE_COMPILE_CACHE_PORTABLE = "1";
+		try {
+			const result = BuiltinModule.enableCompileCache?.(cacheDir);
+			debug("compile cache enabled: %o", result);
+		} catch (err) {
+			debug("compile cache enable failed: %o", err);
+		}
+	}
+	/**
+	* Flush accumulated compile cache entries to disk.
+	*/
+	static flushCompileCache() {
+		try {
+			BuiltinModule.flushCompileCache?.();
+			debug("compile cache flushed");
+		} catch (err) {
+			debug("compile cache flush failed: %o", err);
+		}
+	}
+	/**
+	* Remove the compile cache directory.
+	*/
+	static cleanCompileCache(baseDir) {
+		const compileCacheDir = path.join(baseDir, ".egg", "compile-cache");
+		fs.rmSync(compileCacheDir, {
+			recursive: true,
+			force: true
+		});
+		debug("compile cache removed: %s", compileCacheDir);
+	}
+	#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);
+	}
+	#resolveFromFileDiscovery(relKey) {
+		let matchedDir;
+		for (const dir of Object.keys(this.data.fileDiscovery)) if ((relKey === dir || relKey.startsWith(dir + "/")) && (!matchedDir || dir.length > matchedDir.length)) matchedDir = dir;
+		if (!matchedDir || relKey === matchedDir) return;
+		const request = relKey.slice(matchedDir.length + 1);
+		const matchedFile = this.data.fileDiscovery[matchedDir].find((file) => {
+			if (file === request) return true;
+			const ext = path.posix.extname(file);
+			if (!ext || ext === ".map") return false;
+			const extensionlessFile = file.slice(0, -ext.length);
+			return extensionlessFile === request || extensionlessFile === `${request}/index`;
+		});
+		return matchedFile ? this.#toAbsolute(path.posix.join(matchedDir, matchedFile)) : void 0;
+	}
+	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 };