deslop-js 0.6.2 → 0.7.0

package/dist/index.cjs

@@ -26,6 +26,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+const require_constants = require('./constants-CD9NXHxi.cjs');
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
 let node_fs = require("node:fs");
@@ -36,327 +37,20 @@ let oxc_parser = require("oxc-parser");
 let typescript = require("typescript");
 typescript = __toESM(typescript, 1);
 let oxc_resolver = require("oxc-resolver");
-let node_worker_threads = require("node:worker_threads");
-let node_url = require("node:url");
 let node_os = require("node:os");
 node_os = __toESM(node_os, 1);
+let node_worker_threads = require("node:worker_threads");
+let node_url = require("node:url");
 let minimatch = require("minimatch");
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto, 1);
+let node_module = require("node:module");
 let node_child_process = require("node:child_process");
 
-//#region src/constants.ts
-const DEFAULT_EXTENSIONS = [
-	".ts",
-	".tsx",
-	".js",
-	".jsx",
-	".mts",
-	".mjs",
-	".cts",
-	".cjs",
-	".mdx",
-	".astro",
-	".graphql",
-	".gql",
-	".css",
-	".scss",
-	".vue",
-	".svelte"
-];
-const HIDDEN_DIRECTORY_ALLOWLIST = [
-	".storybook",
-	".vitepress",
-	".well-known",
-	".changeset",
-	".github",
-	".client",
-	".server"
-];
-const OUTPUT_DIRECTORIES = [
-	"dist",
-	"build",
-	"out",
-	"esm",
-	"cjs"
-];
-const SOURCE_EXTENSIONS$3 = [
-	"ts",
-	"tsx",
-	"mts",
-	"cts",
-	"js",
-	"jsx",
-	"mjs",
-	"cjs"
-];
-const DEFAULT_EXCLUSIONS = [
-	"**/node_modules/**",
-	"**/.git/**",
-	"**/coverage/**",
-	"**/*.min.js",
-	"**/*.min.mjs",
-	"**/mockServiceWorker.js"
-];
-const SCRIPT_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|tsc|npx|bun|esr|esno|jiti|babel-node|zx)\s+(?:\S+\s+)*?([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))(?:\s|$)/;
-const SCRIPT_EXTENSIONLESS_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|bun|esr|esno|jiti|babel-node|zx)\s+(?:\S+\s+)*?((?:[./]|[\w@][\w@-]*\/)[\w./@-]+)(?:\s|$)/;
-const SCRIPT_CONFIG_FILE_PATTERN = /--config\s+([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))/;
-const SCRIPT_ENTRY_PATTERNS = [];
-const DEFAULT_ENTRY_GLOBS = [
-	"src/index.{ts,tsx,js,jsx}",
-	"src/main.{ts,tsx,js,jsx}",
-	"index.{ts,tsx,js,jsx}",
-	"main.{ts,tsx,js,jsx}"
-];
-const KNOWN_CONFIG_PREFIXES = [
-	"babel.config.",
-	"rollup.config.",
-	"webpack.config.",
-	"postcss.config.",
-	"stencil.config.",
-	"remotion.config.",
-	"metro.config.",
-	"tsup.config.",
-	"tsdown.config.",
-	"unbuild.config.",
-	"esbuild.config.",
-	"swc.config.",
-	"turbo.",
-	"jest.config.",
-	"jest.setup.",
-	"vitest.config.",
-	"vitest.ci.config.",
-	"vitest.setup.",
-	"vitest.workspace.",
-	"playwright.config.",
-	"cypress.config.",
-	"karma.conf.",
-	"eslint.config.",
-	"prettier.config.",
-	"stylelint.config.",
-	"lint-staged.config.",
-	"commitlint.config.",
-	"next.config.",
-	"next-sitemap.config.",
-	"nuxt.config.",
-	"astro.config.",
-	"sanity.config.",
-	"vite.config.",
-	"tailwind.config.",
-	"drizzle.config.",
-	"knexfile.",
-	"sentry.client.config.",
-	"sentry.server.config.",
-	"sentry.edge.config.",
-	"react-router.config.",
-	"typedoc.",
-	"deslop.config.",
-	"i18next-parser.config.",
-	"codegen.config.",
-	"graphql.config.",
-	"npmpackagejsonlint.config.",
-	"release-it.",
-	"release.config.",
-	"contentlayer.config.",
-	"rspack.config.",
-	"rsbuild.config.",
-	"module-federation.config.",
-	"vercel.",
-	"next-env.d.",
-	"env.d.",
-	"vite-env.d."
-];
-const IMPLICIT_DEPENDENCIES = new Set([
-	"typescript",
-	"@types/node",
-	"@types/react",
-	"@types/react-dom",
-	"eslint",
-	"prettier",
-	"husky",
-	"lint-staged",
-	"tslib",
-	"@babel/core",
-	"@babel/runtime",
-	"babel-core",
-	"babel-jest",
-	"babel-loader",
-	"postcss",
-	"cross-env",
-	"sass",
-	"node-sass",
-	"less",
-	"oxlint",
-	"biome",
-	"@biomejs/biome",
-	"patch-package",
-	"simple-git-hooks",
-	"lefthook",
-	"ts-node",
-	"ts-jest",
-	"tsx",
-	"jsdom",
-	"rimraf",
-	"concurrently",
-	"npm-run-all",
-	"npm-run-all2",
-	"dotenv-cli",
-	"webpack",
-	"rollup",
-	"terser",
-	"autoprefixer",
-	"tailwindcss",
-	"react-test-renderer",
-	"esbuild",
-	"typedoc",
-	"commitizen",
-	"cz-conventional-changelog"
-]);
-const BUILTIN_MODULES = new Set([
-	"assert",
-	"async_hooks",
-	"buffer",
-	"child_process",
-	"cluster",
-	"console",
-	"constants",
-	"crypto",
-	"dgram",
-	"diagnostics_channel",
-	"dns",
-	"domain",
-	"events",
-	"fs",
-	"http",
-	"http2",
-	"https",
-	"inspector",
-	"module",
-	"net",
-	"os",
-	"path",
-	"perf_hooks",
-	"process",
-	"punycode",
-	"querystring",
-	"readline",
-	"repl",
-	"stream",
-	"string_decoder",
-	"sys",
-	"timers",
-	"tls",
-	"trace_events",
-	"tty",
-	"url",
-	"util",
-	"v8",
-	"vm",
-	"wasi",
-	"worker_threads",
-	"zlib"
-]);
-const PLATFORM_SUFFIXES = [
-	".web",
-	".react-native",
-	".native",
-	".ios",
-	".android",
-	".desktop",
-	".windows",
-	".macos",
-	".any",
-	".react-server",
-	".server",
-	".client"
-];
-const REACT_NATIVE_PLATFORM_EXTENSIONS = [
-	".web.ts",
-	".web.tsx",
-	".web.js",
-	".web.jsx",
-	".native.ts",
-	".native.tsx",
-	".native.js",
-	".native.jsx",
-	".ios.ts",
-	".ios.tsx",
-	".ios.js",
-	".ios.jsx",
-	".android.ts",
-	".android.tsx",
-	".android.js",
-	".android.jsx"
-];
-const RESOLVER_EXTENSIONS = [
-	...DEFAULT_EXTENSIONS,
-	".d.ts",
-	".d.mts",
-	".d.cts",
-	".json",
-	".node",
-	".css",
-	".scss",
-	".less",
-	".svg",
-	".png",
-	".jpg",
-	".graphql",
-	".gql"
-];
-const SEMANTIC_MAX_PROGRAM_FILES = 5e3;
-const MAX_PARSE_FILE_SIZE_BYTES = 2e6;
-const MAX_ANALYSIS_ERRORS = 5e3;
-const MAX_ERROR_DETAIL_LENGTH = 1e3;
-const BINARY_DETECTION_SAMPLE_BYTES = 2048;
-const MINIFIED_DETECTION_MIN_BYTES = 5e3;
-/**
-* Numeric literals below 1000 are dominated by indices, counters, small
-* ranges, ports, percentages, and array sizes that coincide by accident
-* (every `MAX_RETRIES = 3` is not a duplicate of every `LIMIT = 3`).
-* 1000 admits real shared constants (timeouts in ms, byte sizes, polling
-* intervals) without producing the noise floor that smaller magnitudes do.
-* NOTE: even at 1000, the rule still produces medium-confidence false
-* positives when constants share a value coincidentally with different
-* names (e.g. `STEP_DELAY_MS` vs `MINIMUM_TOKENS`); the report explicitly
-* downgrades those to `confidence: "medium"`.
-*/
-const MIN_NUMERIC_LITERAL_MAGNITUDE_FOR_DUPLICATE = 1e3;
-const DEFAULT_SEMANTIC_DECORATOR_ALLOWLIST = [
-	"Component",
-	"Injectable",
-	"NgModule",
-	"Pipe",
-	"Directive",
-	"Controller",
-	"Module",
-	"Resolver",
-	"Query",
-	"Mutation",
-	"Get",
-	"Post",
-	"Put",
-	"Patch",
-	"Delete",
-	"Head",
-	"Options",
-	"All",
-	"Sse",
-	"WebSocketGateway",
-	"SubscribeMessage"
-];
-const DEFAULT_SEMANTIC_TSCONFIG_NAMES = [
-	"tsconfig.json",
-	"tsconfig.app.json",
-	"tsconfig.build.json",
-	"tsconfig.src.json",
-	"jsconfig.json"
-];
-const GIT_CHECK_IGNORE_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
-
-//#endregion
 //#region src/errors.ts
 const truncateDetail = (text) => {
 	if (text.length <= 1e3) return text;
-	return `${text.slice(0, MAX_ERROR_DETAIL_LENGTH)}… [truncated ${text.length - MAX_ERROR_DETAIL_LENGTH} chars]`;
+	return `${text.slice(0, require_constants.MAX_ERROR_DETAIL_LENGTH)}… [truncated ${text.length - require_constants.MAX_ERROR_DETAIL_LENGTH} chars]`;
 };
 const describeUnknownError = (caughtValue) => {
 	let rawText;
@@ -1716,7 +1410,7 @@ const stripByteOrderMark = (sourceText) => {
 	return sourceText;
 };
 const looksLikeBinaryContent = (sourceText) => {
-	const sampleLength = Math.min(sourceText.length, BINARY_DETECTION_SAMPLE_BYTES);
+	const sampleLength = Math.min(sourceText.length, require_constants.BINARY_DETECTION_SAMPLE_BYTES);
 	let nullByteCount = 0;
 	for (let scanIndex = 0; scanIndex < sampleLength; scanIndex++) {
 		if (sourceText.charCodeAt(scanIndex) === 0) nullByteCount++;
@@ -1745,7 +1439,7 @@ const safeReadSourceFile = (filePath, errors) => {
 		if (stats.size > 2e6) {
 			errors.push(new FileReadError({
 				code: "file-too-large",
-				message: `file size ${stats.size}B exceeds MAX_PARSE_FILE_SIZE_BYTES (${MAX_PARSE_FILE_SIZE_BYTES})`,
+				message: `file size ${stats.size}B exceeds MAX_PARSE_FILE_SIZE_BYTES (${require_constants.MAX_PARSE_FILE_SIZE_BYTES})`,
 				path: filePath
 			}));
 			return;
@@ -2644,13 +2338,7 @@ const resolveWorkspaces = (rootDir) => {
 	};
 };
 const IMPLICIT_SUB_PROJECT_SEARCH_DEPTH = 3;
-const STANDALONE_PROJECT_LOCKFILES = [
-	"package-lock.json",
-	"yarn.lock",
-	"pnpm-lock.yaml",
-	"bun.lockb"
-];
-const isStandaloneProject = (directory) => STANDALONE_PROJECT_LOCKFILES.some((lockfile) => (0, node_fs.existsSync)((0, node_path.join)(directory, lockfile)));
+const isStandaloneProject = (directory) => require_constants.STANDALONE_PROJECT_LOCKFILES.some((lockfile) => (0, node_fs.existsSync)((0, node_path.join)(directory, lockfile)));
 const discoverImplicitSubProjects = (rootDir, alreadyDiscoveredDirectories) => {
 	const knownDirectories = new Set(alreadyDiscoveredDirectories);
 	const hasDeclaredWorkspaces = alreadyDiscoveredDirectories.length > 0;
@@ -3211,7 +2899,7 @@ const NESTED_EXPO_CONFIG_FILE_GLOBS = [
 	"**/app.json"
 ];
 const EXPO_REACT_NATIVE_DEPENDENCIES = new Set(["expo", "react-native"]);
-const EXPO_PLUGIN_RESOLVABLE_EXTENSIONS = SOURCE_EXTENSIONS$3.map((sourceExtension) => `.${sourceExtension}`);
+const EXPO_PLUGIN_RESOLVABLE_EXTENSIONS = require_constants.SOURCE_EXTENSIONS.map((sourceExtension) => `.${sourceExtension}`);
 const isRecord = (value) => typeof value === "object" && value !== null;
 const isExpoOrReactNativeWorkspace = (dependencies) => [...EXPO_REACT_NATIVE_DEPENDENCIES].some((dependencyName) => dependencyName in dependencies);
 const isLocalExpoPluginPath = (value) => (value.startsWith("./") || value.startsWith("../")) && !value.includes("*") && !value.includes("?");
@@ -3476,21 +3164,6 @@ const resolveWithIndexPrefix = (stemPath, directory) => {
 
 //#endregion
 //#region src/utils/find-monorepo-root.ts
-const MONOREPO_ROOT_MARKERS = [
-	"pnpm-workspace.yaml",
-	"pnpm-workspace.yml",
-	"lerna.json",
-	"nx.json",
-	"turbo.json",
-	"rush.json"
-];
-const LOCKFILE_MARKERS = [
-	"pnpm-lock.yaml",
-	"yarn.lock",
-	"package-lock.json",
-	"bun.lockb",
-	"bun.lock"
-];
 const MAX_MONOREPO_WALK_DEPTH = 5;
 const findMonorepoRoot = (rootDir) => {
 	let currentDirectory = (0, node_path.resolve)(rootDir);
@@ -3501,16 +3174,16 @@ const findMonorepoRoot = (rootDir) => {
 		currentDirectory = parentDirectory;
 		walkedDepth++;
 		if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, ".git"))) {
-			for (const marker of MONOREPO_ROOT_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, marker))) return currentDirectory;
+			for (const marker of require_constants.MONOREPO_ROOT_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, marker))) return currentDirectory;
 			const packageJsonPath = (0, node_path.join)(currentDirectory, "package.json");
 			if ((0, node_fs.existsSync)(packageJsonPath)) try {
 				const content = (0, node_fs.readFileSync)(packageJsonPath, "utf-8");
 				if (JSON.parse(content).workspaces) return currentDirectory;
 			} catch {}
-			for (const lockfile of LOCKFILE_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, lockfile))) return currentDirectory;
+			for (const lockfile of require_constants.LOCKFILE_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, lockfile))) return currentDirectory;
 			return;
 		}
-		for (const marker of MONOREPO_ROOT_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, marker))) return currentDirectory;
+		for (const marker of require_constants.MONOREPO_ROOT_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, marker))) return currentDirectory;
 		const packageJsonPath = (0, node_path.join)(currentDirectory, "package.json");
 		if ((0, node_fs.existsSync)(packageJsonPath)) try {
 			const content = (0, node_fs.readFileSync)(packageJsonPath, "utf-8");
@@ -3518,7 +3191,7 @@ const findMonorepoRoot = (rootDir) => {
 		} catch {
 			continue;
 		}
-		for (const lockfile of LOCKFILE_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, lockfile))) return currentDirectory;
+		for (const lockfile of require_constants.LOCKFILE_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, lockfile))) return currentDirectory;
 	}
 };
 
@@ -3742,9 +3415,9 @@ const isPlatformBuiltinOrVirtualSpecifier = (specifier) => {
 	if (specifier === "std" || specifier.startsWith("std/")) return true;
 	const stripped = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
 	const slashIndex = stripped.indexOf("/");
-	if (slashIndex === -1) return BUILTIN_MODULES.has(stripped);
+	if (slashIndex === -1) return require_constants.BUILTIN_MODULES.has(stripped);
 	const baseName = stripped.slice(0, slashIndex);
-	if (!BUILTIN_MODULES.has(baseName)) return false;
+	if (!require_constants.BUILTIN_MODULES.has(baseName)) return false;
 	return BUILTIN_SUBPATH_NODE_MODULES.has(baseName);
 };
 
@@ -3798,7 +3471,7 @@ const existsAsFile = (filePath) => {
 };
 const trySourceFallback = (resolvedPath) => {
 	const segments = resolvedPath.split(node_path.sep);
-	const isOutputDirectory = (segment) => OUTPUT_DIRECTORIES.some((outputDirectory) => segment === outputDirectory || segment.startsWith(`${outputDirectory}-`));
+	const isOutputDirectory = (segment) => require_constants.OUTPUT_DIRECTORIES.some((outputDirectory) => segment === outputDirectory || segment.startsWith(`${outputDirectory}-`));
 	let lastOutputPosition = -1;
 	for (let index = segments.length - 1; index >= 0; index--) if (isOutputDirectory(segments[index])) {
 		lastOutputPosition = index;
@@ -3812,18 +3485,18 @@ const trySourceFallback = (resolvedPath) => {
 	if (!suffix) return void 0;
 	const fileExtension = (0, node_path.extname)((0, node_path.basename)(suffix));
 	const stemmedSuffix = fileExtension ? suffix.slice(0, suffix.length - fileExtension.length) : suffix;
-	for (const sourceExtension of SOURCE_EXTENSIONS$3) {
+	for (const sourceExtension of require_constants.SOURCE_EXTENSIONS) {
 		const sourceCandidate = (0, node_path.join)(prefix, "src", `${stemmedSuffix}.${sourceExtension}`);
 		if (existsAsFile(sourceCandidate)) return sourceCandidate;
 	}
 };
 const resolvePathWithExtensionFallback = (candidatePath) => {
 	if (existsAsFile(candidatePath)) return candidatePath;
-	for (const extension of RESOLVER_EXTENSIONS) {
+	for (const extension of require_constants.RESOLVER_EXTENSIONS) {
 		const withExtension = candidatePath + extension;
 		if (existsAsFile(withExtension)) return withExtension;
 	}
-	for (const extension of RESOLVER_EXTENSIONS) {
+	for (const extension of require_constants.RESOLVER_EXTENSIONS) {
 		const indexCandidate = (0, node_path.join)(candidatePath, `index${extension}`);
 		if (existsAsFile(indexCandidate)) return indexCandidate;
 	}
@@ -3831,13 +3504,13 @@ const resolvePathWithExtensionFallback = (candidatePath) => {
 };
 const resolveAliasTarget = (target) => {
 	if (existsAsFile(target)) return target;
-	for (const extension of RESOLVER_EXTENSIONS) if (cachedExistsSync(target + extension)) return target + extension;
+	for (const extension of require_constants.RESOLVER_EXTENSIONS) if (cachedExistsSync(target + extension)) return target + extension;
 	const sourceTarget = target.replace(/\.[cm]?js$/, "");
 	if (sourceTarget !== target) {
-		for (const extension of RESOLVER_EXTENSIONS) if (cachedExistsSync(sourceTarget + extension)) return sourceTarget + extension;
+		for (const extension of require_constants.RESOLVER_EXTENSIONS) if (cachedExistsSync(sourceTarget + extension)) return sourceTarget + extension;
 	}
 	const indexCandidate = (0, node_path.join)(target, "index");
-	for (const extension of RESOLVER_EXTENSIONS) if (cachedExistsSync(indexCandidate + extension)) return indexCandidate + extension;
+	for (const extension of require_constants.RESOLVER_EXTENSIONS) if (cachedExistsSync(indexCandidate + extension)) return indexCandidate + extension;
 };
 const pathMappingSpecificity = (mapping) => mapping.isWildcard ? mapping.prefix.length + mapping.suffix.length : Number.MAX_SAFE_INTEGER;
 const compilePathMappings = (entries) => {
@@ -3880,7 +3553,7 @@ const COMMON_RESOLVER_OPTIONS = {
 		"node",
 		"default"
 	],
-	extensions: RESOLVER_EXTENSIONS,
+	extensions: require_constants.RESOLVER_EXTENSIONS,
 	mainFields: [
 		"module",
 		"main",
@@ -4176,7 +3849,7 @@ const resolveWorkspaceSubpath = (workspaceDirectory, subpath) => {
 		if (subpath && !resolvedEntryPath) {
 			const subpathCandidates = [(0, node_path.resolve)(workspaceDirectory, subpath), (0, node_path.resolve)(workspaceDirectory, "src", subpath)];
 			for (const directSubpath of subpathCandidates) {
-				for (const candidateExtension of RESOLVER_EXTENSIONS) {
+				for (const candidateExtension of require_constants.RESOLVER_EXTENSIONS) {
 					const candidate = directSubpath + candidateExtension;
 					if (cachedExistsSync(candidate)) {
 						resolvedEntryPath = candidate;
@@ -4184,7 +3857,7 @@ const resolveWorkspaceSubpath = (workspaceDirectory, subpath) => {
 					}
 				}
 				if (resolvedEntryPath) break;
-				for (const candidateExtension of RESOLVER_EXTENSIONS) {
+				for (const candidateExtension of require_constants.RESOLVER_EXTENSIONS) {
 					const indexCandidate = (0, node_path.join)(directSubpath, `index${candidateExtension}`);
 					if (cachedExistsSync(indexCandidate)) {
 						resolvedEntryPath = indexCandidate;
@@ -4214,7 +3887,7 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 	const resolverCache = /* @__PURE__ */ new Map();
 	const resolveResultCache = /* @__PURE__ */ new Map();
 	const failedTsconfigPaths = /* @__PURE__ */ new Set();
-	const resolverExtensions = options.hasReactNative ? [...REACT_NATIVE_PLATFORM_EXTENSIONS, ...RESOLVER_EXTENSIONS] : RESOLVER_EXTENSIONS;
+	const resolverExtensions = options.hasReactNative ? [...require_constants.REACT_NATIVE_PLATFORM_EXTENSIONS, ...require_constants.RESOLVER_EXTENSIONS] : require_constants.RESOLVER_EXTENSIONS;
 	const resolverOptions = {
 		...COMMON_RESOLVER_OPTIONS,
 		extensions: resolverExtensions
@@ -4603,7 +4276,7 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 				const baseUrlDirectory = getBaseUrlDirectory(tsconfigFile);
 				if (baseUrlDirectory) {
 					const baseUrlCandidate = (0, node_path.resolve)(baseUrlDirectory, cleanedSpecifier);
-					for (const candidateExtension of RESOLVER_EXTENSIONS) {
+					for (const candidateExtension of require_constants.RESOLVER_EXTENSIONS) {
 						const fullCandidate = baseUrlCandidate + candidateExtension;
 						if (cachedExistsSync(fullCandidate)) {
 							const resolvedResult = {
@@ -4616,7 +4289,7 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 						}
 					}
 					const indexCandidate = (0, node_path.join)(baseUrlCandidate, "index");
-					for (const candidateExtension of RESOLVER_EXTENSIONS) {
+					for (const candidateExtension of require_constants.RESOLVER_EXTENSIONS) {
 						const fullCandidate = indexCandidate + candidateExtension;
 						if (cachedExistsSync(fullCandidate)) {
 							const resolvedResult = {
@@ -4792,9 +4465,9 @@ const extractSiblingWorkspaceImportEntries = (absoluteRoot) => {
 //#endregion
 //#region src/collect/entries.ts
 const collectSourceFiles = async (config) => {
-	const extensions = config.includeExtensions.length > 0 ? config.includeExtensions : DEFAULT_EXTENSIONS;
+	const extensions = config.includeExtensions.length > 0 ? config.includeExtensions : require_constants.DEFAULT_EXTENSIONS;
 	const extensionGlob = extensions.length === 1 ? `**/*${extensions[0]}` : `**/*{${extensions.join(",")}}`;
-	const ignorePatterns = [...DEFAULT_EXCLUSIONS, ...config.ignorePatterns].map(toPosixPath);
+	const ignorePatterns = [...require_constants.DEFAULT_EXCLUSIONS, ...config.ignorePatterns].map(toPosixPath);
 	const absoluteRoot = (0, node_path.resolve)(config.rootDir);
 	const mainFiles = await (0, fast_glob.default)(extensionGlob, {
 		cwd: absoluteRoot,
@@ -4803,7 +4476,7 @@ const collectSourceFiles = async (config) => {
 		dot: false,
 		onlyFiles: true
 	});
-	const allowedHiddenGlobs = HIDDEN_DIRECTORY_ALLOWLIST.flatMap((directory) => [`${directory}/**/*{${extensions.join(",")}}`, `**/${directory}/**/*{${extensions.join(",")}}`]);
+	const allowedHiddenGlobs = require_constants.HIDDEN_DIRECTORY_ALLOWLIST.flatMap((directory) => [`${directory}/**/*{${extensions.join(",")}}`, `**/${directory}/**/*{${extensions.join(",")}}`]);
 	const hiddenFiles = allowedHiddenGlobs.length > 0 ? await (0, fast_glob.default)(allowedHiddenGlobs, {
 		cwd: absoluteRoot,
 		absolute: true,
@@ -5374,7 +5047,7 @@ const extractScriptEntries = (directory) => {
 		const scripts = JSON.parse(content).scripts;
 		if (scripts && typeof scripts === "object") for (const scriptCommand of Object.values(scripts)) {
 			if (typeof scriptCommand !== "string") continue;
-			const match = scriptCommand.match(SCRIPT_FILE_PATTERN);
+			const match = scriptCommand.match(require_constants.SCRIPT_FILE_PATTERN);
 			if (match?.[1]) {
 				const scriptFilePath = (0, node_path.resolve)(directory, match[1]);
 				if ((0, node_fs.existsSync)(scriptFilePath)) entries.push(scriptFilePath);
@@ -5383,14 +5056,14 @@ const extractScriptEntries = (directory) => {
 					if (sourcePath) entries.push(sourcePath);
 				}
 			} else {
-				const extensionlessMatch = scriptCommand.match(SCRIPT_EXTENSIONLESS_FILE_PATTERN);
+				const extensionlessMatch = scriptCommand.match(require_constants.SCRIPT_EXTENSIONLESS_FILE_PATTERN);
 				if (extensionlessMatch?.[1]) {
 					const extensionlessPath = extensionlessMatch[1];
 					const resolved = resolveExtensionlessScriptPath((0, node_path.resolve)(directory, extensionlessPath));
 					if (resolved) entries.push(resolved);
 				}
 			}
-			const configMatch = scriptCommand.match(SCRIPT_CONFIG_FILE_PATTERN);
+			const configMatch = scriptCommand.match(require_constants.SCRIPT_CONFIG_FILE_PATTERN);
 			if (configMatch?.[1]) {
 				const configFilePath = (0, node_path.resolve)(directory, configMatch[1]);
 				if ((0, node_fs.existsSync)(configFilePath)) entries.push(configFilePath);
@@ -5402,7 +5075,7 @@ const extractScriptEntries = (directory) => {
 			entries.push(...extractScriptFileArguments(scriptCommand, directory));
 		}
 	} catch {}
-	const scriptDirectoryFiles = fast_glob.default.sync(SCRIPT_ENTRY_PATTERNS, {
+	const scriptDirectoryFiles = fast_glob.default.sync(require_constants.SCRIPT_ENTRY_PATTERNS, {
 		cwd: directory,
 		absolute: true,
 		onlyFiles: true,
@@ -5458,12 +5131,12 @@ const extractCiWorkflowEntries = (rootDir) => {
 	for (const workflowFile of workflowFiles) try {
 		const runCommands = extractCiRunCommands((0, node_fs.readFileSync)(workflowFile, "utf-8"));
 		for (const command of runCommands) {
-			const scriptMatch = command.match(SCRIPT_FILE_PATTERN);
+			const scriptMatch = command.match(require_constants.SCRIPT_FILE_PATTERN);
 			if (scriptMatch?.[1]) {
 				const scriptFilePath = (0, node_path.resolve)(rootDir, scriptMatch[1]);
 				if ((0, node_fs.existsSync)(scriptFilePath)) entries.push(scriptFilePath);
 			}
-			const configMatch = command.match(SCRIPT_CONFIG_FILE_PATTERN);
+			const configMatch = command.match(require_constants.SCRIPT_CONFIG_FILE_PATTERN);
 			if (configMatch?.[1]) {
 				const configFilePath = (0, node_path.resolve)(rootDir, configMatch[1]);
 				if ((0, node_fs.existsSync)(configFilePath)) entries.push(configFilePath);
@@ -6109,7 +5782,7 @@ const extractTestSetupFiles = (directory) => {
 	} catch {}
 	return entries;
 };
-const IMPORTABLE_EXTENSION_SET = new Set(SOURCE_EXTENSIONS$3.map((extension) => `.${extension}`));
+const IMPORTABLE_EXTENSION_SET = new Set(require_constants.SOURCE_EXTENSIONS.map((extension) => `.${extension}`));
 const isImportableSourceFile = (filePath) => IMPORTABLE_EXTENSION_SET.has(filePath.slice(filePath.lastIndexOf(".")));
 const expandWildcardExportPattern = (pattern, rootDir) => {
 	const normalized = pattern.startsWith("./") ? pattern.slice(2) : pattern;
@@ -7256,6 +6929,18 @@ const resolveAvailableConcurrency = () => {
 	return clampParseConcurrency(available);
 };
 
+//#endregion
+//#region src/collect/launch-worker.ts
+/**
+* Launches a worker module that sits next to `fromModuleUrl`: the TypeScript
+* source (via tsx) when the caller itself runs from source — tests and direct
+* `tsx` execution — and the built `.mjs` sibling when running from dist.
+*/
+const launchSiblingWorker = (fromModuleUrl, workerBaseName) => {
+	const isTypeScriptSource = fromModuleUrl.endsWith(".ts");
+	return new node_worker_threads.Worker((0, node_url.fileURLToPath)(new URL(isTypeScriptSource ? `./${workerBaseName}.ts` : `./${workerBaseName}.mjs`, fromModuleUrl)), { ...isTypeScriptSource ? { execArgv: ["--import", "tsx"] } : {} });
+};
+
 //#endregion
 //#region src/collect/parallel-parse.ts
 const deserializeErrors = (serializedErrors) => serializedErrors.map((errorJson) => new DeslopError({
@@ -7282,14 +6967,6 @@ const deserializeParsedSource = (serialized) => ({
 	duplicateConstantCandidates: serialized.duplicateConstantCandidates,
 	errors: deserializeErrors(serialized.errors)
 });
-const resolveWorkerPath = () => {
-	const currentUrl = require("url").pathToFileURL(__filename).href;
-	if (currentUrl.endsWith(".ts")) return (0, node_url.fileURLToPath)(new URL("./parse-worker.ts", currentUrl));
-	return (0, node_url.fileURLToPath)(new URL("./parse-worker.mjs", currentUrl));
-};
-const createWorker = (workerPath) => {
-	return new node_worker_threads.Worker(workerPath, { ...workerPath.endsWith(".ts") ? { execArgv: ["--import", "tsx"] } : {} });
-};
 const waitForReady = (worker) => new Promise((resolve, reject) => {
 	const onMessage = (message) => {
 		if (message.type === "ready") {
@@ -7307,11 +6984,10 @@ const waitForReady = (worker) => new Promise((resolve, reject) => {
 	worker.on("error", onError);
 });
 const parseFilesWithWorkerPool = async (files, workerCount) => {
-	const workerPath = resolveWorkerPath();
 	const results = new Array(files.length);
 	const workers = [];
 	try {
-		for (let workerIndex = 0; workerIndex < workerCount; workerIndex++) workers.push(createWorker(workerPath));
+		for (let workerIndex = 0; workerIndex < workerCount; workerIndex++) workers.push(launchSiblingWorker(require("url").pathToFileURL(__filename).href, "parse-worker"));
 		await Promise.all(workers.map(waitForReady));
 	} catch {
 		for (const worker of workers) worker.terminate();
@@ -7397,7 +7073,7 @@ const isConfigFile = (filePath) => {
 	if (fileName.startsWith(".") && !fileName.startsWith("..")) {
 		if (fileName.toLowerCase().includes("rc.")) return true;
 	}
-	return KNOWN_CONFIG_PREFIXES.some((prefix) => fileName.startsWith(prefix));
+	return require_constants.KNOWN_CONFIG_PREFIXES.some((prefix) => fileName.startsWith(prefix));
 };
 
 //#endregion
@@ -7524,7 +7200,7 @@ const PLATFORM_DIRECTORY_NAMES = new Set([
 	"macos"
 ]);
 const stripPlatformSuffix = (filePath) => {
-	for (const suffix of PLATFORM_SUFFIXES) {
+	for (const suffix of require_constants.PLATFORM_SUFFIXES) {
 		const extensionIndex = filePath.lastIndexOf(".");
 		if (extensionIndex === -1) continue;
 		const withoutExtension = filePath.slice(0, extensionIndex);
@@ -7831,10 +7507,16 @@ const detectDeadExports = (graph, config) => {
 const buildUsageMap = (graph) => {
 	const usedExportKeys = /* @__PURE__ */ new Set();
 	const sourceToTargetMap = buildSourceToTargetsMap(graph);
+	const reExportEdgesBySource = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		if (!edge.isReExportEdge) continue;
+		const existingEdges = reExportEdgesBySource.get(edge.source);
+		if (existingEdges) existingEdges.push(edge);
+		else reExportEdgesBySource.set(edge.source, [edge]);
+	}
 	for (const module of graph.modules) {
 		if (!module.isEntryPoint) continue;
-		for (const edge of graph.edges) {
-			if (edge.source !== module.fileId.index || !edge.isReExportEdge) continue;
+		for (const edge of reExportEdgesBySource.get(module.fileId.index) ?? []) {
 			const targetModule = graph.modules[edge.target];
 			if (!targetModule) continue;
 			if (edge.reExportedNames.includes("*")) markAllExportsUsedRecursive(targetModule, graph, sourceToTargetMap, usedExportKeys, /* @__PURE__ */ new Set());
@@ -8081,12 +7763,29 @@ const matchesPackageTokenReference = (command, packageName) => {
 
 //#endregion
 //#region src/report/packages.ts
-const discoverAllPackageJsonPaths = (rootDir) => {
+const globPackageFiles = (cwd, patterns, options, summaryCache) => summaryCache?.matchWalkedFiles({
+	cwd,
+	patterns,
+	...options
+}) ?? fast_glob.default.sync([...patterns], {
+	cwd,
+	absolute: true,
+	onlyFiles: true,
+	ignore: [...options.ignore],
+	deep: options.deep,
+	...options.dot === void 0 ? {} : { dot: options.dot }
+});
+const containsPackageName = (content, packageName) => content.includes(packageName);
+const matchPackageNamesInFile = (filePath, kind, names, matcher, summaryCache) => {
+	if (summaryCache !== void 0) return summaryCache.matchPackageNames(filePath, kind, names, matcher);
+	const content = (0, node_fs.readFileSync)(filePath, "utf-8");
+	const matchedNames = [];
+	for (const packageName of names) if (matcher(content, packageName)) matchedNames.push(packageName);
+	return matchedNames;
+};
+const discoverAllPackageJsonPaths = (rootDir, summaryCache) => {
 	const paths = [(0, node_path.join)(rootDir, "package.json")];
-	const workspacePackageJsons = fast_glob.default.sync("**/package.json", {
-		cwd: rootDir,
-		absolute: true,
-		onlyFiles: true,
+	const workspacePackageJsons = globPackageFiles(rootDir, ["**/package.json"], {
 		ignore: [
 			"**/node_modules/**",
 			"**/dist/**",
@@ -8094,11 +7793,11 @@ const discoverAllPackageJsonPaths = (rootDir) => {
 			"**/.git/**"
 		],
 		deep: 5
-	});
+	}, summaryCache);
 	for (const workspacePath of workspacePackageJsons) if (workspacePath !== paths[0] && !paths.includes(workspacePath)) paths.push(workspacePath);
 	return paths;
 };
-const detectStalePackages = (graph, config) => {
+const detectStalePackages = (graph, config, summaryCache) => {
 	const packageJsonPath = (0, node_path.resolve)(config.rootDir, "package.json");
 	let packageJson;
 	try {
@@ -8116,7 +7815,7 @@ const detectStalePackages = (graph, config) => {
 	const usedPackageNames = collectUsedPackages(graph);
 	const monorepoRoot = findMonorepoRoot(config.rootDir);
 	const nodeModulesSearchRoots = monorepoRoot && monorepoRoot !== config.rootDir ? [config.rootDir, monorepoRoot] : [config.rootDir];
-	const allPackageJsonPaths = discoverAllPackageJsonPaths(config.rootDir);
+	const allPackageJsonPaths = discoverAllPackageJsonPaths(config.rootDir, summaryCache);
 	if (monorepoRoot) {
 		const monorepoPackageJson = (0, node_path.join)(monorepoRoot, "package.json");
 		if (!allPackageJsonPaths.includes(monorepoPackageJson) && (0, node_fs.existsSync)(monorepoPackageJson)) allPackageJsonPaths.push(monorepoPackageJson);
@@ -8129,13 +7828,13 @@ const detectStalePackages = (graph, config) => {
 		const packageJsonConfigReferenced = collectPackageJsonConfigReferences(workspacePackageJsonPath, declaredNames);
 		for (const packageName of packageJsonConfigReferenced) usedPackageNames.add(packageName);
 	}
-	const nxProjectReferenced = collectNxProjectJsonReferences(config.rootDir, declaredNames, binToPackage);
+	const nxProjectReferenced = collectNxProjectJsonReferences(config.rootDir, declaredNames, binToPackage, summaryCache);
 	for (const packageName of nxProjectReferenced) usedPackageNames.add(packageName);
 	const configSearchRoots = monorepoRoot && monorepoRoot !== config.rootDir ? [config.rootDir, monorepoRoot] : [config.rootDir];
 	for (const configSearchRoot of configSearchRoots) {
-		const configReferenced = collectConfigReferencedPackages(configSearchRoot, graph, declaredNames);
+		const configReferenced = collectConfigReferencedPackages(configSearchRoot, graph, declaredNames, summaryCache);
 		for (const packageName of configReferenced) usedPackageNames.add(packageName);
-		const tsconfigReferenced = collectTsconfigReferencedPackages(configSearchRoot);
+		const tsconfigReferenced = collectTsconfigReferencedPackages(configSearchRoot, summaryCache);
 		for (const packageName of tsconfigReferenced) usedPackageNames.add(packageName);
 		const { packageNames: expoPluginPackageNames } = extractExpoConfigPluginEntries(configSearchRoot, {
 			...dependencies,
@@ -8187,7 +7886,7 @@ const detectStalePackages = (graph, config) => {
 		candidateUnused.add(dependencyName);
 	}
 	if (candidateUnused.size > 0) {
-		const sourceFileRescued = scanSourceFilesForPackageImports(config.rootDir, candidateUnused);
+		const sourceFileRescued = scanSourceFilesForPackageImports(config.rootDir, candidateUnused, summaryCache);
 		for (const packageName of sourceFileRescued) {
 			usedPackageNames.add(packageName);
 			candidateUnused.delete(packageName);
@@ -8355,35 +8054,26 @@ const CONFIG_FILE_GLOBS = [
 	".dumirc.js",
 	"dumi.config.{ts,js}"
 ];
-const collectConfigReferencedPackages = (rootDir, graph, declaredNames) => {
+const collectConfigReferencedPackages = (rootDir, graph, declaredNames, summaryCache) => {
 	const referenced = /* @__PURE__ */ new Set();
-	for (const module of graph.modules) {
-		if (!module.isConfigFile) continue;
+	const addMatchesFromFile = (filePath, kind, matcher) => {
 		try {
-			const content = (0, node_fs.readFileSync)(module.fileId.path, "utf-8");
-			for (const packageName of declaredNames) if (content.includes(packageName)) referenced.add(packageName);
+			for (const packageName of matchPackageNamesInFile(filePath, kind, declaredNames, matcher, summaryCache)) referenced.add(packageName);
 		} catch {
-			continue;
+			return;
 		}
+	};
+	for (const module of graph.modules) {
+		if (!module.isConfigFile) continue;
+		addMatchesFromFile(module.fileId.path, "substring", containsPackageName);
 	}
-	const configFiles = fast_glob.default.sync(CONFIG_FILE_GLOBS, {
-		cwd: rootDir,
-		absolute: true,
-		onlyFiles: true,
+	const configFiles = globPackageFiles(rootDir, CONFIG_FILE_GLOBS, {
 		ignore: ["**/node_modules/**"],
 		dot: true,
 		deep: 3
-	});
-	for (const configPath of configFiles) try {
-		const content = (0, node_fs.readFileSync)(configPath, "utf-8");
-		for (const packageName of declaredNames) if (content.includes(packageName)) referenced.add(packageName);
-	} catch {
-		continue;
-	}
-	const documentationFiles = fast_glob.default.sync(["**/*.{mdx,md}"], {
-		cwd: rootDir,
-		absolute: true,
-		onlyFiles: true,
+	}, summaryCache);
+	for (const configPath of configFiles) addMatchesFromFile(configPath, "substring", containsPackageName);
+	const documentationFiles = globPackageFiles(rootDir, ["**/*.{mdx,md}"], {
 		ignore: [
 			"**/node_modules/**",
 			"**/dist/**",
@@ -8391,13 +8081,8 @@ const collectConfigReferencedPackages = (rootDir, graph, declaredNames) => {
 			"**/CHANGELOG.md"
 		],
 		deep: 6
-	});
-	for (const documentationPath of documentationFiles) try {
-		const content = (0, node_fs.readFileSync)(documentationPath, "utf-8");
-		for (const packageName of declaredNames) if (matchesPackageImportReference(content, packageName)) referenced.add(packageName);
-	} catch {
-		continue;
-	}
+	}, summaryCache);
+	for (const documentationPath of documentationFiles) addMatchesFromFile(documentationPath, "importReference", matchesPackageImportReference);
 	return referenced;
 };
 const PACKAGE_JSON_CONFIG_SECTIONS = [
@@ -8468,19 +8153,16 @@ const collectPackageJsonConfigReferences = (packageJsonPath, declaredNames) => {
 	}
 	return referenced;
 };
-const collectNxProjectJsonReferences = (rootDir, declaredNames, binToPackage) => {
+const collectNxProjectJsonReferences = (rootDir, declaredNames, binToPackage, summaryCache) => {
 	const referenced = /* @__PURE__ */ new Set();
-	const projectJsonPaths = fast_glob.default.sync(["project.json", "**/project.json"], {
-		cwd: rootDir,
-		absolute: true,
-		onlyFiles: true,
+	const projectJsonPaths = globPackageFiles(rootDir, ["project.json", "**/project.json"], {
 		ignore: [
 			"**/node_modules/**",
 			"**/dist/**",
 			"**/build/**"
 		],
 		deep: 5
-	});
+	}, summaryCache);
 	for (const projectJsonPath of projectJsonPaths) try {
 		const content = (0, node_fs.readFileSync)(projectJsonPath, "utf-8");
 		const projectJson = JSON.parse(content);
@@ -8508,16 +8190,13 @@ const TSCONFIG_GLOBS = [
 	"**/tsconfig.json",
 	"**/tsconfig.*.json"
 ];
-const collectTsconfigReferencedPackages = (rootDir) => {
+const collectTsconfigReferencedPackages = (rootDir, summaryCache) => {
 	const referenced = /* @__PURE__ */ new Set();
-	const tsconfigFiles = fast_glob.default.sync(TSCONFIG_GLOBS, {
-		cwd: rootDir,
-		absolute: true,
-		onlyFiles: true,
+	const tsconfigFiles = globPackageFiles(rootDir, TSCONFIG_GLOBS, {
 		ignore: ["**/node_modules/**"],
 		dot: false,
 		deep: 4
-	});
+	}, summaryCache);
 	for (const tsconfigPath of tsconfigFiles) try {
 		const cleaned = (0, node_fs.readFileSync)(tsconfigPath, "utf-8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
 		const parsed = JSON.parse(cleaned);
@@ -8563,16 +8242,22 @@ const SOURCE_FILE_IGNORES = [
 	"**/*.min.js",
 	"**/*.d.ts"
 ];
-const scanSourceFilesForPackageImports = (rootDir, candidatePackages) => {
+const scanSourceFilesForPackageImports = (rootDir, candidatePackages, summaryCache) => {
 	const found = /* @__PURE__ */ new Set();
 	if (candidatePackages.size === 0) return found;
-	const sourceFiles = fast_glob.default.sync(SOURCE_FILE_GLOBS, {
-		cwd: rootDir,
-		absolute: true,
-		onlyFiles: true,
+	const sourceFiles = globPackageFiles(rootDir, SOURCE_FILE_GLOBS, {
 		ignore: SOURCE_FILE_IGNORES,
 		deep: 15
-	});
+	}, summaryCache);
+	if (summaryCache !== void 0) {
+		for (const filePath of sourceFiles) try {
+			for (const packageName of summaryCache.matchPackageNames(filePath, "importReference", candidatePackages, matchesPackageImportReference)) found.add(packageName);
+		} catch {
+			continue;
+		}
+		for (const packageName of found) candidatePackages.delete(packageName);
+		return found;
+	}
 	for (const filePath of sourceFiles) {
 		if (candidatePackages.size === 0) break;
 		try {
@@ -8641,7 +8326,7 @@ const ALWAYS_USED_PREFIXES = [
 ];
 const ALWAYS_USED_SUFFIXES = ["-loader"];
 const isAlwaysConsideredUsed = (dependencyName) => {
-	if (IMPLICIT_DEPENDENCIES.has(dependencyName)) return true;
+	if (require_constants.IMPLICIT_DEPENDENCIES.has(dependencyName)) return true;
 	if (ALWAYS_USED_PREFIXES.some((prefix) => dependencyName.startsWith(prefix))) return true;
 	if (ALWAYS_USED_SUFFIXES.some((suffix) => dependencyName.endsWith(suffix))) return true;
 	return false;
@@ -8809,13 +8494,13 @@ const isPlatformSpecificModulePath = (modulePath) => {
 	const extensionIndex = modulePath.lastIndexOf(".");
 	if (extensionIndex === -1) return false;
 	const withoutExtension = modulePath.slice(0, extensionIndex);
-	return PLATFORM_SUFFIXES.some((suffix) => withoutExtension.endsWith(suffix));
+	return require_constants.PLATFORM_SUFFIXES.some((suffix) => withoutExtension.endsWith(suffix));
 };
 const platformStrippedBasePath = (modulePath) => {
 	const extensionIndex = modulePath.lastIndexOf(".");
 	if (extensionIndex === -1) return modulePath;
 	const withoutExtension = modulePath.slice(0, extensionIndex);
-	for (const suffix of PLATFORM_SUFFIXES) if (withoutExtension.endsWith(suffix)) return withoutExtension.slice(0, -suffix.length) + modulePath.slice(extensionIndex);
+	for (const suffix of require_constants.PLATFORM_SUFFIXES) if (withoutExtension.endsWith(suffix)) return withoutExtension.slice(0, -suffix.length) + modulePath.slice(extensionIndex);
 	return modulePath;
 };
 const buildPlatformSiblingGroupSizes = (graph) => {
@@ -9855,7 +9540,7 @@ const tokenizeAst = (program) => {
 //#endregion
 //#region src/duplicate-blocks/index.ts
 const isBinaryFile = (sourceText) => {
-	const sampleEnd = Math.min(sourceText.length, BINARY_DETECTION_SAMPLE_BYTES);
+	const sampleEnd = Math.min(sourceText.length, require_constants.BINARY_DETECTION_SAMPLE_BYTES);
 	let nullByteCount = 0;
 	for (let charIndex = 0; charIndex < sampleEnd; charIndex++) if (sourceText.charCodeAt(charIndex) === 0) {
 		nullByteCount++;
@@ -11587,7 +11272,7 @@ const findNearestTsconfig = (rootDir, explicitPath) => {
 		if ((0, node_fs.existsSync)(absoluteExplicit)) return absoluteExplicit;
 		return;
 	}
-	for (const candidateName of DEFAULT_SEMANTIC_TSCONFIG_NAMES) {
+	for (const candidateName of require_constants.DEFAULT_SEMANTIC_TSCONFIG_NAMES) {
 		const candidatePath = (0, node_path.resolve)(rootDir, candidateName);
 		if ((0, node_fs.existsSync)(candidatePath)) return candidatePath;
 	}
@@ -11640,7 +11325,7 @@ const createSemanticContext = (rootDir, tsconfigPath) => {
 	}
 	if (parsedCommandLine.fileNames.length > 5e3) return {
 		ok: false,
-		failure: failureFor("too-many-files", `Project has ${parsedCommandLine.fileNames.length} files, exceeds SEMANTIC_MAX_PROGRAM_FILES=${SEMANTIC_MAX_PROGRAM_FILES}`, { rootDir: resolvedTsconfigPath })
+		failure: failureFor("too-many-files", `Project has ${parsedCommandLine.fileNames.length} files, exceeds SEMANTIC_MAX_PROGRAM_FILES=${require_constants.SEMANTIC_MAX_PROGRAM_FILES}`, { rootDir: resolvedTsconfigPath })
 	};
 	try {
 		const program = typescript.default.createProgram({
@@ -12542,7 +12227,7 @@ const safeReportDetector = (detectorName, detector, fallback, errorSink) => runS
 	module: "report",
 	contextDescription: "while building findings"
 });
-const generateReport = (graph, config) => {
+const generateReport = (graph, config, summaryCache) => {
 	const analysisStartTime = performance.now();
 	const errorSink = [];
 	for (const module of graph.modules) {
@@ -12554,7 +12239,7 @@ const generateReport = (graph, config) => {
 	}
 	const unusedFiles = safeReportDetector("detectOrphanFiles", () => detectOrphanFiles(graph), [], errorSink);
 	const unusedExports = safeReportDetector("detectDeadExports", () => detectDeadExports(graph, config), [], errorSink);
-	const unusedDependencies = safeReportDetector("detectStalePackages", () => detectStalePackages(graph, config), [], errorSink);
+	const unusedDependencies = safeReportDetector("detectStalePackages", () => detectStalePackages(graph, config, summaryCache), [], errorSink);
 	const circularDependencies = safeReportDetector("detectCycles", () => detectCycles(graph), [], errorSink);
 	const syntacticRedundantAliases = config.reportRedundancy ? [...safeReportDetector("detectRedundantAliases", () => detectRedundantAliases(graph), [], errorSink), ...safeReportDetector("detectUselessAliasedReExports", () => detectUselessAliasedReExports(graph), [], errorSink)] : [];
 	const duplicateExports = config.reportRedundancy ? safeReportDetector("detectDuplicateExports", () => detectDuplicateExports(graph), [], errorSink) : [];
@@ -12648,6 +12333,478 @@ const generateReport = (graph, config) => {
 	};
 };
 
+//#endregion
+//#region src/collect/entries-in-worker.ts
+/**
+* Runs `resolveEntries` on a dedicated worker thread so its ~90%-synchronous
+* fs work overlaps the main-thread analysis phases — the incremental-cache
+* warm path has no long parse `await` left to hide it behind. Entry content
+* reads stay live (fresh every run) exactly as inline. Worker infrastructure
+* failures fall back to the inline call (same result, just serialized); an
+* error thrown by `resolveEntries` itself rejects with the same message an
+* inline throw would, so the caller's fallback-to-empty-entries handling is
+* unchanged.
+*/
+const resolveEntriesInWorker = async (config) => {
+	let worker;
+	try {
+		worker = launchSiblingWorker(require("url").pathToFileURL(__filename).href, "entries-worker");
+	} catch {
+		return resolveEntries(config);
+	}
+	try {
+		const outcome = await new Promise((resolveOutcome) => {
+			worker.on("message", (message) => {
+				if (message.type === "ready") worker.postMessage({
+					type: "resolve-entries",
+					config
+				});
+				else if (message.type === "result") resolveOutcome({
+					kind: "result",
+					entries: message.entries
+				});
+				else if (message.type === "error") resolveOutcome({
+					kind: "analysis-error",
+					errorMessage: message.errorMessage
+				});
+			});
+			worker.on("error", () => resolveOutcome({ kind: "infra-failure" }));
+			worker.on("exit", () => resolveOutcome({ kind: "infra-failure" }));
+		});
+		if (outcome.kind === "result") return outcome.entries;
+		if (outcome.kind === "analysis-error") throw new Error(outcome.errorMessage);
+		return resolveEntries(config);
+	} finally {
+		worker.terminate();
+	}
+};
+
+//#endregion
+//#region src/summary-cache.ts
+const WALK_SKIP_DIRECTORY_NAMES = new Set(["node_modules", ".git"]);
+const MANIFEST_LIKE_FILENAMES = new Set(require_constants.ANALYZED_MANIFEST_FILENAMES);
+const isManifestLikeFileName = (fileName) => MANIFEST_LIKE_FILENAMES.has(fileName) || (fileName.startsWith("tsconfig") || fileName.startsWith("jsconfig")) && fileName.endsWith(".json");
+const isResolverConfigFileName = (fileName) => fileName.includes("webpack") || fileName.startsWith("vite.config.") || fileName.startsWith("vitest.config.") || fileName.startsWith("babel.config.") || fileName.startsWith(".babelrc") || fileName.startsWith("jest.config.");
+const sha1Hex = (text) => node_crypto.default.createHash("sha1").update(text).digest("hex");
+const sha1OfFileBytes = (filePath) => {
+	try {
+		return node_crypto.default.createHash("sha1").update((0, node_fs.readFileSync)(filePath)).digest("hex");
+	} catch {
+		return null;
+	}
+};
+const fileNameOfPosixPath = (posixPath) => posixPath.slice(posixPath.lastIndexOf("/") + 1);
+const deslopRequire = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+const resolveOwnPackageVersion = () => {
+	try {
+		const packageJson = deslopRequire("deslop-js/package.json");
+		return typeof packageJson?.version === "string" ? packageJson.version : "unknown";
+	} catch {
+		return "unknown";
+	}
+};
+const walkTreeStats = (rootDirectory) => {
+	const collected = /* @__PURE__ */ new Map();
+	const followedLinkTargets = /* @__PURE__ */ new Set();
+	const walk = (directory) => {
+		let entries;
+		try {
+			entries = (0, node_fs.readdirSync)(directory, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const entryPath = `${directory}/${entry.name}`;
+			if (entry.isDirectory()) {
+				if (!WALK_SKIP_DIRECTORY_NAMES.has(entry.name)) walk(entryPath);
+				continue;
+			}
+			if (entry.isSymbolicLink()) {
+				if (WALK_SKIP_DIRECTORY_NAMES.has(entry.name)) continue;
+				try {
+					const linkStat = (0, node_fs.statSync)(entryPath);
+					if (linkStat.isDirectory()) {
+						const linkTarget = (0, node_fs.realpathSync)(entryPath);
+						if (!followedLinkTargets.has(linkTarget)) {
+							followedLinkTargets.add(linkTarget);
+							walk(entryPath);
+						}
+					} else if (linkStat.isFile()) collected.set(entryPath, {
+						m: linkStat.mtimeMs,
+						s: linkStat.size
+					});
+				} catch {
+					continue;
+				}
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			try {
+				const fileStat = (0, node_fs.statSync)(entryPath);
+				collected.set(entryPath, {
+					m: fileStat.mtimeMs,
+					s: fileStat.size
+				});
+			} catch {
+				continue;
+			}
+		}
+	};
+	walk(toPosixPath((0, node_path.resolve)(rootDirectory)));
+	return collected;
+};
+const compileGlobAlternation = (patterns, matchDotNames) => {
+	const regexSources = [];
+	for (const pattern of patterns) {
+		const compiled = new minimatch.Minimatch(pattern, { dot: matchDotNames }).makeRe();
+		if (compiled === false) return null;
+		regexSources.push(compiled.source);
+	}
+	return regexSources.length === 0 ? null : new RegExp(regexSources.join("|"));
+};
+const countPathSegments = (relativePath) => {
+	let segmentCount = 1;
+	for (let charIndex = 0; charIndex < relativePath.length; charIndex++) if (relativePath.charCodeAt(charIndex) === 47) segmentCount++;
+	return segmentCount;
+};
+const contentFingerprintOf = (filePath, fileStat) => `${filePath}:${fileStat.s}:${sha1OfFileBytes(filePath) ?? `stat-${fileStat.m}`}`;
+const computeCollectHash = (walkedStats) => {
+	const fingerprintLines = [];
+	for (const [filePath, fileStat] of walkedStats) fingerprintLines.push(isManifestLikeFileName(fileNameOfPosixPath(filePath)) ? contentFingerprintOf(filePath, fileStat) : filePath);
+	fingerprintLines.sort();
+	return sha1Hex(fingerprintLines.join("\n"));
+};
+const computeResolutionHash = (collectHash, walkedStats) => {
+	const fingerprintLines = [];
+	for (const [filePath, fileStat] of walkedStats) if (isResolverConfigFileName(fileNameOfPosixPath(filePath))) fingerprintLines.push(contentFingerprintOf(filePath, fileStat));
+	fingerprintLines.sort();
+	return sha1Hex(`${collectHash}\n${fingerprintLines.join("\n")}`);
+};
+const computeScopeHash = (config) => sha1Hex(JSON.stringify({
+	deslopVersion: resolveOwnPackageVersion(),
+	rootDir: toPosixPath((0, node_path.resolve)(config.rootDir)),
+	entryPatterns: config.entryPatterns,
+	ignorePatterns: config.ignorePatterns,
+	includeExtensions: config.includeExtensions,
+	reportTypes: config.reportTypes,
+	includeEntryExports: config.includeEntryExports,
+	reportRedundancy: config.reportRedundancy,
+	tsConfigPath: config.tsConfigPath ?? null,
+	paths: config.paths ?? null
+}));
+const isRecordValue = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+const isOptionalArray = (value) => value === void 0 || Array.isArray(value);
+const emptyStore = (scopeHash) => ({
+	version: 2,
+	scopeHash,
+	fileList: null,
+	resolutions: null,
+	summaries: {},
+	packageFacts: {}
+});
+const readPersistedStore = (cachePath, scopeHash) => {
+	try {
+		const parsed = JSON.parse((0, node_fs.readFileSync)(cachePath, "utf-8"));
+		if (isRecordValue(parsed) && parsed.version === 2 && parsed.scopeHash === scopeHash && isRecordValue(parsed.summaries) && isRecordValue(parsed.packageFacts)) {
+			const persisted = parsed;
+			return {
+				version: 2,
+				scopeHash,
+				fileList: isRecordValue(persisted.fileList) ? persisted.fileList : null,
+				resolutions: isRecordValue(persisted.resolutions) && typeof persisted.resolutions.hash === "string" && isRecordValue(persisted.resolutions.entries) ? persisted.resolutions : null,
+				summaries: persisted.summaries,
+				packageFacts: persisted.packageFacts
+			};
+		}
+	} catch {}
+	return emptyStore(scopeHash);
+};
+const intersectLocalReferencesWithOwnExports = (parsed) => {
+	if (parsed.localIdentifierReferences.length === 0) return [];
+	const ownExportNames = new Set(parsed.exports.map((exportInfo) => exportInfo.name));
+	return parsed.localIdentifierReferences.filter((identifierName) => ownExportNames.has(identifierName));
+};
+const toPersistedArray = (values) => values.length > 0 ? values : void 0;
+const serializeParsedSource = (parsed, shouldPersistDryPatternFields) => ({
+	imports: toPersistedArray(parsed.imports),
+	exports: toPersistedArray(parsed.exports),
+	memberAccesses: toPersistedArray(parsed.memberAccesses),
+	wholeObjectUses: toPersistedArray(parsed.wholeObjectUses),
+	localIdentifierReferences: toPersistedArray(intersectLocalReferencesWithOwnExports(parsed)),
+	referencedFilenames: toPersistedArray(parsed.referencedFilenames),
+	...shouldPersistDryPatternFields ? {
+		redundantTypePatterns: toPersistedArray(parsed.redundantTypePatterns),
+		identityWrappers: toPersistedArray(parsed.identityWrappers),
+		typeDefinitionHashes: toPersistedArray(parsed.typeDefinitionHashes),
+		inlineTypeLiterals: toPersistedArray(parsed.inlineTypeLiterals),
+		simplifiableFunctions: toPersistedArray(parsed.simplifiableFunctions),
+		simplifiableExpressions: toPersistedArray(parsed.simplifiableExpressions),
+		duplicateConstantCandidates: toPersistedArray(parsed.duplicateConstantCandidates)
+	} : {},
+	errors: toPersistedArray(parsed.errors.map((deslopError) => deslopError.toJSON()))
+});
+const isPersistedErrorJson = (value) => isRecordValue(value) && typeof value.code === "string" && typeof value.module === "string" && typeof value.message === "string";
+const PERSISTED_SOURCE_ARRAY_FIELDS = [
+	"imports",
+	"exports",
+	"memberAccesses",
+	"wholeObjectUses",
+	"localIdentifierReferences",
+	"referencedFilenames",
+	"redundantTypePatterns",
+	"identityWrappers",
+	"typeDefinitionHashes",
+	"inlineTypeLiterals",
+	"simplifiableFunctions",
+	"simplifiableExpressions",
+	"duplicateConstantCandidates",
+	"errors"
+];
+const reviveParsedSource = (persisted) => {
+	if (!isRecordValue(persisted)) return null;
+	for (const fieldName of PERSISTED_SOURCE_ARRAY_FIELDS) if (!isOptionalArray(persisted[fieldName])) return null;
+	const source = persisted;
+	const persistedErrors = source.errors ?? [];
+	if (!persistedErrors.every(isPersistedErrorJson)) return null;
+	return {
+		imports: source.imports ?? [],
+		exports: source.exports ?? [],
+		memberAccesses: source.memberAccesses ?? [],
+		wholeObjectUses: source.wholeObjectUses ?? [],
+		localIdentifierReferences: source.localIdentifierReferences ?? [],
+		referencedFilenames: source.referencedFilenames ?? [],
+		redundantTypePatterns: source.redundantTypePatterns ?? [],
+		identityWrappers: source.identityWrappers ?? [],
+		typeDefinitionHashes: source.typeDefinitionHashes ?? [],
+		inlineTypeLiterals: source.inlineTypeLiterals ?? [],
+		simplifiableFunctions: source.simplifiableFunctions ?? [],
+		simplifiableExpressions: source.simplifiableExpressions ?? [],
+		duplicateConstantCandidates: source.duplicateConstantCandidates ?? [],
+		errors: persistedErrors.map((errorJson) => new DeslopError({
+			code: errorJson.code,
+			module: errorJson.module,
+			severity: errorJson.severity,
+			message: errorJson.message,
+			path: errorJson.path,
+			detail: errorJson.detail
+		}))
+	};
+};
+const atomicWriteFile = (filePath, contents) => {
+	try {
+		(0, node_fs.mkdirSync)((0, node_path.dirname)(filePath), { recursive: true });
+		const temporaryPath = `${filePath}.${process.pid}.tmp`;
+		(0, node_fs.writeFileSync)(temporaryPath, contents);
+		(0, node_fs.renameSync)(temporaryPath, filePath);
+	} catch {}
+};
+const createSummaryCache = (cachePath, config) => {
+	const scopeHash = computeScopeHash(config);
+	const store = readPersistedStore(cachePath, scopeHash);
+	const walkRoot = toPosixPath((0, node_path.resolve)(config.rootDir));
+	const walkedStats = walkTreeStats(config.rootDir);
+	const collectHash = computeCollectHash(walkedStats);
+	const resolutionHash = computeResolutionHash(collectHash, walkedStats);
+	const shouldPersistDryPatternFields = config.reportRedundancy;
+	if (store.resolutions === null || store.resolutions.hash !== resolutionHash) store.resolutions = {
+		hash: resolutionHash,
+		entries: {}
+	};
+	const resolutionEntries = store.resolutions.entries;
+	let isDirty = false;
+	const activeSummaryPaths = /* @__PURE__ */ new Set();
+	const activeResolutionKeys = /* @__PURE__ */ new Set();
+	const activeFactPaths = /* @__PURE__ */ new Set();
+	const sortedNameSetMemo = /* @__PURE__ */ new WeakMap();
+	const statOfLive = (filePath) => {
+		try {
+			const fileStat = (0, node_fs.statSync)(filePath);
+			return {
+				m: fileStat.mtimeMs,
+				s: fileStat.size
+			};
+		} catch {
+			return null;
+		}
+	};
+	const statOf = (filePath) => walkedStats.get(filePath) ?? statOfLive(filePath);
+	return {
+		lookupFileList: () => {
+			const cachedFileList = store.fileList;
+			if (cachedFileList === null || cachedFileList.hash !== collectHash || !isStringArray(cachedFileList.files)) return null;
+			return cachedFileList.files.map((filePath, fileIndex) => ({
+				index: fileIndex,
+				path: filePath
+			}));
+		},
+		storeFileList: (files) => {
+			store.fileList = {
+				hash: collectHash,
+				files: files.map((file) => file.path)
+			};
+			isDirty = true;
+		},
+		lookupSummary: (filePath) => {
+			const cachedSummary = store.summaries[filePath];
+			if (!isRecordValue(cachedSummary)) return null;
+			const fileStat = statOf(filePath);
+			if (!fileStat) return null;
+			if (fileStat.m !== cachedSummary.m || fileStat.s !== cachedSummary.s) {
+				if (fileStat.s !== cachedSummary.s || typeof cachedSummary.h !== "string") return null;
+				const contentHash = sha1OfFileBytes(filePath);
+				if (contentHash === null || contentHash !== cachedSummary.h) return null;
+				cachedSummary.m = fileStat.m;
+				cachedSummary.s = fileStat.s;
+				isDirty = true;
+			}
+			const revived = reviveParsedSource(cachedSummary.p);
+			if (revived === null) return null;
+			activeSummaryPaths.add(filePath);
+			return revived;
+		},
+		storeSummary: (filePath, parsed) => {
+			const walkStat = statOf(filePath);
+			if (!walkStat) return;
+			const contentHash = sha1OfFileBytes(filePath);
+			if (contentHash === null) return;
+			const liveStat = statOfLive(filePath);
+			if (liveStat === null || liveStat.m !== walkStat.m || liveStat.s !== walkStat.s) return;
+			store.summaries[filePath] = {
+				m: walkStat.m,
+				s: walkStat.s,
+				h: contentHash,
+				p: serializeParsedSource(parsed, shouldPersistDryPatternFields)
+			};
+			activeSummaryPaths.add(filePath);
+			isDirty = true;
+		},
+		lookupResolution: (specifier, fromFile) => {
+			const resolutionKey = `${(0, node_path.dirname)(fromFile)}::${specifier}`;
+			const cachedResolution = resolutionEntries[resolutionKey];
+			if (!isRecordValue(cachedResolution) || typeof cachedResolution.e !== "boolean") return null;
+			activeResolutionKeys.add(resolutionKey);
+			return {
+				resolvedPath: typeof cachedResolution.p === "string" ? cachedResolution.p : void 0,
+				isExternal: cachedResolution.e,
+				packageName: typeof cachedResolution.n === "string" ? cachedResolution.n : void 0
+			};
+		},
+		storeResolution: (specifier, fromFile, resolved) => {
+			const resolutionKey = `${(0, node_path.dirname)(fromFile)}::${specifier}`;
+			resolutionEntries[resolutionKey] = {
+				p: resolved.resolvedPath ?? null,
+				e: resolved.isExternal,
+				n: resolved.packageName ?? null
+			};
+			activeResolutionKeys.add(resolutionKey);
+			isDirty = true;
+		},
+		matchPackageNames: (filePath, kind, names, matcher) => {
+			let nameSet = sortedNameSetMemo.get(names);
+			if (nameSet === void 0) {
+				const sortedNames = [...names].sort();
+				nameSet = {
+					sortedNames,
+					hash: sha1Hex(sortedNames.join("\n"))
+				};
+				sortedNameSetMemo.set(names, nameSet);
+			}
+			activeFactPaths.add(filePath);
+			const fileStat = statOf(filePath);
+			const existingEntry = isRecordValue(store.packageFacts[filePath]) ? store.packageFacts[filePath] : null;
+			let validEntry = fileStat !== null && existingEntry !== null && existingEntry.m === fileStat.m && existingEntry.s === fileStat.s ? existingEntry : null;
+			const existingMatch = validEntry?.[kind];
+			if (isRecordValue(existingMatch) && existingMatch.h === nameSet.hash && isStringArray(existingMatch.matched)) return existingMatch.matched;
+			const content = (0, node_fs.readFileSync)(filePath, "utf-8");
+			const contentHash = sha1Hex(content);
+			if (validEntry === null && fileStat !== null && existingEntry?.h === contentHash) {
+				existingEntry.m = fileStat.m;
+				existingEntry.s = fileStat.s;
+				isDirty = true;
+				validEntry = existingEntry;
+				const repairedMatch = validEntry[kind];
+				if (isRecordValue(repairedMatch) && repairedMatch.h === nameSet.hash && isStringArray(repairedMatch.matched)) return repairedMatch.matched;
+			}
+			const matchedNames = nameSet.sortedNames.filter((packageName) => matcher(content, packageName));
+			if (fileStat !== null) {
+				const factEntry = validEntry ?? {
+					m: fileStat.m,
+					s: fileStat.s,
+					h: contentHash
+				};
+				factEntry[kind] = {
+					h: nameSet.hash,
+					matched: matchedNames
+				};
+				store.packageFacts[filePath] = factEntry;
+				isDirty = true;
+			}
+			return matchedNames;
+		},
+		matchWalkedFiles: (query) => {
+			if (toPosixPath((0, node_path.resolve)(query.cwd)) !== walkRoot) return null;
+			const positiveMatcher = compileGlobAlternation(query.patterns, query.dot === true);
+			if (positiveMatcher === null) return null;
+			const ignoreMatcher = query.ignore.length > 0 ? compileGlobAlternation(query.ignore, true) : null;
+			if (query.ignore.length > 0 && ignoreMatcher === null) return null;
+			const rootPrefixLength = walkRoot.length + 1;
+			const matchedPaths = [];
+			for (const filePath of walkedStats.keys()) {
+				const relativePath = filePath.slice(rootPrefixLength);
+				if (countPathSegments(relativePath) > query.deep) continue;
+				if (ignoreMatcher !== null && ignoreMatcher.test(relativePath)) continue;
+				if (positiveMatcher.test(relativePath)) matchedPaths.push(filePath);
+			}
+			return matchedPaths.sort();
+		},
+		save: () => {
+			if (!isDirty) return;
+			const compactedSummaries = {};
+			for (const filePath of activeSummaryPaths) {
+				const summaryEntry = store.summaries[filePath];
+				if (summaryEntry !== void 0) compactedSummaries[filePath] = summaryEntry;
+			}
+			const compactedFacts = {};
+			for (const filePath of activeFactPaths) {
+				const factEntry = store.packageFacts[filePath];
+				if (factEntry !== void 0) compactedFacts[filePath] = factEntry;
+			}
+			const compactedResolutions = {};
+			for (const resolutionKey of activeResolutionKeys) {
+				const resolutionEntry = resolutionEntries[resolutionKey];
+				if (resolutionEntry !== void 0) compactedResolutions[resolutionKey] = resolutionEntry;
+			}
+			const serialized = JSON.stringify({
+				version: 2,
+				scopeHash,
+				fileList: store.fileList,
+				resolutions: {
+					hash: resolutionHash,
+					entries: compactedResolutions
+				},
+				summaries: compactedSummaries,
+				packageFacts: compactedFacts
+			});
+			if (serialized.length > 268435456) return;
+			atomicWriteFile(cachePath, serialized);
+		}
+	};
+};
+/**
+* Loads the incremental cache configured at `config.incrementalCachePath`.
+* Returns `null` (analysis runs exactly as without a cache) when the path is
+* unset or anything about initialization fails.
+*/
+const loadSummaryCache = (config) => {
+	if (!config.incrementalCachePath) return null;
+	try {
+		return createSummaryCache(config.incrementalCachePath, config);
+	} catch {
+		return null;
+	}
+};
+
 //#endregion
 //#region src/utils/collect-git-ignored-paths.ts
 /**
@@ -12686,7 +12843,7 @@ const collectGitIgnoredPaths = (rootDirectory, candidatePaths) => {
 		cwd: rootDirectory,
 		input: candidatePaths.join("\0"),
 		encoding: "utf-8",
-		maxBuffer: GIT_CHECK_IGNORE_MAX_BUFFER_BYTES
+		maxBuffer: require_constants.GIT_CHECK_IGNORE_MAX_BUFFER_BYTES
 	});
 	if (result.error) {
 		const gitBinaryMissing = "code" in result.error && result.error.code === "ENOENT";
@@ -12802,7 +12959,7 @@ const fillSemanticConfig = (semanticOverrides) => {
 		reportRedundantVariableAliases: overrides.reportRedundantVariableAliases ?? true,
 		reportMisclassifiedDependencies: overrides.reportMisclassifiedDependencies ?? true,
 		reportRoundTripAliases: overrides.reportRoundTripAliases ?? true,
-		decoratorAllowlist: overrides.decoratorAllowlist ?? DEFAULT_SEMANTIC_DECORATOR_ALLOWLIST
+		decoratorAllowlist: overrides.decoratorAllowlist ?? require_constants.DEFAULT_SEMANTIC_DECORATOR_ALLOWLIST
 	};
 };
 const fillDuplicateBlocksConfig = (duplicateBlocksOverrides) => {
@@ -12837,11 +12994,12 @@ const fillComplexityConfig = (complexityOverrides) => {
 };
 const defineConfig = (options) => ({
 	rootDir: (0, node_path.resolve)(options.rootDir),
-	entryPatterns: options.entryPatterns ?? DEFAULT_ENTRY_GLOBS,
+	entryPatterns: options.entryPatterns ?? require_constants.DEFAULT_ENTRY_GLOBS,
 	ignorePatterns: options.ignorePatterns ?? [],
-	includeExtensions: options.includeExtensions ?? DEFAULT_EXTENSIONS,
+	includeExtensions: options.includeExtensions ?? require_constants.DEFAULT_EXTENSIONS,
 	tsConfigPath: options.tsConfigPath,
 	paths: options.paths,
+	incrementalCachePath: options.incrementalCachePath,
 	reportTypes: options.reportTypes ?? false,
 	includeEntryExports: options.includeEntryExports ?? false,
 	reportRedundancy: options.reportRedundancy ?? true,
@@ -12952,7 +13110,7 @@ const analyze = async (config) => {
 		}));
 	}
 	const absoluteRoot = (0, node_path.resolve)(config.rootDir);
-	const outputDirectoryExclusions = OUTPUT_DIRECTORIES.flatMap((outputDirectory) => [`${absoluteRoot}/${outputDirectory}/**`, `${absoluteRoot}/**/${outputDirectory}/**`]);
+	const outputDirectoryExclusions = require_constants.OUTPUT_DIRECTORIES.flatMap((outputDirectory) => [`${absoluteRoot}/${outputDirectory}/**`, `${absoluteRoot}/**/${outputDirectory}/**`]);
 	const allExclusionPatterns = [
 		...workspaceDiscovery.excludedDirectories.map((directory) => `${directory}/**`),
 		...frameworkIgnorePatterns,
@@ -12962,24 +13120,26 @@ const analyze = async (config) => {
 		...config,
 		ignorePatterns: [...config.ignorePatterns, ...allExclusionPatterns]
 	} : config;
+	const entriesPromise = (configWithExclusions.incrementalCachePath ? resolveEntriesInWorker(configWithExclusions) : resolveEntries(configWithExclusions)).catch((entriesError) => {
+		setupErrors.push(new WorkspaceError({
+			code: "workspace-discovery-failed",
+			message: "resolveEntries failed — defaulting to empty entry set",
+			path: config.rootDir,
+			detail: describeUnknownError(entriesError)
+		}));
+		return {
+			productionEntries: [],
+			testEntries: [],
+			alwaysUsedFiles: []
+		};
+	});
+	const summaryCache = loadSummaryCache(configWithExclusions);
 	let files;
-	let discoveredEntries;
-	try {
-		const [collectedFiles, resolvedEntries] = await Promise.all([collectSourceFiles(configWithExclusions), resolveEntries(configWithExclusions).catch((entriesError) => {
-			setupErrors.push(new WorkspaceError({
-				code: "workspace-discovery-failed",
-				message: "resolveEntries failed — defaulting to empty entry set",
-				path: config.rootDir,
-				detail: describeUnknownError(entriesError)
-			}));
-			return {
-				productionEntries: [],
-				testEntries: [],
-				alwaysUsedFiles: []
-			};
-		})]);
-		files = collectedFiles;
-		discoveredEntries = resolvedEntries;
+	const cachedFileList = summaryCache?.lookupFileList() ?? null;
+	if (cachedFileList !== null) files = cachedFileList;
+	else try {
+		files = await collectSourceFiles(configWithExclusions);
+		summaryCache?.storeFileList(files);
 	} catch (collectError) {
 		setupErrors.push(new WorkspaceError({
 			code: "workspace-discovery-failed",
@@ -12990,9 +13150,6 @@ const analyze = async (config) => {
 		}));
 		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
 	}
-	const productionEntrySet = new Set(discoveredEntries.productionEntries);
-	const testEntrySet = new Set(discoveredEntries.testEntries);
-	const alwaysUsedFileSet = new Set(discoveredEntries.alwaysUsedFiles);
 	const gitIgnoreResult = collectGitIgnoredPaths((0, node_path.resolve)(config.rootDir), files.map((file) => file.path));
 	const gitIgnoredFileSet = gitIgnoreResult.ignoredPaths;
 	if (gitIgnoreResult.gitUnavailable) setupErrors.push(new WorkspaceError({
@@ -13024,7 +13181,41 @@ const analyze = async (config) => {
 		}));
 		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
 	}
-	const parsedModules = await parseFilesInParallel(files);
+	const resolveModuleThroughCache = (specifier, fromFile) => {
+		if (summaryCache === null) return moduleResolver.resolveModule(specifier, fromFile);
+		const cachedResolution = summaryCache.lookupResolution(specifier, fromFile);
+		if (cachedResolution !== null) return cachedResolution;
+		const resolved = moduleResolver.resolveModule(specifier, fromFile);
+		summaryCache.storeResolution(specifier, fromFile, resolved);
+		return resolved;
+	};
+	let parsedModules;
+	let summaryMissCount = 0;
+	if (summaryCache === null) parsedModules = await parseFilesInParallel(files);
+	else {
+		parsedModules = new Array(files.length);
+		const missedFiles = [];
+		const missedPositions = [];
+		for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
+			const cachedSummary = summaryCache.lookupSummary(files[fileIndex].path);
+			if (cachedSummary !== null) {
+				parsedModules[fileIndex] = cachedSummary;
+				continue;
+			}
+			missedFiles.push(files[fileIndex]);
+			missedPositions.push(fileIndex);
+		}
+		summaryMissCount = missedFiles.length;
+		const parsedMissedModules = await parseFilesInParallel(missedFiles);
+		for (let missIndex = 0; missIndex < missedFiles.length; missIndex++) {
+			parsedModules[missedPositions[missIndex]] = parsedMissedModules[missIndex];
+			summaryCache.storeSummary(missedFiles[missIndex].path, parsedMissedModules[missIndex]);
+		}
+	}
+	const discoveredEntries = await entriesPromise;
+	const productionEntrySet = new Set(discoveredEntries.productionEntries);
+	const testEntrySet = new Set(discoveredEntries.testEntries);
+	const alwaysUsedFileSet = new Set(discoveredEntries.alwaysUsedFiles);
 	const graphInputs = [];
 	for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
 		const file = files[fileIndex];
@@ -13032,7 +13223,7 @@ const analyze = async (config) => {
 		const resolvedImportMap = /* @__PURE__ */ new Map();
 		const safeResolveImport = (specifier) => {
 			try {
-				return moduleResolver.resolveModule(specifier, file.path);
+				return resolveModuleThroughCache(specifier, file.path);
 			} catch (resolveError) {
 				setupErrors.push(new ResolverError({
 					severity: "warning",
@@ -13112,7 +13303,7 @@ const analyze = async (config) => {
 		for (const importInfo of parsedStyleModule.imports) {
 			let resolvedImport;
 			try {
-				resolvedImport = moduleResolver.resolveModule(importInfo.specifier, styleFilePath);
+				resolvedImport = resolveModuleThroughCache(importInfo.specifier, styleFilePath);
 			} catch (styleResolveError) {
 				setupErrors.push(new ResolverError({
 					severity: "warning",
@@ -13176,7 +13367,7 @@ const analyze = async (config) => {
 	}
 	let analysisResult;
 	try {
-		analysisResult = generateReport(moduleGraph, config);
+		analysisResult = generateReport(moduleGraph, config, summaryCache ?? void 0);
 	} catch (reportError) {
 		setupErrors.push(new DetectorError({
 			module: "report",
@@ -13186,6 +13377,11 @@ const analyze = async (config) => {
 		}));
 		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
 	}
+	summaryCache?.save();
+	if (summaryCache !== null) analysisResult.incrementalCacheStats = {
+		summaryHits: files.length - summaryMissCount,
+		summaryMisses: summaryMissCount
+	};
 	if (setupErrors.length > 0) analysisResult.analysisErrors = [...setupErrors, ...analysisResult.analysisErrors];
 	analysisResult.analysisTimeMs = performance.now() - pipelineStartTime;
 	return analysisResult;