deslop-js 0.6.2 → 0.7.0

package/dist/index.mjs

@@ -1,326 +1,19 @@
+import { A as STANDALONE_PROJECT_LOCKFILES, C as RESOLVER_EXTENSIONS, D as SCRIPT_FILE_PATTERN, E as SCRIPT_EXTENSIONLESS_FILE_PATTERN, O as SEMANTIC_MAX_PROGRAM_FILES, S as REACT_NATIVE_PLATFORM_EXTENSIONS, T as SCRIPT_ENTRY_PATTERNS, _ as MINIFIED_DETECTION_MIN_BYTES, a as DEFAULT_EXCLUSIONS, b as OUTPUT_DIRECTORIES, c as DEFAULT_SEMANTIC_TSCONFIG_NAMES, d as IMPLICIT_DEPENDENCIES, f as KNOWN_CONFIG_PREFIXES, g as MAX_PARSE_FILE_SIZE_BYTES, h as MAX_ERROR_DETAIL_LENGTH, i as DEFAULT_ENTRY_GLOBS, j as SUMMARY_CACHE_MAX_BYTES, k as SOURCE_EXTENSIONS$3, l as GIT_CHECK_IGNORE_MAX_BUFFER_BYTES, m as MAX_ANALYSIS_ERRORS, n as BINARY_DETECTION_SAMPLE_BYTES, o as DEFAULT_EXTENSIONS, p as LOCKFILE_MARKERS, r as BUILTIN_MODULES, s as DEFAULT_SEMANTIC_DECORATOR_ALLOWLIST, t as ANALYZED_MANIFEST_FILENAMES, u as HIDDEN_DIRECTORY_ALLOWLIST, v as MIN_NUMERIC_LITERAL_MAGNITUDE_FOR_DUPLICATE, w as SCRIPT_CONFIG_FILE_PATTERN, x as PLATFORM_SUFFIXES, y as MONOREPO_ROOT_MARKERS } from "./constants-oYYofMhb.mjs";
+import { createRequire } from "node:module";
 import path, { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
 import fg from "fast-glob";
 import { readFile } from "node:fs/promises";
 import { parseSync } from "oxc-parser";
 import ts from "typescript";
 import { ResolverFactory } from "oxc-resolver";
+import os, { devNull } from "node:os";
 import { Worker } from "node:worker_threads";
 import { fileURLToPath } from "node:url";
-import os, { devNull } from "node:os";
-import { minimatch } from "minimatch";
+import { Minimatch, minimatch } from "minimatch";
+import crypto from "node:crypto";
 import { spawnSync } from "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;
@@ -2612,12 +2305,6 @@ 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) => existsSync(join(directory, lockfile)));
 const discoverImplicitSubProjects = (rootDir, alreadyDiscoveredDirectories) => {
 	const knownDirectories = new Set(alreadyDiscoveredDirectories);
@@ -3444,21 +3131,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 = resolve(rootDir);
@@ -7224,6 +6896,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 Worker(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({
@@ -7250,14 +6934,6 @@ const deserializeParsedSource = (serialized) => ({
 	duplicateConstantCandidates: serialized.duplicateConstantCandidates,
 	errors: deserializeErrors(serialized.errors)
 });
-const resolveWorkerPath = () => {
-	const currentUrl = import.meta.url;
-	if (currentUrl.endsWith(".ts")) return fileURLToPath(new URL("./parse-worker.ts", currentUrl));
-	return fileURLToPath(new URL("./parse-worker.mjs", currentUrl));
-};
-const createWorker = (workerPath) => {
-	return new Worker(workerPath, { ...workerPath.endsWith(".ts") ? { execArgv: ["--import", "tsx"] } : {} });
-};
 const waitForReady = (worker) => new Promise((resolve, reject) => {
 	const onMessage = (message) => {
 		if (message.type === "ready") {
@@ -7275,11 +6951,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(import.meta.url, "parse-worker"));
 		await Promise.all(workers.map(waitForReady));
 	} catch {
 		for (const worker of workers) worker.terminate();
@@ -7799,10 +7474,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());
@@ -8049,12 +7730,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
+}) ?? fg.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 = 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 = [join(rootDir, "package.json")];
-	const workspacePackageJsons = fg.sync("**/package.json", {
-		cwd: rootDir,
-		absolute: true,
-		onlyFiles: true,
+	const workspacePackageJsons = globPackageFiles(rootDir, ["**/package.json"], {
 		ignore: [
 			"**/node_modules/**",
 			"**/dist/**",
@@ -8062,11 +7760,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 = resolve(config.rootDir, "package.json");
 	let packageJson;
 	try {
@@ -8084,7 +7782,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 = join(monorepoRoot, "package.json");
 		if (!allPackageJsonPaths.includes(monorepoPackageJson) && existsSync(monorepoPackageJson)) allPackageJsonPaths.push(monorepoPackageJson);
@@ -8097,13 +7795,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,
@@ -8155,7 +7853,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);
@@ -8323,35 +8021,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 = 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 = fg.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 = readFileSync(configPath, "utf-8");
-		for (const packageName of declaredNames) if (content.includes(packageName)) referenced.add(packageName);
-	} catch {
-		continue;
-	}
-	const documentationFiles = fg.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/**",
@@ -8359,13 +8048,8 @@ const collectConfigReferencedPackages = (rootDir, graph, declaredNames) => {
 			"**/CHANGELOG.md"
 		],
 		deep: 6
-	});
-	for (const documentationPath of documentationFiles) try {
-		const content = 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 = [
@@ -8436,19 +8120,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 = fg.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 = readFileSync(projectJsonPath, "utf-8");
 		const projectJson = JSON.parse(content);
@@ -8476,16 +8157,13 @@ const TSCONFIG_GLOBS = [
 	"**/tsconfig.json",
 	"**/tsconfig.*.json"
 ];
-const collectTsconfigReferencedPackages = (rootDir) => {
+const collectTsconfigReferencedPackages = (rootDir, summaryCache) => {
 	const referenced = /* @__PURE__ */ new Set();
-	const tsconfigFiles = fg.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 = readFileSync(tsconfigPath, "utf-8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
 		const parsed = JSON.parse(cleaned);
@@ -8531,16 +8209,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 = fg.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 {
@@ -12510,7 +12194,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) {
@@ -12522,7 +12206,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) : [];
@@ -12616,6 +12300,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(import.meta.url, "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(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) => crypto.createHash("sha1").update(text).digest("hex");
+const sha1OfFileBytes = (filePath) => {
+	try {
+		return crypto.createHash("sha1").update(readFileSync(filePath)).digest("hex");
+	} catch {
+		return null;
+	}
+};
+const fileNameOfPosixPath = (posixPath) => posixPath.slice(posixPath.lastIndexOf("/") + 1);
+const deslopRequire = createRequire(import.meta.url);
+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 = 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 = statSync(entryPath);
+					if (linkStat.isDirectory()) {
+						const linkTarget = 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 = statSync(entryPath);
+				collected.set(entryPath, {
+					m: fileStat.mtimeMs,
+					s: fileStat.size
+				});
+			} catch {
+				continue;
+			}
+		}
+	};
+	walk(toPosixPath(resolve(rootDirectory)));
+	return collected;
+};
+const compileGlobAlternation = (patterns, matchDotNames) => {
+	const regexSources = [];
+	for (const pattern of patterns) {
+		const compiled = new 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(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(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 {
+		mkdirSync(dirname(filePath), { recursive: true });
+		const temporaryPath = `${filePath}.${process.pid}.tmp`;
+		writeFileSync(temporaryPath, contents);
+		renameSync(temporaryPath, filePath);
+	} catch {}
+};
+const createSummaryCache = (cachePath, config) => {
+	const scopeHash = computeScopeHash(config);
+	const store = readPersistedStore(cachePath, scopeHash);
+	const walkRoot = toPosixPath(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 = 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 = `${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 = `${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 = 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(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
 /**
@@ -12810,6 +12966,7 @@ const defineConfig = (options) => ({
 	includeExtensions: options.includeExtensions ?? DEFAULT_EXTENSIONS,
 	tsConfigPath: options.tsConfigPath,
 	paths: options.paths,
+	incrementalCachePath: options.incrementalCachePath,
 	reportTypes: options.reportTypes ?? false,
 	includeEntryExports: options.includeEntryExports ?? false,
 	reportRedundancy: options.reportRedundancy ?? true,
@@ -12930,24 +13087,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",
@@ -12958,9 +13117,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(resolve(config.rootDir), files.map((file) => file.path));
 	const gitIgnoredFileSet = gitIgnoreResult.ignoredPaths;
 	if (gitIgnoreResult.gitUnavailable) setupErrors.push(new WorkspaceError({
@@ -12992,7 +13148,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];
@@ -13000,7 +13190,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",
@@ -13080,7 +13270,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",
@@ -13144,7 +13334,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",
@@ -13154,6 +13344,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;