deslop-js 0.0.8 → 0.0.10

package/dist/index.cjs

@@ -254,7 +254,9 @@ const PLATFORM_SUFFIXES = [
 	".desktop",
 	".windows",
 	".macos",
-	".any"
+	".any",
+	".server",
+	".client"
 ];
 const REACT_NATIVE_PLATFORM_EXTENSIONS = [
 	".web.ts",
@@ -605,6 +607,10 @@ const extractNamedExportDeclaration = (node, sourceText, exports) => {
 	}
 };
 const extractDefaultExportDeclaration = (node, sourceText, exports) => {
+	const defaultExpression = node.declaration;
+	let defaultExportLocalName;
+	if (defaultExpression?.type === "Identifier" && typeof defaultExpression.name === "string") defaultExportLocalName = defaultExpression.name;
+	else if ((defaultExpression?.type === "FunctionDeclaration" || defaultExpression?.type === "ClassDeclaration") && defaultExpression.id?.name) defaultExportLocalName = defaultExpression.id.name;
 	exports.push({
 		name: "default",
 		isDefault: true,
@@ -615,7 +621,8 @@ const extractDefaultExportDeclaration = (node, sourceText, exports) => {
 		reExportOriginalName: void 0,
 		isNamespaceReExport: false,
 		line: getLineFromOffset(sourceText, node.start),
-		column: getColumnFromOffset(sourceText, node.start)
+		column: getColumnFromOffset(sourceText, node.start),
+		defaultExportLocalName
 	});
 };
 const extractExportAllDeclaration = (node, sourceText, exports) => {
@@ -1096,6 +1103,12 @@ const collectWorkspacePatterns = (rootDir) => {
 		const packageLines = extractPnpmWorkspacePackages((0, node_fs.readFileSync)(pnpmWorkspacePath, "utf-8"));
 		patterns.push(...packageLines);
 	} catch {}
+	const lernaJsonPath = (0, node_path.join)(rootDir, "lerna.json");
+	if ((0, node_fs.existsSync)(lernaJsonPath)) try {
+		const content = (0, node_fs.readFileSync)(lernaJsonPath, "utf-8");
+		const lernaJson = JSON.parse(content);
+		if (Array.isArray(lernaJson.packages)) patterns.push(...lernaJson.packages.filter((pattern) => typeof pattern === "string" && !pattern.startsWith("!")));
+	} catch {}
 	return patterns;
 };
 const extractPnpmWorkspacePackages = (yamlContent) => {
@@ -1657,6 +1670,54 @@ const resolveSourcePath = (distPath, 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);
+	let walkedDepth = 0;
+	while (walkedDepth < MAX_MONOREPO_WALK_DEPTH) {
+		const parentDirectory = (0, node_path.dirname)(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		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;
+			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;
+			return;
+		}
+		for (const marker of 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 {
+			continue;
+		}
+		for (const lockfile of LOCKFILE_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, lockfile))) return currentDirectory;
+	}
+};
+
 //#endregion
 //#region src/collect/entries.ts
 const collectSourceFiles = async (config) => {
@@ -1762,6 +1823,14 @@ const resolveEntries = async (config) => {
 	for (const entryPath of allDiscoveredEntries) if (entryPath.endsWith(".html") && (0, node_fs.existsSync)(entryPath)) htmlScriptEntries.push(...extractScriptTagsFromHtmlFile(entryPath));
 	const angularEntries = extractAngularEntryPoints(absoluteRoot);
 	for (const workspacePackage of entryEligiblePackages) angularEntries.push(...extractAngularEntryPoints(workspacePackage.directory));
+	const browserExtensionEntries = extractBrowserExtensionEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) browserExtensionEntries.push(...extractBrowserExtensionEntries(workspacePackage.directory));
+	const webWorkerEntries = extractWebWorkerEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) webWorkerEntries.push(...extractWebWorkerEntries(workspacePackage.directory));
+	const tsConfigIncludeEntries = extractTsConfigIncludeFilesEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) tsConfigIncludeEntries.push(...extractTsConfigIncludeFilesEntries(workspacePackage.directory));
+	const wranglerEntries = extractWranglerEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) wranglerEntries.push(...extractWranglerEntries(workspacePackage.directory));
 	const testSetupEntries = extractTestSetupFiles(absoluteRoot);
 	for (const workspacePackage of entryEligiblePackages) testSetupEntries.push(...extractTestSetupFiles(workspacePackage.directory));
 	const pluginFileEntries = extractNextConfigPluginFiles(absoluteRoot);
@@ -1783,6 +1852,10 @@ const resolveEntries = async (config) => {
 			...bundlerConfigEntries,
 			...htmlScriptEntries,
 			...angularEntries,
+			...browserExtensionEntries,
+			...webWorkerEntries,
+			...tsConfigIncludeEntries,
+			...wranglerEntries,
 			...pluginFileEntries,
 			...toolingDiscovery.entryFiles,
 			...ciEntries
@@ -2426,6 +2499,231 @@ const extractScriptTagsFromHtmlFile = (htmlFilePath) => {
 	} catch {}
 	return entries;
 };
+const TSCONFIG_FILENAME_GLOBS = ["tsconfig.json", "tsconfig.*.json"];
+const stripJsoncCommentsLocal = (sourceText) => {
+	let result = "";
+	let insideString = false;
+	let index = 0;
+	while (index < sourceText.length) {
+		const ch = sourceText[index];
+		if (insideString) {
+			if (ch === "\\" && index + 1 < sourceText.length) {
+				result += sourceText[index] + sourceText[index + 1];
+				index += 2;
+				continue;
+			}
+			if (ch === "\"") insideString = false;
+			result += ch;
+			index++;
+			continue;
+		}
+		if (ch === "\"") {
+			insideString = true;
+			result += ch;
+			index++;
+			continue;
+		}
+		if (ch === "/" && index + 1 < sourceText.length) {
+			if (sourceText[index + 1] === "/") {
+				while (index < sourceText.length && sourceText[index] !== "\n") index++;
+				continue;
+			}
+			if (sourceText[index + 1] === "*") {
+				index += 2;
+				while (index + 1 < sourceText.length && !(sourceText[index] === "*" && sourceText[index + 1] === "/")) index++;
+				index += 2;
+				continue;
+			}
+		}
+		result += ch;
+		index++;
+	}
+	return result.replace(/,(\s*[}\]])/g, "$1");
+};
+const extractTsConfigIncludeFilesEntries = (directory) => {
+	const entries = [];
+	const tsconfigPaths = fast_glob.default.sync(TSCONFIG_FILENAME_GLOBS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 1
+	});
+	for (const tsconfigPath of tsconfigPaths) try {
+		const cleaned = stripJsoncCommentsLocal((0, node_fs.readFileSync)(tsconfigPath, "utf-8"));
+		const tsconfigJson = JSON.parse(cleaned);
+		const tsconfigDir = (0, node_path.dirname)(tsconfigPath);
+		const collectPaths = (rawList) => {
+			if (!Array.isArray(rawList)) return;
+			for (const item of rawList) {
+				if (typeof item !== "string") continue;
+				if (item.includes("*") || item.includes("?")) continue;
+				const candidatePath = (0, node_path.resolve)(tsconfigDir, item);
+				if ((0, node_fs.existsSync)(candidatePath)) entries.push(candidatePath);
+			}
+		};
+		collectPaths(tsconfigJson.include);
+		collectPaths(tsconfigJson.files);
+	} catch {}
+	return entries;
+};
+const WRANGLER_TOML_MAIN_PATTERN = /^\s*main\s*=\s*['"]([^'"\n]+)['"]/m;
+const WRANGLER_JSON_MAIN_PATTERN = /"main"\s*:\s*"([^"]+)"/;
+const WRANGLER_SERVICE_BINDINGS_PATTERN = /entry_point\s*=\s*['"]([^'"\n]+)['"]/g;
+const extractWranglerEntries = (directory) => {
+	const entries = [];
+	const wranglerPaths = fast_glob.default.sync([
+		"wrangler.toml",
+		"wrangler.json",
+		"wrangler.jsonc"
+	], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		deep: 1
+	});
+	for (const wranglerPath of wranglerPaths) try {
+		const content = (0, node_fs.readFileSync)(wranglerPath, "utf-8");
+		const wranglerDir = (0, node_path.dirname)(wranglerPath);
+		const mainMatch = wranglerPath.endsWith(".toml") ? content.match(WRANGLER_TOML_MAIN_PATTERN) : content.match(WRANGLER_JSON_MAIN_PATTERN);
+		if (mainMatch?.[1]) {
+			const candidatePath = (0, node_path.resolve)(wranglerDir, mainMatch[1]);
+			if ((0, node_fs.existsSync)(candidatePath)) entries.push(candidatePath);
+			else {
+				const sourceCandidate = resolveSourcePath(candidatePath, wranglerDir);
+				if (sourceCandidate) entries.push(sourceCandidate);
+			}
+		}
+		let entryPointMatch;
+		WRANGLER_SERVICE_BINDINGS_PATTERN.lastIndex = 0;
+		while ((entryPointMatch = WRANGLER_SERVICE_BINDINGS_PATTERN.exec(content)) !== null) {
+			const candidatePath = (0, node_path.resolve)(wranglerDir, entryPointMatch[1]);
+			if ((0, node_fs.existsSync)(candidatePath)) entries.push(candidatePath);
+		}
+	} catch {}
+	return entries;
+};
+const WORKER_FILE_GLOBS = [
+	"**/*.worker.{ts,tsx,js,jsx,mts,mjs,cts,cjs}",
+	"**/*.sw.{ts,tsx,js,jsx,mts,mjs,cts,cjs}",
+	"**/sw.{ts,tsx,js,jsx,mts,mjs,cts,cjs}",
+	"**/service-worker.{ts,tsx,js,jsx,mts,mjs,cts,cjs}"
+];
+const extractWebWorkerEntries = (directory) => {
+	return fast_glob.default.sync(WORKER_FILE_GLOBS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**",
+			"**/.next/**",
+			"**/out/**"
+		],
+		deep: 8
+	});
+};
+const collectBrowserExtensionManifestPaths = (manifest) => {
+	const candidatePaths = [];
+	if (typeof manifest !== "object" || manifest === null) return candidatePaths;
+	const manifestRecord = manifest;
+	const background = manifestRecord.background;
+	if (typeof background === "object" && background !== null) {
+		const backgroundRecord = background;
+		if (typeof backgroundRecord.service_worker === "string") candidatePaths.push(backgroundRecord.service_worker);
+		if (typeof backgroundRecord.page === "string") candidatePaths.push(backgroundRecord.page);
+		if (typeof backgroundRecord.scripts === "string") candidatePaths.push(backgroundRecord.scripts);
+		if (Array.isArray(backgroundRecord.scripts)) {
+			for (const scriptPath of backgroundRecord.scripts) if (typeof scriptPath === "string") candidatePaths.push(scriptPath);
+		}
+	}
+	const contentScripts = manifestRecord.content_scripts;
+	if (Array.isArray(contentScripts)) for (const contentScript of contentScripts) {
+		if (typeof contentScript !== "object" || contentScript === null) continue;
+		const contentScriptRecord = contentScript;
+		if (Array.isArray(contentScriptRecord.js)) {
+			for (const scriptPath of contentScriptRecord.js) if (typeof scriptPath === "string") candidatePaths.push(scriptPath);
+		}
+		if (Array.isArray(contentScriptRecord.css)) {
+			for (const stylePath of contentScriptRecord.css) if (typeof stylePath === "string") candidatePaths.push(stylePath);
+		}
+	}
+	const action = manifestRecord.action ?? manifestRecord.browser_action ?? manifestRecord.page_action;
+	if (typeof action === "object" && action !== null) {
+		const actionRecord = action;
+		if (typeof actionRecord.default_popup === "string") candidatePaths.push(actionRecord.default_popup);
+	}
+	if (typeof manifestRecord.devtools_page === "string") candidatePaths.push(manifestRecord.devtools_page);
+	if (typeof manifestRecord.options_page === "string") candidatePaths.push(manifestRecord.options_page);
+	if (typeof manifestRecord.options_ui === "object" && manifestRecord.options_ui !== null) {
+		const optionsRecord = manifestRecord.options_ui;
+		if (typeof optionsRecord.page === "string") candidatePaths.push(optionsRecord.page);
+	}
+	if (typeof manifestRecord.sandbox === "object" && manifestRecord.sandbox !== null) {
+		const sandboxRecord = manifestRecord.sandbox;
+		if (Array.isArray(sandboxRecord.pages)) {
+			for (const pagePath of sandboxRecord.pages) if (typeof pagePath === "string") candidatePaths.push(pagePath);
+		}
+	}
+	return candidatePaths;
+};
+const isLikelyBrowserExtensionManifest = (manifest) => {
+	if (typeof manifest !== "object" || manifest === null) return false;
+	return typeof manifest.manifest_version === "number";
+};
+const extractBrowserExtensionEntries = (directory) => {
+	const entries = [];
+	const manifestPaths = fast_glob.default.sync([
+		"manifest.json",
+		"manifest.*.json",
+		"src/manifest.json",
+		"src/manifest.*.json",
+		"public/manifest.json",
+		"public/manifest.*.json",
+		"static/manifest.json"
+	], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 3
+	});
+	for (const manifestPath of manifestPaths) try {
+		const content = (0, node_fs.readFileSync)(manifestPath, "utf-8");
+		const manifest = JSON.parse(content);
+		if (!isLikelyBrowserExtensionManifest(manifest)) continue;
+		const manifestDir = (0, node_path.dirname)(manifestPath);
+		const candidatePaths = collectBrowserExtensionManifestPaths(manifest);
+		const resolutionRoots = [
+			manifestDir,
+			(0, node_path.resolve)(manifestDir, ".."),
+			directory
+		];
+		for (const candidatePath of candidatePaths) for (const resolutionRoot of resolutionRoots) {
+			const candidateAbsolutePath = (0, node_path.resolve)(resolutionRoot, candidatePath);
+			if ((0, node_fs.existsSync)(candidateAbsolutePath)) {
+				entries.push(candidateAbsolutePath);
+				break;
+			}
+			const sourceFile = resolveSourcePath(candidateAbsolutePath, resolutionRoot);
+			if (sourceFile) {
+				entries.push(sourceFile);
+				break;
+			}
+		}
+	} catch {}
+	return entries;
+};
 const ANGULAR_ENTRY_KEYS = [
 	"main",
 	"polyfills",
@@ -3156,8 +3454,14 @@ const FRAMEWORK_PATTERNS = [
 		alwaysUsed: ["tsr.config.json", "app.config.{ts,js}"]
 	},
 	{
-		enablers: ["vite", "rolldown-vite"],
-		enablerPrefixes: ["@vitejs/"],
+		enablers: [
+			"vite",
+			"rolldown-vite",
+			"vite-plus",
+			"@voidzero-dev/vite-plus-core",
+			"@voidzero-dev/vite-plus-test"
+		],
+		enablerPrefixes: ["@vitejs/", "@voidzero-dev/vite-plus"],
 		entryPatterns: [
 			"src/main.{ts,tsx,js,jsx}",
 			"src/index.{ts,tsx,js,jsx}",
@@ -3445,10 +3749,25 @@ const detectBunTestRunner = (directory) => {
 		return false;
 	}
 };
+const readPackageJsonDependencies = (packageJsonPath) => {
+	try {
+		const content = (0, node_fs.readFileSync)(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		return {
+			...packageJson.dependencies,
+			...packageJson.devDependencies,
+			...packageJson.optionalDependencies
+		};
+	} catch {
+		return {};
+	}
+};
 const discoverTestRunnerEntryPoints = (rootDir, workspacePackages) => {
 	const allEntries = [];
 	const allAlwaysUsed = [];
 	const directoriesToCheck = [rootDir, ...workspacePackages.map((workspacePackage) => workspacePackage.directory)];
+	const monorepoRoot = findMonorepoRoot(rootDir);
+	const monorepoRootDeps = monorepoRoot && monorepoRoot !== rootDir ? readPackageJsonDependencies((0, node_path.join)(monorepoRoot, "package.json")) : {};
 	for (const directory of directoriesToCheck) {
 		const packageJsonPath = (0, node_path.join)(directory, "package.json");
 		if (!(0, node_fs.existsSync)(packageJsonPath)) continue;
@@ -3473,16 +3792,25 @@ const discoverTestRunnerEntryPoints = (rootDir, workspacePackages) => {
 			})) return true;
 			return runner.configFileActivators.some((configFile) => (0, node_fs.existsSync)((0, node_path.join)(checkDirectory, configFile)));
 		};
-		for (const runner of TEST_FRAMEWORK_PATTERNS) if (isRunnerEnabled(runner, allDependencies, directory)) {
-			const isVitestRunner = runner.enablers.includes("vitest");
-			const isJestRunner = runner.enablers.includes("jest");
-			let customPatterns = [];
-			if (isVitestRunner) customPatterns = extractVitestIncludePatterns(directory);
-			else if (isJestRunner) customPatterns = extractJestTestMatchPatterns(directory);
-			if (customPatterns.length > 0) activatedPatterns.push(...customPatterns);
-			else activatedPatterns.push(...runner.entryPatterns);
-			activatedFixturePatterns.push(...runner.fixturePatterns);
-			activatedAlwaysUsed.push(...runner.alwaysUsed);
+		for (const runner of TEST_FRAMEWORK_PATTERNS) {
+			const enabledLocally = isRunnerEnabled(runner, allDependencies, directory);
+			const enabledViaMonorepo = !enabledLocally && monorepoRoot && (isRunnerEnabled(runner, monorepoRootDeps, monorepoRoot) || runner.configFileActivators.some((configFile) => (0, node_fs.existsSync)((0, node_path.join)(monorepoRoot, configFile))));
+			if (enabledLocally || enabledViaMonorepo) {
+				const isVitestRunner = runner.enablers.includes("vitest");
+				const isJestRunner = runner.enablers.includes("jest");
+				let customPatterns = [];
+				if (isVitestRunner) {
+					customPatterns = extractVitestIncludePatterns(directory);
+					if (customPatterns.length === 0 && monorepoRoot) customPatterns = extractVitestIncludePatterns(monorepoRoot);
+				} else if (isJestRunner) {
+					customPatterns = extractJestTestMatchPatterns(directory);
+					if (customPatterns.length === 0 && monorepoRoot) customPatterns = extractJestTestMatchPatterns(monorepoRoot);
+				}
+				if (customPatterns.length > 0) activatedPatterns.push(...customPatterns);
+				else activatedPatterns.push(...runner.entryPatterns);
+				activatedFixturePatterns.push(...runner.fixturePatterns);
+				activatedAlwaysUsed.push(...runner.alwaysUsed);
+			}
 		}
 		if (activatedPatterns.length === 0 && directory !== rootDir) {
 			const rootPackageJsonPath = (0, node_path.join)(rootDir, "package.json");
@@ -3547,6 +3875,45 @@ const isToolingPluginEnabled = (plugin, dependencies) => {
 	}
 	return false;
 };
+const FRAMEWORK_SCRIPT_BINARIES = {
+	next: ["next"],
+	nuxt: ["nuxt"],
+	astro: ["astro"],
+	gatsby: ["gatsby"],
+	remix: ["remix"],
+	"@sveltejs/kit": ["svelte-kit", "vite-svelte-kit"],
+	"@docusaurus/core": ["docusaurus"],
+	"@angular/core": ["ng"],
+	"@nestjs/core": ["nest"],
+	storybook: [
+		"storybook",
+		"start-storybook",
+		"build-storybook"
+	]
+};
+const detectFrameworkFromScripts = (scripts) => {
+	const enabledEnablers = /* @__PURE__ */ new Set();
+	if (!scripts || typeof scripts !== "object") return enabledEnablers;
+	for (const scriptValue of Object.values(scripts)) {
+		if (typeof scriptValue !== "string") continue;
+		const tokenized = scriptValue.split(/[\s|&;]+/);
+		for (const token of tokenized) {
+			const cleaned = token.replace(/^.*\//, "");
+			for (const [enabler, binaries] of Object.entries(FRAMEWORK_SCRIPT_BINARIES)) if (binaries.includes(cleaned)) enabledEnablers.add(enabler);
+		}
+	}
+	return enabledEnablers;
+};
+const readPackageScripts = (directory) => {
+	const packageJsonPath = (0, node_path.join)(directory, "package.json");
+	if (!(0, node_fs.existsSync)(packageJsonPath)) return void 0;
+	try {
+		const content = (0, node_fs.readFileSync)(packageJsonPath, "utf-8");
+		return JSON.parse(content).scripts;
+	} catch {
+		return;
+	}
+};
 const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 	const allEntries = [];
 	const allAlwaysUsed = [];
@@ -3562,6 +3929,8 @@ const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 			...rootPackageJson.optionalDependencies
 		};
 	} catch {}
+	const monorepoRoot = findMonorepoRoot(rootDir);
+	const monorepoRootDeps = monorepoRoot && monorepoRoot !== rootDir ? readPackageJsonDependencies((0, node_path.join)(monorepoRoot, "package.json")) : {};
 	for (const directory of directoriesToCheck) {
 		const packageJsonPath = (0, node_path.join)(directory, "package.json");
 		if (!(0, node_fs.existsSync)(packageJsonPath)) continue;
@@ -3577,7 +3946,10 @@ const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 		} catch {
 			continue;
 		}
-		const mergedDependencies = directory === rootDir ? rootDependencies : workspaceDependencies;
+		const scriptDetectedEnablers = detectFrameworkFromScripts(readPackageScripts(directory));
+		const mergedDependencies = { ...workspaceDependencies };
+		if (directory === rootDir) Object.assign(mergedDependencies, rootDependencies);
+		else for (const enabler of scriptDetectedEnablers) if (enabler in monorepoRootDeps || enabler in rootDependencies) mergedDependencies[enabler] = "*";
 		const activatedPatterns = [];
 		const activatedAlwaysUsed = [];
 		for (const plugin of FRAMEWORK_PATTERNS) if (isToolingPluginEnabled(plugin, mergedDependencies)) {
@@ -3715,6 +4087,17 @@ const COMMON_RESOLVER_OPTIONS = {
 		".cjs": [".cts", ".cjs"]
 	}
 };
+const WEBPACK_CONFIG_GLOBS = [
+	"webpack.config.{js,ts,mjs,cjs}",
+	"**/webpack*.config.{js,ts,mjs,cjs}",
+	"**/webpack.config*.{js,ts,mjs,cjs}",
+	"**/webpack*.config*.babel.{js,ts}"
+];
+const WEBPACK_ALIAS_BLOCK_PATTERN = /alias\s*:\s*\{([\s\S]*?)\}/g;
+const WEBPACK_ALIAS_ENTRY_PATTERN = /["']?([@\w$./-]+)["']?\s*:\s*(?:path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["']\s*,?\s*)+)\)|["']([^"']+)["'])/g;
+const WEBPACK_MODULES_BLOCK_PATTERN = /modules\s*:\s*\[([\s\S]*?)\]/g;
+const WEBPACK_PATH_CALL_PATTERN = /path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["']\s*,?\s*)+)\)/g;
+const WEBPACK_STRING_LITERAL_PATTERN = /["']([^"']+)["']/g;
 const TSCONFIG_FILENAMES = [
 	"tsconfig.json",
 	"tsconfig.web.json",
@@ -3764,6 +4147,108 @@ const resolveScssPartial = (specifier, fromDirectory) => {
 	candidates.push((0, node_path.join)(basePath, `_index.sass`));
 	for (const candidate of candidates) if (cachedExistsSync(candidate)) return candidate;
 };
+const isInsideDirectory = (filePath, directory) => {
+	const relativePath = (0, node_path.relative)(directory, filePath);
+	return relativePath === "" || !relativePath.startsWith("..") && !(0, node_path.isAbsolute)(relativePath);
+};
+const extractQuotedSegments = (value) => {
+	const segments = [];
+	let segmentMatch;
+	WEBPACK_STRING_LITERAL_PATTERN.lastIndex = 0;
+	while ((segmentMatch = WEBPACK_STRING_LITERAL_PATTERN.exec(value)) !== null) segments.push(segmentMatch[1]);
+	return segments;
+};
+const resolveWebpackPathValue = (value, configDirectory) => {
+	if ((0, node_path.isAbsolute)(value)) return value;
+	return (0, node_path.resolve)(configDirectory, value);
+};
+const findWebpackConfigScope = (configPath, rootDir) => {
+	let currentDirectory = (0, node_path.dirname)(configPath);
+	const absoluteRoot = (0, node_path.resolve)(rootDir);
+	while (currentDirectory.length >= absoluteRoot.length) {
+		if (cachedExistsSync((0, node_path.join)(currentDirectory, "package.json"))) return currentDirectory;
+		const parentDirectory = (0, node_path.dirname)(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
+	}
+	return absoluteRoot;
+};
+const extractWebpackAliases = (content, configDirectory) => {
+	const aliases = [];
+	let aliasBlockMatch;
+	WEBPACK_ALIAS_BLOCK_PATTERN.lastIndex = 0;
+	while ((aliasBlockMatch = WEBPACK_ALIAS_BLOCK_PATTERN.exec(content)) !== null) {
+		const aliasBlock = aliasBlockMatch[1];
+		let aliasEntryMatch;
+		WEBPACK_ALIAS_ENTRY_PATTERN.lastIndex = 0;
+		while ((aliasEntryMatch = WEBPACK_ALIAS_ENTRY_PATTERN.exec(aliasBlock)) !== null) {
+			const rawName = aliasEntryMatch[1];
+			const pathCallSegments = aliasEntryMatch[2];
+			const stringTarget = aliasEntryMatch[3];
+			if (!pathCallSegments && !stringTarget) continue;
+			const isExact = rawName.endsWith("$");
+			const name = isExact ? rawName.slice(0, -1) : rawName.replace(/\/$/, "");
+			let targetDirectory;
+			if (pathCallSegments) targetDirectory = (0, node_path.resolve)(configDirectory, ...extractQuotedSegments(pathCallSegments));
+			else if (stringTarget) targetDirectory = resolveWebpackPathValue(stringTarget, configDirectory);
+			else continue;
+			aliases.push({
+				name,
+				targetDirectory,
+				isExact
+			});
+		}
+	}
+	return aliases;
+};
+const extractWebpackModuleDirectories = (content, configDirectory) => {
+	const moduleDirectories = [];
+	let modulesBlockMatch;
+	WEBPACK_MODULES_BLOCK_PATTERN.lastIndex = 0;
+	while ((modulesBlockMatch = WEBPACK_MODULES_BLOCK_PATTERN.exec(content)) !== null) {
+		const modulesBlock = modulesBlockMatch[1];
+		let pathCallMatch;
+		WEBPACK_PATH_CALL_PATTERN.lastIndex = 0;
+		while ((pathCallMatch = WEBPACK_PATH_CALL_PATTERN.exec(modulesBlock)) !== null) moduleDirectories.push((0, node_path.resolve)(configDirectory, ...extractQuotedSegments(pathCallMatch[1])));
+		let stringMatch;
+		WEBPACK_STRING_LITERAL_PATTERN.lastIndex = 0;
+		while ((stringMatch = WEBPACK_STRING_LITERAL_PATTERN.exec(modulesBlock)) !== null) {
+			const moduleDirectory = stringMatch[1];
+			if (moduleDirectory === "node_modules") continue;
+			moduleDirectories.push(resolveWebpackPathValue(moduleDirectory, configDirectory));
+		}
+	}
+	return [...new Set(moduleDirectories)];
+};
+const loadWebpackResolverConfigs = (rootDir) => {
+	const configPaths = fast_glob.default.sync(WEBPACK_CONFIG_GLOBS, {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 4
+	});
+	const configs = [];
+	for (const configPath of configPaths) try {
+		const content = cachedReadFileSync(configPath);
+		const configDirectory = (0, node_path.dirname)(configPath);
+		const aliases = extractWebpackAliases(content, configDirectory);
+		const moduleDirectories = extractWebpackModuleDirectories(content, configDirectory);
+		if (aliases.length === 0 && moduleDirectories.length === 0) continue;
+		configs.push({
+			scopeDirectory: findWebpackConfigScope(configPath, rootDir),
+			aliases,
+			moduleDirectories
+		});
+	} catch {
+		continue;
+	}
+	return configs;
+};
 const createResolver = (config, workspacePackages = [], options = {}) => {
 	const resolverCache = /* @__PURE__ */ new Map();
 	const resolveResultCache = /* @__PURE__ */ new Map();
@@ -3800,6 +4285,7 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 	};
 	const workspaceNameToDirectory = /* @__PURE__ */ new Map();
 	for (const workspacePackage of workspacePackages) workspaceNameToDirectory.set(workspacePackage.name, workspacePackage.directory);
+	const webpackResolverConfigs = (options.monorepoRoot && options.monorepoRoot !== config.rootDir ? [config.rootDir, options.monorepoRoot] : [config.rootDir]).flatMap(loadWebpackResolverConfigs).sort((leftConfig, rightConfig) => rightConfig.scopeDirectory.length - leftConfig.scopeDirectory.length);
 	let rootTsconfigPath;
 	if (config.tsConfigPath) rootTsconfigPath = (0, node_path.resolve)(config.rootDir, config.tsConfigPath);
 	else {
@@ -3883,6 +4369,43 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 			return false;
 		}
 	})();
+	const packageDependencyCache = /* @__PURE__ */ new Map();
+	const readPackageDependencies = (directory) => {
+		const cached = packageDependencyCache.get(directory);
+		if (cached) return cached;
+		const dependencies = /* @__PURE__ */ new Set();
+		const packageJsonPath = (0, node_path.join)(directory, "package.json");
+		try {
+			const packageJson = JSON.parse(cachedReadFileSync(packageJsonPath));
+			const dependencySections = [
+				packageJson.dependencies,
+				packageJson.devDependencies,
+				packageJson.optionalDependencies
+			];
+			for (const dependencySection of dependencySections) {
+				if (!dependencySection || typeof dependencySection !== "object") continue;
+				for (const dependencyName of Object.keys(dependencySection)) dependencies.add(dependencyName);
+			}
+		} catch {}
+		packageDependencyCache.set(directory, dependencies);
+		return dependencies;
+	};
+	const findNearestPackageSrcDirectoryWithDependency = (filePath, dependencyNames) => {
+		let currentDirectory = (0, node_path.dirname)(filePath);
+		const stopAt = options.monorepoRoot ? (0, node_path.resolve)(options.monorepoRoot) : (0, node_path.resolve)(config.rootDir);
+		while (currentDirectory.length >= stopAt.length) {
+			if (cachedExistsSync((0, node_path.join)(currentDirectory, "package.json"))) {
+				const dependencies = readPackageDependencies(currentDirectory);
+				if (dependencyNames.some((dependencyName) => dependencies.has(dependencyName))) {
+					const srcDirectory = (0, node_path.join)(currentDirectory, "src");
+					return cachedExistsSync(srcDirectory) ? srcDirectory : void 0;
+				}
+			}
+			const parentDirectory = (0, node_path.dirname)(currentDirectory);
+			if (parentDirectory === currentDirectory) break;
+			currentDirectory = parentDirectory;
+		}
+	};
 	const extractPathsFromTsconfig = (tsconfigFile, visitedFiles) => {
 		if (visitedFiles.has(tsconfigFile)) return void 0;
 		visitedFiles.add(tsconfigFile);
@@ -3959,6 +4482,28 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 			}
 		}
 	};
+	const tryResolveFromDirectory = (directory, specifier) => {
+		const candidatePath = resolvePathWithExtensionFallback((0, node_path.resolve)(directory, specifier));
+		if (existsAsFile(candidatePath)) return candidatePath;
+	};
+	const tryResolveViaWebpackConfig = (specifier, fromFile) => {
+		if (webpackResolverConfigs.length === 0) return void 0;
+		if (!isBareSpecifier(specifier)) return void 0;
+		for (const webpackConfig of webpackResolverConfigs) {
+			if (!isInsideDirectory(fromFile, webpackConfig.scopeDirectory)) continue;
+			for (const alias of webpackConfig.aliases) {
+				if (alias.isExact && specifier !== alias.name) continue;
+				const suffix = specifier === alias.name ? "" : specifier.startsWith(`${alias.name}/`) ? specifier.slice(alias.name.length + 1) : void 0;
+				if (suffix === void 0) continue;
+				const aliasCandidate = tryResolveFromDirectory(alias.targetDirectory, suffix);
+				if (aliasCandidate) return aliasCandidate;
+			}
+			for (const moduleDirectory of webpackConfig.moduleDirectories) {
+				const moduleCandidate = tryResolveFromDirectory(moduleDirectory, specifier);
+				if (moduleCandidate) return moduleCandidate;
+			}
+		}
+	};
 	const resolveModule = (specifier, fromFile) => {
 		const queryIndex = specifier.indexOf("?");
 		const cleanedSpecifier = queryIndex !== -1 ? specifier.slice(0, queryIndex) : specifier;
@@ -4122,6 +4667,16 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 			resolveResultCache.set(cacheKey, resolvedResult);
 			return resolvedResult;
 		}
+		const webpackResolved = tryResolveViaWebpackConfig(cleanedSpecifier, fromFile);
+		if (webpackResolved) {
+			const resolvedResult = {
+				resolvedPath: webpackResolved,
+				isExternal: false,
+				packageName: void 0
+			};
+			resolveResultCache.set(cacheKey, resolvedResult);
+			return resolvedResult;
+		}
 		if (isBareSpecifier(cleanedSpecifier)) {
 			const tsconfigFile = findTsconfigForFile(fromFile);
 			if (tsconfigFile) {
@@ -4155,6 +4710,19 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 					}
 				}
 			}
+			const createReactAppSrcDirectory = findNearestPackageSrcDirectoryWithDependency(fromFile, ["react-scripts", "react-app-rewired"]);
+			if (createReactAppSrcDirectory) {
+				const craResolved = tryResolveFromDirectory(createReactAppSrcDirectory, cleanedSpecifier);
+				if (craResolved) {
+					const resolvedResult = {
+						resolvedPath: craResolved,
+						isExternal: false,
+						packageName: void 0
+					};
+					resolveResultCache.set(cacheKey, resolvedResult);
+					return resolvedResult;
+				}
+			}
 			const resolvedResult = {
 				resolvedPath: void 0,
 				isExternal: true,
@@ -4618,12 +5186,16 @@ const detectDeadExports = (graph, config) => {
 		if (!module.isReachable) continue;
 		if (module.isDeclarationFile) continue;
 		if (module.isEntryPoint && !config.includeEntryExports) continue;
+		const defaultExportLinkedNames = /* @__PURE__ */ new Set();
+		for (const exportInfo of module.exports) if (exportInfo.isDefault && exportInfo.defaultExportLocalName && usageMap.has(`${module.fileId.path}::default`)) defaultExportLinkedNames.add(exportInfo.defaultExportLocalName);
 		for (const exportInfo of module.exports) {
 			if (exportInfo.name === "*" && exportInfo.isNamespaceReExport) continue;
 			if (exportInfo.isReExport && exportInfo.reExportOriginalName) continue;
 			if (!config.reportTypes && exportInfo.isTypeOnly) continue;
 			const usageKey = `${module.fileId.path}::${exportInfo.name}`;
-			if (!usageMap.has(usageKey)) unusedExports.push({
+			if (usageMap.has(usageKey)) continue;
+			if (!exportInfo.isDefault && defaultExportLinkedNames.has(exportInfo.name)) continue;
+			unusedExports.push({
 				path: module.fileId.path,
 				name: exportInfo.name,
 				line: exportInfo.line,
@@ -4739,61 +5311,134 @@ const followReExportChain = (reExporterModuleIndex, exportInfo, graph, sourceToT
 //#endregion
 //#region src/utils/package-name.ts
 const extractPackageName = (specifier) => {
-	if (specifier.startsWith(".") || specifier.startsWith("/")) return void 0;
+	const normalizedSpecifier = specifier.startsWith("~") ? specifier.slice(1) : specifier;
+	if (normalizedSpecifier.startsWith(".") || normalizedSpecifier.startsWith("/")) return void 0;
 	if (specifier.startsWith("node:")) return void 0;
-	if (specifier.startsWith("@")) {
-		const parts = specifier.split("/");
+	if (normalizedSpecifier.startsWith("@")) {
+		const parts = normalizedSpecifier.split("/");
 		return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0;
 	}
-	return specifier.split("/")[0];
+	return normalizedSpecifier.split("/")[0];
 };
 
 //#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);
-	let walkedDepth = 0;
-	while (walkedDepth < MAX_MONOREPO_WALK_DEPTH) {
-		const parentDirectory = (0, node_path.dirname)(currentDirectory);
-		if (parentDirectory === currentDirectory) break;
-		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;
-			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;
-			return;
+//#region src/utils/extract-override-target.ts
+const extractOverrideTargetPackage = (overrideValue) => {
+	let normalizedValue = overrideValue.trim().replace(/^["']|["']$/g, "");
+	if (normalizedValue.startsWith("npm:")) normalizedValue = normalizedValue.slice(4);
+	if (normalizedValue.startsWith("@")) {
+		const slashIndex = normalizedValue.indexOf("/");
+		if (slashIndex === -1) return void 0;
+		const scope = normalizedValue.slice(0, slashIndex);
+		const remainder = normalizedValue.slice(slashIndex + 1);
+		const versionSeparatorIndex = remainder.indexOf("@");
+		const packageName = versionSeparatorIndex === -1 ? remainder : remainder.slice(0, versionSeparatorIndex);
+		if (!packageName) return void 0;
+		return `${scope}/${packageName}`;
+	}
+	const versionSeparatorIndex = normalizedValue.indexOf("@");
+	return (versionSeparatorIndex === -1 ? normalizedValue : normalizedValue.slice(0, versionSeparatorIndex)) || void 0;
+};
+
+//#endregion
+//#region src/utils/collect-override-mappings-from-record.ts
+const collectOverrideMappingsFromUnknown = (fromPackage, overrideValue, mappings) => {
+	if (typeof overrideValue === "string") {
+		const toPackage = extractOverrideTargetPackage(overrideValue);
+		if (!toPackage) return;
+		mappings.push({
+			fromPackage,
+			toPackage
+		});
+		return;
+	}
+	if (!overrideValue || typeof overrideValue !== "object" || Array.isArray(overrideValue)) return;
+	for (const [nestedFromPackage, nestedValue] of Object.entries(overrideValue)) collectOverrideMappingsFromUnknown(nestedFromPackage, nestedValue, mappings);
+};
+const collectOverrideMappingsFromRecord = (overrideRecord) => {
+	const mappings = [];
+	for (const [fromPackage, overrideValue] of Object.entries(overrideRecord)) collectOverrideMappingsFromUnknown(fromPackage, overrideValue, mappings);
+	return mappings;
+};
+
+//#endregion
+//#region src/utils/parse-pnpm-workspace-overrides.ts
+const PNPM_WORKSPACE_FILENAMES = ["pnpm-workspace.yaml", "pnpm-workspace.yml"];
+const parseIndentedYamlMapping = (lines, startLineIndex, sectionIndent) => {
+	const entries = {};
+	let lineIndex = startLineIndex;
+	while (lineIndex < lines.length) {
+		const line = lines[lineIndex];
+		const trimmedLine = line.trim();
+		if (trimmedLine.length === 0 || trimmedLine.startsWith("#")) {
+			lineIndex++;
+			continue;
 		}
-		for (const marker of 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;
+		const indent = line.length - line.trimStart().length;
+		if (indent <= sectionIndent) break;
+		const colonIndex = trimmedLine.indexOf(":");
+		if (colonIndex === -1) {
+			lineIndex++;
+			continue;
+		}
+		const key = trimmedLine.slice(0, colonIndex).trim().replace(/^["']|["']$/g, "");
+		const rawValue = trimmedLine.slice(colonIndex + 1).trim();
+		if (!key) {
+			lineIndex++;
+			continue;
+		}
+		if (rawValue.length === 0) {
+			const nestedMapping = parseIndentedYamlMapping(lines, lineIndex + 1, indent);
+			entries[key] = nestedMapping.entries;
+			lineIndex = nestedMapping.endLineIndex;
+			continue;
+		}
+		entries[key] = rawValue.replace(/^["']|["']$/g, "");
+		lineIndex++;
+	}
+	return {
+		entries,
+		endLineIndex: lineIndex
+	};
+};
+const parsePnpmWorkspaceOverrideRecords = (yamlContent) => {
+	const lines = yamlContent.split("\n");
+	const overrideRecords = [];
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+		if (lines[lineIndex].trim() !== "overrides:") continue;
+		const sectionIndent = lines[lineIndex].length - lines[lineIndex].trimStart().length;
+		const parsedMapping = parseIndentedYamlMapping(lines, lineIndex + 1, sectionIndent);
+		if (Object.keys(parsedMapping.entries).length > 0) overrideRecords.push(parsedMapping.entries);
+	}
+	return overrideRecords;
+};
+const collectPnpmWorkspaceOverrideMappings = (rootDir) => {
+	const mappings = [];
+	for (const workspaceFilename of PNPM_WORKSPACE_FILENAMES) {
+		const workspacePath = (0, node_path.join)(rootDir, workspaceFilename);
+		if (!(0, node_fs.existsSync)(workspacePath)) continue;
+		try {
+			const overrideRecords = parsePnpmWorkspaceOverrideRecords((0, node_fs.readFileSync)(workspacePath, "utf-8"));
+			for (const overrideRecord of overrideRecords) mappings.push(...collectOverrideMappingsFromRecord(overrideRecord));
 		} catch {
 			continue;
 		}
-		for (const lockfile of LOCKFILE_MARKERS) if ((0, node_fs.existsSync)((0, node_path.join)(currentDirectory, lockfile))) return currentDirectory;
 	}
+	return mappings;
+};
+
+//#endregion
+//#region src/utils/matches-package-import-reference.ts
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const matchesPackageImportReference = (content, packageName) => {
+	const escapedPackageName = escapeRegExp(packageName);
+	const subpathPattern = `(?:/[^'"]*)?`;
+	return [
+		new RegExp(`\\bfrom\\s+['"]${escapedPackageName}${subpathPattern}['"]`),
+		new RegExp(`\\bimport\\s+(?:[^'";\\n]*?\\sfrom\\s+)?['"]${escapedPackageName}${subpathPattern}['"]`),
+		new RegExp(`\\brequire\\s*\\(\\s*['"]${escapedPackageName}${subpathPattern}['"]\\s*\\)`),
+		new RegExp(`\\bimport\\s*\\(\\s*['"]${escapedPackageName}${subpathPattern}['"]`)
+	].some((pattern) => pattern.test(content));
 };
 
 //#endregion
@@ -4845,6 +5490,8 @@ const detectStalePackages = (graph, config) => {
 		const packageJsonConfigReferenced = collectPackageJsonConfigReferences(workspacePackageJsonPath, declaredNames);
 		for (const packageName of packageJsonConfigReferenced) usedPackageNames.add(packageName);
 	}
+	const nxProjectReferenced = collectNxProjectJsonReferences(config.rootDir, declaredNames, binToPackage);
+	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);
@@ -4884,6 +5531,15 @@ const detectStalePackages = (graph, config) => {
 	}
 	const peerSatisfied = collectPeerSatisfiedPackages(nodeModulesRoot, declaredNames, usedPackageNames);
 	for (const packageName of peerSatisfied) usedPackageNames.add(packageName);
+	const staticPeerSatisfied = collectStaticPeerSatisfiedPackages(declaredNames, usedPackageNames);
+	for (const packageName of staticPeerSatisfied) usedPackageNames.add(packageName);
+	const implicitCompanionPackages = collectImplicitCompanionPackages(declaredNames, usedPackageNames);
+	for (const packageName of implicitCompanionPackages) usedPackageNames.add(packageName);
+	const overrideMappings = collectOverrideMappings(configSearchRoots, allPackageJsonPaths, monorepoRoot);
+	for (const { fromPackage, toPackage } of overrideMappings) {
+		if (declaredNames.has(toPackage)) usedPackageNames.add(toPackage);
+		if (usedPackageNames.has(fromPackage) && declaredNames.has(toPackage)) usedPackageNames.add(toPackage);
+	}
 	const candidateUnused = /* @__PURE__ */ new Set();
 	for (const [dependencyName] of declaredDependencies) {
 		if (isAlwaysConsideredUsed(dependencyName)) continue;
@@ -4937,11 +5593,76 @@ const collectPeerSatisfiedPackages = (rootDir, declaredNames, confirmedUsedNames
 	}
 	return peerSatisfied;
 };
+const STATIC_PEER_DEPENDENCY_MAP = {
+	"@apollo/client": ["graphql"],
+	"@docusaurus/core": ["@mdx-js/react"],
+	"@fortawesome/react-fontawesome": ["@fortawesome/fontawesome-svg-core"],
+	"@gorhom/bottom-sheet": ["react-native-gesture-handler", "react-native-reanimated"],
+	"@hookform/resolvers": ["zod"],
+	"@mdx-js/loader": ["@mdx-js/react"],
+	"@mui/material": ["react-transition-group", "styled-components"],
+	"@stripe/react-stripe-js": ["@stripe/stripe-js"],
+	"@tiptap/core": ["@tiptap/pm"],
+	"@tiptap/react": ["@tiptap/pm"],
+	"@trpc/server": ["zod"],
+	"chart.js": [],
+	"fumadocs-core": ["@mdx-js/react"],
+	"fumadocs-mdx": ["@mdx-js/react"],
+	"fumadocs-ui": ["@mdx-js/react"],
+	"graphql-request": ["graphql"],
+	nextra: ["@mdx-js/react"],
+	"nextra-theme-blog": ["@mdx-js/react"],
+	"nextra-theme-docs": ["@mdx-js/react"],
+	"react-app-polyfill": ["core-js"],
+	"react-bootstrap": ["react-transition-group"],
+	"react-chartjs-2": ["chart.js"],
+	"react-redux": ["redux"],
+	"react-router-dom": ["react-router"],
+	"redux-thunk": ["redux"],
+	sanity: ["styled-components"],
+	sequelize: ["pg"],
+	"stylis-plugin-rtl": ["stylis"],
+	urql: ["graphql"],
+	"use-immer": ["immer"],
+	zustand: ["immer"]
+};
+const collectStaticPeerSatisfiedPackages = (declaredNames, confirmedUsedNames) => {
+	const peerSatisfied = /* @__PURE__ */ new Set();
+	for (const [packageName, peerNames] of Object.entries(STATIC_PEER_DEPENDENCY_MAP)) {
+		if (!confirmedUsedNames.has(packageName)) continue;
+		for (const peerName of peerNames) if (declaredNames.has(peerName)) peerSatisfied.add(peerName);
+	}
+	return peerSatisfied;
+};
+const IMPLICIT_COMPANION_DEPENDENCY_MAP = {
+	jest: ["jest-config"],
+	"jest-cli": ["jest-config"],
+	"vite-plus": ["@voidzero-dev/vite-plus-core"]
+};
+const collectImplicitCompanionPackages = (declaredNames, confirmedUsedNames) => {
+	const companions = /* @__PURE__ */ new Set();
+	for (const [packageName, companionNames] of Object.entries(IMPLICIT_COMPANION_DEPENDENCY_MAP)) {
+		if (!confirmedUsedNames.has(packageName)) continue;
+		for (const companionName of companionNames) if (declaredNames.has(companionName)) companions.add(companionName);
+	}
+	return companions;
+};
 const SHELL_SPLIT_PATTERN = /\s*(?:&&|\|\||[;&|])\s*/;
 const CLI_BINARY_TO_PACKAGE = {
+	"babel-node": "@babel/node",
+	"trigger.dev": "trigger.dev",
+	"@formatjs/cli": "@formatjs/cli",
 	"react-scripts": "react-scripts",
 	"webpack-cli": "webpack-cli",
 	"webpack-dev-server": "webpack-dev-server",
+	babel: "@babel/cli",
+	chokidar: "chokidar-cli",
+	"replace-in-file": "replace-in-file",
+	tauri: "@tauri-apps/cli",
+	tinacms: "@tinacms/cli",
+	"tsc-alias": "tsc-alias",
+	formatjs: "@formatjs/cli",
+	prompt: "prompt",
 	vitest: "vitest",
 	jest: "jest",
 	prisma: "prisma",
@@ -4957,7 +5678,15 @@ const CLI_BINARY_TO_PACKAGE = {
 	"rndebugger-open": "react-native-debugger-open",
 	"simple-git-hooks": "simple-git-hooks",
 	"generate-arg-types": "@webstudio-is/generate-arg-types",
-	email: "@react-email/preview-server"
+	email: "@react-email/preview-server",
+	vp: "vite-plus",
+	turbo: "turbo",
+	changeset: "@changesets/cli",
+	tsx: "tsx"
+};
+const CLI_BINARY_FALLBACK_PACKAGES = {
+	babel: ["babel-cli"],
+	jest: ["jest-cli"]
 };
 const ENV_WRAPPER_BINARY_SET = new Set([
 	"cross-env",
@@ -4990,36 +5719,43 @@ const collectScriptReferencedPackages = (packageJsonPath, declaredNames, binToPa
 		if (!scripts || typeof scripts !== "object") return referenced;
 		for (const scriptCommand of Object.values(scripts)) {
 			if (typeof scriptCommand !== "string") continue;
-			const segments = scriptCommand.split(SHELL_SPLIT_PATTERN);
-			for (const segment of segments) {
-				const tokens = segment.trim().split(/\s+/);
-				if (tokens.length === 0) continue;
-				let binaryIndex = 0;
-				const firstToken = tokens[0].replace(/^.*\//, "");
-				if (ENV_WRAPPER_BINARY_SET.has(firstToken)) {
-					const envPackage = binToPackage.get(firstToken);
-					if (envPackage && declaredNames.has(envPackage)) referenced.add(envPackage);
-					binaryIndex = 1;
-					while (binaryIndex < tokens.length && INLINE_ENV_VAR_PATTERN.test(tokens[binaryIndex])) binaryIndex++;
-					if (binaryIndex >= tokens.length) continue;
-				}
-				while (binaryIndex < tokens.length && INLINE_ENV_VAR_PATTERN.test(tokens[binaryIndex])) binaryIndex++;
-				if (binaryIndex >= tokens.length) continue;
-				const binaryToken = tokens[binaryIndex].replace(/^.*\//, "");
-				const effectiveBinary = binaryToken === "npx" || binaryToken === "pnpx" || binaryToken === "bunx" ? tokens[binaryIndex + 1]?.replace(/^.*\//, "") ?? "" : binaryToken;
-				for (const candidateBinary of [binaryToken, effectiveBinary]) {
-					if (!candidateBinary) continue;
-					const mappedPackage = binToPackage.get(candidateBinary);
-					if (mappedPackage && declaredNames.has(mappedPackage)) referenced.add(mappedPackage);
-					if (declaredNames.has(candidateBinary)) referenced.add(candidateBinary);
-				}
-			}
+			const commandReferenced = collectCommandReferencedPackages(scriptCommand, declaredNames, binToPackage);
+			for (const packageName of commandReferenced) referenced.add(packageName);
 		}
 	} catch {
 		return referenced;
 	}
 	return referenced;
 };
+const collectCommandReferencedPackages = (command, declaredNames, binToPackage) => {
+	const referenced = /* @__PURE__ */ new Set();
+	const segments = command.split(SHELL_SPLIT_PATTERN);
+	for (const segment of segments) {
+		const tokens = segment.trim().split(/\s+/);
+		if (tokens.length === 0) continue;
+		let binaryIndex = 0;
+		const firstToken = tokens[0].replace(/^.*\//, "");
+		if (ENV_WRAPPER_BINARY_SET.has(firstToken)) {
+			const envPackage = binToPackage.get(firstToken);
+			if (envPackage && declaredNames.has(envPackage)) referenced.add(envPackage);
+			binaryIndex = 1;
+			while (binaryIndex < tokens.length && INLINE_ENV_VAR_PATTERN.test(tokens[binaryIndex])) binaryIndex++;
+			if (binaryIndex >= tokens.length) continue;
+		}
+		while (binaryIndex < tokens.length && INLINE_ENV_VAR_PATTERN.test(tokens[binaryIndex])) binaryIndex++;
+		if (binaryIndex >= tokens.length) continue;
+		const binaryToken = tokens[binaryIndex].replace(/^.*\//, "");
+		const effectiveBinary = binaryToken === "npx" || binaryToken === "pnpx" || binaryToken === "bunx" ? tokens[binaryIndex + 1]?.replace(/^.*\//, "") ?? "" : binaryToken;
+		for (const candidateBinary of [binaryToken, effectiveBinary]) {
+			if (!candidateBinary) continue;
+			const mappedPackage = binToPackage.get(candidateBinary);
+			if (mappedPackage && declaredNames.has(mappedPackage)) referenced.add(mappedPackage);
+			for (const fallbackPackage of CLI_BINARY_FALLBACK_PACKAGES[candidateBinary] ?? []) if (declaredNames.has(fallbackPackage)) referenced.add(fallbackPackage);
+			if (declaredNames.has(candidateBinary)) referenced.add(candidateBinary);
+		}
+	}
+	return referenced;
+};
 const CONFIG_FILE_GLOBS = [
 	"postcss.config.{js,cjs,mjs,ts}",
 	".babelrc",
@@ -5100,6 +5836,42 @@ const PACKAGE_JSON_CONFIG_SECTIONS = [
 	"resolutions",
 	"overrides"
 ];
+const collectOverrideMappingsFromPackageJson = (packageJsonPath) => {
+	const mappings = [];
+	try {
+		const content = (0, node_fs.readFileSync)(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		const overrideSections = [
+			packageJson.overrides,
+			packageJson.resolutions,
+			packageJson.pnpm?.overrides
+		];
+		for (const overrideSection of overrideSections) {
+			if (!overrideSection || typeof overrideSection !== "object") continue;
+			mappings.push(...collectOverrideMappingsFromRecord(overrideSection));
+		}
+	} catch {
+		return mappings;
+	}
+	return mappings;
+};
+const collectOverrideMappings = (configSearchRoots, packageJsonPaths, monorepoRoot) => {
+	const mappings = [];
+	const seenMappings = /* @__PURE__ */ new Set();
+	const addMappings = (nextMappings) => {
+		for (const mapping of nextMappings) {
+			const mappingKey = `${mapping.fromPackage}->${mapping.toPackage}`;
+			if (seenMappings.has(mappingKey)) continue;
+			seenMappings.add(mappingKey);
+			mappings.push(mapping);
+		}
+	};
+	for (const packageJsonPath of packageJsonPaths) addMappings(collectOverrideMappingsFromPackageJson(packageJsonPath));
+	const workspaceRoots = new Set(configSearchRoots);
+	if (monorepoRoot) workspaceRoots.add(monorepoRoot);
+	for (const workspaceRoot of workspaceRoots) addMappings(collectPnpmWorkspaceOverrideMappings(workspaceRoot));
+	return mappings;
+};
 const collectPackageJsonConfigReferences = (packageJsonPath, declaredNames) => {
 	const referenced = /* @__PURE__ */ new Set();
 	try {
@@ -5116,6 +5888,39 @@ const collectPackageJsonConfigReferences = (packageJsonPath, declaredNames) => {
 	}
 	return referenced;
 };
+const collectNxProjectJsonReferences = (rootDir, declaredNames, binToPackage) => {
+	const referenced = /* @__PURE__ */ new Set();
+	const projectJsonPaths = fast_glob.default.sync(["project.json", "**/project.json"], {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 5
+	});
+	for (const projectJsonPath of projectJsonPaths) try {
+		const content = (0, node_fs.readFileSync)(projectJsonPath, "utf-8");
+		const projectJson = JSON.parse(content);
+		const projectText = JSON.stringify(projectJson);
+		for (const packageName of declaredNames) if (projectText.includes(packageName)) referenced.add(packageName);
+		for (const stringValue of collectStringValues(projectJson)) {
+			const commandReferenced = collectCommandReferencedPackages(stringValue, declaredNames, binToPackage);
+			for (const packageName of commandReferenced) referenced.add(packageName);
+		}
+	} catch {
+		continue;
+	}
+	return referenced;
+};
+const collectStringValues = (value) => {
+	if (typeof value === "string") return [value];
+	if (!value || typeof value !== "object") return [];
+	if (Array.isArray(value)) return value.flatMap(collectStringValues);
+	return Object.values(value).flatMap(collectStringValues);
+};
 const TSCONFIG_GLOBS = [
 	"tsconfig.json",
 	"tsconfig.*.json",
@@ -5192,7 +5997,7 @@ const scanSourceFilesForPackageImports = (rootDir, candidatePackages) => {
 		if (candidatePackages.size === 0) break;
 		try {
 			const content = (0, node_fs.readFileSync)(filePath, "utf-8");
-			for (const packageName of candidatePackages) if (content.includes(`'${packageName}'`) || content.includes(`"${packageName}"`) || content.includes(`'${packageName}/`) || content.includes(`"${packageName}/`)) {
+			for (const packageName of candidatePackages) if (matchesPackageImportReference(content, packageName)) {
 				found.add(packageName);
 				candidatePackages.delete(packageName);
 			}