deslop-js 0.0.7 → 0.0.9

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import path, { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import path, { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import fg from "fast-glob";
 import { readFile } from "node:fs/promises";
@@ -224,7 +224,9 @@ const PLATFORM_SUFFIXES = [
 	".desktop",
 	".windows",
 	".macos",
-	".any"
+	".any",
+	".server",
+	".client"
 ];
 const REACT_NATIVE_PLATFORM_EXTENSIONS = [
 	".web.ts",
@@ -575,6 +577,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,
@@ -585,7 +591,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) => {
@@ -1066,6 +1073,12 @@ const collectWorkspacePatterns = (rootDir) => {
 		const packageLines = extractPnpmWorkspacePackages(readFileSync(pnpmWorkspacePath, "utf-8"));
 		patterns.push(...packageLines);
 	} catch {}
+	const lernaJsonPath = join(rootDir, "lerna.json");
+	if (existsSync(lernaJsonPath)) try {
+		const content = 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) => {
@@ -1627,6 +1640,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 = resolve(rootDir);
+	let walkedDepth = 0;
+	while (walkedDepth < MAX_MONOREPO_WALK_DEPTH) {
+		const parentDirectory = dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
+		walkedDepth++;
+		if (existsSync(join(currentDirectory, ".git"))) {
+			for (const marker of MONOREPO_ROOT_MARKERS) if (existsSync(join(currentDirectory, marker))) return currentDirectory;
+			const packageJsonPath = join(currentDirectory, "package.json");
+			if (existsSync(packageJsonPath)) try {
+				const content = readFileSync(packageJsonPath, "utf-8");
+				if (JSON.parse(content).workspaces) return currentDirectory;
+			} catch {}
+			for (const lockfile of LOCKFILE_MARKERS) if (existsSync(join(currentDirectory, lockfile))) return currentDirectory;
+			return;
+		}
+		for (const marker of MONOREPO_ROOT_MARKERS) if (existsSync(join(currentDirectory, marker))) return currentDirectory;
+		const packageJsonPath = join(currentDirectory, "package.json");
+		if (existsSync(packageJsonPath)) try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			if (JSON.parse(content).workspaces) return currentDirectory;
+		} catch {
+			continue;
+		}
+		for (const lockfile of LOCKFILE_MARKERS) if (existsSync(join(currentDirectory, lockfile))) return currentDirectory;
+	}
+};
+
 //#endregion
 //#region src/collect/entries.ts
 const collectSourceFiles = async (config) => {
@@ -1732,6 +1793,14 @@ const resolveEntries = async (config) => {
 	for (const entryPath of allDiscoveredEntries) if (entryPath.endsWith(".html") && 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);
@@ -1753,6 +1822,10 @@ const resolveEntries = async (config) => {
 			...bundlerConfigEntries,
 			...htmlScriptEntries,
 			...angularEntries,
+			...browserExtensionEntries,
+			...webWorkerEntries,
+			...tsConfigIncludeEntries,
+			...wranglerEntries,
 			...pluginFileEntries,
 			...toolingDiscovery.entryFiles,
 			...ciEntries
@@ -2396,6 +2469,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 = fg.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(readFileSync(tsconfigPath, "utf-8"));
+		const tsconfigJson = JSON.parse(cleaned);
+		const tsconfigDir = 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 = resolve(tsconfigDir, item);
+				if (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 = fg.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 = readFileSync(wranglerPath, "utf-8");
+		const wranglerDir = dirname(wranglerPath);
+		const mainMatch = wranglerPath.endsWith(".toml") ? content.match(WRANGLER_TOML_MAIN_PATTERN) : content.match(WRANGLER_JSON_MAIN_PATTERN);
+		if (mainMatch?.[1]) {
+			const candidatePath = resolve(wranglerDir, mainMatch[1]);
+			if (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 = resolve(wranglerDir, entryPointMatch[1]);
+			if (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 fg.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 = fg.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 = readFileSync(manifestPath, "utf-8");
+		const manifest = JSON.parse(content);
+		if (!isLikelyBrowserExtensionManifest(manifest)) continue;
+		const manifestDir = dirname(manifestPath);
+		const candidatePaths = collectBrowserExtensionManifestPaths(manifest);
+		const resolutionRoots = [
+			manifestDir,
+			resolve(manifestDir, ".."),
+			directory
+		];
+		for (const candidatePath of candidatePaths) for (const resolutionRoot of resolutionRoots) {
+			const candidateAbsolutePath = resolve(resolutionRoot, candidatePath);
+			if (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",
@@ -3126,8 +3424,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}",
@@ -3415,10 +3719,25 @@ const detectBunTestRunner = (directory) => {
 		return false;
 	}
 };
+const readPackageJsonDependencies = (packageJsonPath) => {
+	try {
+		const content = 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(join(monorepoRoot, "package.json")) : {};
 	for (const directory of directoriesToCheck) {
 		const packageJsonPath = join(directory, "package.json");
 		if (!existsSync(packageJsonPath)) continue;
@@ -3443,16 +3762,25 @@ const discoverTestRunnerEntryPoints = (rootDir, workspacePackages) => {
 			})) return true;
 			return runner.configFileActivators.some((configFile) => existsSync(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) => existsSync(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 = join(rootDir, "package.json");
@@ -3517,6 +3845,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 = join(directory, "package.json");
+	if (!existsSync(packageJsonPath)) return void 0;
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		return JSON.parse(content).scripts;
+	} catch {
+		return;
+	}
+};
 const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 	const allEntries = [];
 	const allAlwaysUsed = [];
@@ -3532,6 +3899,8 @@ const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 			...rootPackageJson.optionalDependencies
 		};
 	} catch {}
+	const monorepoRoot = findMonorepoRoot(rootDir);
+	const monorepoRootDeps = monorepoRoot && monorepoRoot !== rootDir ? readPackageJsonDependencies(join(monorepoRoot, "package.json")) : {};
 	for (const directory of directoriesToCheck) {
 		const packageJsonPath = join(directory, "package.json");
 		if (!existsSync(packageJsonPath)) continue;
@@ -3547,7 +3916,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)) {
@@ -3685,16 +4057,28 @@ 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",
 	"tsconfig.app.json",
-	"tsconfig.base.json"
+	"tsconfig.base.json",
+	"jsconfig.json"
 ];
-const findNearestTsconfig = (fromDir, rootDir) => {
+const findNearestTsconfig = (fromDir, rootDir, monorepoRootDir) => {
 	let currentDirectory = fromDir;
-	const normalizedRoot = resolve(rootDir);
-	while (currentDirectory.length >= normalizedRoot.length) {
+	const stopAt = monorepoRootDir ? resolve(monorepoRootDir) : resolve(rootDir);
+	while (currentDirectory.length >= stopAt.length) {
 		for (const tsconfigFilename of TSCONFIG_FILENAMES) {
 			const tsconfigCandidate = join(currentDirectory, tsconfigFilename);
 			if (cachedExistsSync(tsconfigCandidate)) return tsconfigCandidate;
@@ -3733,6 +4117,108 @@ const resolveScssPartial = (specifier, fromDirectory) => {
 	candidates.push(join(basePath, `_index.sass`));
 	for (const candidate of candidates) if (cachedExistsSync(candidate)) return candidate;
 };
+const isInsideDirectory = (filePath, directory) => {
+	const relativePath = relative(directory, filePath);
+	return relativePath === "" || !relativePath.startsWith("..") && !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 (isAbsolute(value)) return value;
+	return resolve(configDirectory, value);
+};
+const findWebpackConfigScope = (configPath, rootDir) => {
+	let currentDirectory = dirname(configPath);
+	const absoluteRoot = resolve(rootDir);
+	while (currentDirectory.length >= absoluteRoot.length) {
+		if (cachedExistsSync(join(currentDirectory, "package.json"))) return currentDirectory;
+		const parentDirectory = 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 = 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(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 = fg.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 = 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();
@@ -3769,18 +4255,20 @@ 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 = resolve(config.rootDir, config.tsConfigPath);
-	else for (const candidate of [
-		"tsconfig.json",
-		"tsconfig.web.json",
-		"tsconfig.app.json",
-		"tsconfig.base.json"
-	]) {
-		const candidatePath = resolve(config.rootDir, candidate);
-		if (cachedExistsSync(candidatePath)) {
-			rootTsconfigPath = candidatePath;
-			break;
+	else {
+		const tsconfigSearchDirs = options.monorepoRoot ? [config.rootDir, options.monorepoRoot] : [config.rootDir];
+		for (const searchDir of tsconfigSearchDirs) {
+			for (const candidate of TSCONFIG_FILENAMES) {
+				const candidatePath = resolve(searchDir, candidate);
+				if (cachedExistsSync(candidatePath)) {
+					rootTsconfigPath = candidatePath;
+					break;
+				}
+			}
+			if (rootTsconfigPath) break;
 		}
 	}
 	const tsconfigPathCache = /* @__PURE__ */ new Map();
@@ -3789,24 +4277,56 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 		const fileDir = dirname(filePath);
 		const cached = tsconfigPathCache.get(fileDir);
 		if (cached !== void 0) return cached;
-		const tsconfigResult = findNearestTsconfig(fileDir, config.rootDir) ?? rootTsconfigPath;
+		const tsconfigResult = findNearestTsconfig(fileDir, config.rootDir, options.monorepoRoot) ?? rootTsconfigPath;
 		tsconfigPathCache.set(fileDir, tsconfigResult);
 		return tsconfigResult;
 	};
 	const tsconfigBaseUrlCache = /* @__PURE__ */ new Map();
-	const getBaseUrlDirectory = (tsconfigFile) => {
-		const cached = tsconfigBaseUrlCache.get(tsconfigFile);
-		if (cached !== void 0) return cached;
+	const resolveExtendsPath = (extendsValue, fromDir) => {
+		if (extendsValue.startsWith(".")) {
+			const absolutePath = resolve(fromDir, extendsValue);
+			if (cachedExistsSync(absolutePath)) return absolutePath;
+			if (cachedExistsSync(absolutePath + ".json")) return absolutePath + ".json";
+			return;
+		}
+		const packagePath = join(options.monorepoRoot ?? config.rootDir, "node_modules", extendsValue);
+		if (cachedExistsSync(packagePath)) return packagePath;
+		if (cachedExistsSync(packagePath + ".json")) return packagePath + ".json";
+		const localPackagePath = join(fromDir, "node_modules", extendsValue);
+		if (cachedExistsSync(localPackagePath)) return localPackagePath;
+		if (cachedExistsSync(localPackagePath + ".json")) return localPackagePath + ".json";
+	};
+	const collectExtendsEntries = (tsconfigJson) => {
+		if (typeof tsconfigJson.extends === "string") return [tsconfigJson.extends];
+		if (Array.isArray(tsconfigJson.extends)) return tsconfigJson.extends.filter((entry) => typeof entry === "string");
+		return [];
+	};
+	const extractBaseUrlFromTsconfig = (tsconfigFile, visitedFiles) => {
+		if (visitedFiles.has(tsconfigFile)) return void 0;
+		visitedFiles.add(tsconfigFile);
 		try {
 			const cleanedContent = stripJsonComments(cachedReadFileSync(tsconfigFile));
-			const baseUrl = JSON.parse(cleanedContent).compilerOptions?.baseUrl;
-			if (baseUrl) {
-				const absoluteBaseUrl = resolve(dirname(tsconfigFile), baseUrl);
-				tsconfigBaseUrlCache.set(tsconfigFile, absoluteBaseUrl);
-				return absoluteBaseUrl;
+			const tsconfigJson = JSON.parse(cleanedContent);
+			const tsconfigDir = dirname(tsconfigFile);
+			const baseUrl = tsconfigJson.compilerOptions?.baseUrl;
+			if (baseUrl) return resolve(tsconfigDir, baseUrl);
+			for (const extendsEntry of collectExtendsEntries(tsconfigJson)) {
+				const resolvedPath = resolveExtendsPath(extendsEntry, tsconfigDir);
+				if (resolvedPath) {
+					const result = extractBaseUrlFromTsconfig(resolvedPath, visitedFiles);
+					if (result) return result;
+				}
 			}
-		} catch {}
-		tsconfigBaseUrlCache.set(tsconfigFile, void 0);
+		} catch {
+			return;
+		}
+	};
+	const getBaseUrlDirectory = (tsconfigFile) => {
+		const cached = tsconfigBaseUrlCache.get(tsconfigFile);
+		if (cached !== void 0) return cached;
+		const result = extractBaseUrlFromTsconfig(tsconfigFile, /* @__PURE__ */ new Set());
+		tsconfigBaseUrlCache.set(tsconfigFile, result);
+		return result;
 	};
 	const hasNextJsDependency = (() => {
 		try {
@@ -3819,25 +4339,83 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 			return false;
 		}
 	})();
-	const getPathAliases = (tsconfigFile) => {
-		const cached = tsconfigPathAliasCache.get(tsconfigFile);
+	const packageDependencyCache = /* @__PURE__ */ new Map();
+	const readPackageDependencies = (directory) => {
+		const cached = packageDependencyCache.get(directory);
 		if (cached) return cached;
-		const aliasMap = /* @__PURE__ */ new Map();
-		const tsconfigDir = dirname(tsconfigFile);
+		const dependencies = /* @__PURE__ */ new Set();
+		const packageJsonPath = 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 = dirname(filePath);
+		const stopAt = options.monorepoRoot ? resolve(options.monorepoRoot) : resolve(config.rootDir);
+		while (currentDirectory.length >= stopAt.length) {
+			if (cachedExistsSync(join(currentDirectory, "package.json"))) {
+				const dependencies = readPackageDependencies(currentDirectory);
+				if (dependencyNames.some((dependencyName) => dependencies.has(dependencyName))) {
+					const srcDirectory = join(currentDirectory, "src");
+					return cachedExistsSync(srcDirectory) ? srcDirectory : void 0;
+				}
+			}
+			const parentDirectory = dirname(currentDirectory);
+			if (parentDirectory === currentDirectory) break;
+			currentDirectory = parentDirectory;
+		}
+	};
+	const extractPathsFromTsconfig = (tsconfigFile, visitedFiles) => {
+		if (visitedFiles.has(tsconfigFile)) return void 0;
+		visitedFiles.add(tsconfigFile);
 		try {
 			const tsconfigContent = cachedReadFileSync(tsconfigFile).trim();
-			if (tsconfigContent.length > 0) {
-				const cleanedContent = stripJsonComments(tsconfigContent);
-				const tsconfigJson = JSON.parse(cleanedContent);
-				const paths = tsconfigJson.compilerOptions?.paths;
-				const baseUrl = tsconfigJson.compilerOptions?.baseUrl ?? ".";
-				if (paths && typeof paths === "object") {
-					for (const [pattern, targets] of Object.entries(paths)) if (Array.isArray(targets)) aliasMap.set(pattern, targets.map((target) => resolve(tsconfigDir, baseUrl, target)));
+			if (tsconfigContent.length === 0) return void 0;
+			const cleanedContent = stripJsonComments(tsconfigContent);
+			const tsconfigJson = JSON.parse(cleanedContent);
+			const tsconfigDir = dirname(tsconfigFile);
+			const paths = tsconfigJson.compilerOptions?.paths;
+			const baseUrl = tsconfigJson.compilerOptions?.baseUrl;
+			if (paths && typeof paths === "object") return {
+				paths,
+				baseUrl: baseUrl ?? ".",
+				tsconfigDir
+			};
+			for (const extendsEntry of collectExtendsEntries(tsconfigJson)) {
+				const resolvedPath = resolveExtendsPath(extendsEntry, tsconfigDir);
+				if (resolvedPath) {
+					const result = extractPathsFromTsconfig(resolvedPath, visitedFiles);
+					if (result) return result;
 				}
 			}
-		} catch {}
-		if (aliasMap.size === 0 && hasNextJsDependency) if (cachedExistsSync(resolve(tsconfigDir, "src"))) aliasMap.set("@/*", [resolve(tsconfigDir, "src/*")]);
-		else aliasMap.set("@/*", [resolve(tsconfigDir, "*")]);
+		} catch {
+			return;
+		}
+	};
+	const getPathAliases = (tsconfigFile) => {
+		const cached = tsconfigPathAliasCache.get(tsconfigFile);
+		if (cached) return cached;
+		const aliasMap = /* @__PURE__ */ new Map();
+		const extracted = extractPathsFromTsconfig(tsconfigFile, /* @__PURE__ */ new Set());
+		if (extracted) {
+			for (const [pattern, targets] of Object.entries(extracted.paths)) if (Array.isArray(targets)) aliasMap.set(pattern, targets.map((target) => resolve(extracted.tsconfigDir, extracted.baseUrl, target)));
+		}
+		if (aliasMap.size === 0 && hasNextJsDependency) {
+			const tsconfigDir = dirname(tsconfigFile);
+			if (cachedExistsSync(resolve(tsconfigDir, "src"))) aliasMap.set("@/*", [resolve(tsconfigDir, "src/*")]);
+			else aliasMap.set("@/*", [resolve(tsconfigDir, "*")]);
+		}
 		tsconfigPathAliasCache.set(tsconfigFile, aliasMap);
 		return aliasMap;
 	};
@@ -3874,6 +4452,28 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 			}
 		}
 	};
+	const tryResolveFromDirectory = (directory, specifier) => {
+		const candidatePath = resolvePathWithExtensionFallback(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;
@@ -4037,6 +4637,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) {
@@ -4070,6 +4680,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,
@@ -4533,12 +5156,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,
@@ -4654,62 +5281,18 @@ 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/report/packages.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);
-	let walkedDepth = 0;
-	while (walkedDepth < MAX_MONOREPO_WALK_DEPTH) {
-		const parentDirectory = dirname(currentDirectory);
-		if (parentDirectory === currentDirectory) break;
-		currentDirectory = parentDirectory;
-		walkedDepth++;
-		if (existsSync(join(currentDirectory, ".git"))) {
-			for (const marker of MONOREPO_ROOT_MARKERS) if (existsSync(join(currentDirectory, marker))) return currentDirectory;
-			const packageJsonPath = join(currentDirectory, "package.json");
-			if (existsSync(packageJsonPath)) try {
-				const content = readFileSync(packageJsonPath, "utf-8");
-				if (JSON.parse(content).workspaces) return currentDirectory;
-			} catch {}
-			for (const lockfile of LOCKFILE_MARKERS) if (existsSync(join(currentDirectory, lockfile))) return currentDirectory;
-			return;
-		}
-		for (const marker of MONOREPO_ROOT_MARKERS) if (existsSync(join(currentDirectory, marker))) return currentDirectory;
-		const packageJsonPath = join(currentDirectory, "package.json");
-		if (existsSync(packageJsonPath)) try {
-			const content = readFileSync(packageJsonPath, "utf-8");
-			if (JSON.parse(content).workspaces) return currentDirectory;
-		} catch {
-			continue;
-		}
-		for (const lockfile of LOCKFILE_MARKERS) if (existsSync(join(currentDirectory, lockfile))) return currentDirectory;
-	}
-};
 const discoverAllPackageJsonPaths = (rootDir) => {
 	const paths = [join(rootDir, "package.json")];
 	const workspacePackageJsons = fg.sync("**/package.json", {
@@ -4757,6 +5340,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);
@@ -4770,8 +5355,36 @@ const detectStalePackages = (graph, config) => {
 		if (declaredNames.has("react-native")) usedPackageNames.add("react-native");
 		if (declaredNames.has("react-native-web")) usedPackageNames.add("react-native-web");
 	}
+	if (declaredNames.has("react-dom")) {
+		if ([
+			"next",
+			"gatsby",
+			"@remix-run/react",
+			"react-router-dom",
+			"vite",
+			"@docusaurus/core",
+			"react-scripts",
+			"astro",
+			"@tanstack/react-router",
+			"@tanstack/react-start",
+			"react-app-rewired"
+		].some((framework) => declaredNames.has(framework) || usedPackageNames.has(framework))) usedPackageNames.add("react-dom");
+	}
+	if (declaredNames.has("react") && declaredNames.has("react-dom")) {
+		const packageJsonPath = resolve(config.rootDir, "package.json");
+		try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			const peerDeps = JSON.parse(content).peerDependencies ?? {};
+			if ("react" in peerDeps && declaredDependencies.get("react") === true) usedPackageNames.add("react");
+			if ("react-dom" in peerDeps && declaredDependencies.get("react-dom") === true) usedPackageNames.add("react-dom");
+		} catch {}
+	}
 	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 candidateUnused = /* @__PURE__ */ new Set();
 	for (const [dependencyName] of declaredDependencies) {
 		if (isAlwaysConsideredUsed(dependencyName)) continue;
@@ -4825,11 +5438,75 @@ 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"]
+};
+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",
@@ -4847,6 +5524,10 @@ const CLI_BINARY_TO_PACKAGE = {
 	"generate-arg-types": "@webstudio-is/generate-arg-types",
 	email: "@react-email/preview-server"
 };
+const CLI_BINARY_FALLBACK_PACKAGES = {
+	babel: ["babel-cli"],
+	jest: ["jest-cli"]
+};
 const ENV_WRAPPER_BINARY_SET = new Set([
 	"cross-env",
 	"dotenv",
@@ -4878,36 +5559,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",
@@ -5004,6 +5692,39 @@ const collectPackageJsonConfigReferences = (packageJsonPath, declaredNames) => {
 	}
 	return referenced;
 };
+const collectNxProjectJsonReferences = (rootDir, declaredNames, binToPackage) => {
+	const referenced = /* @__PURE__ */ new Set();
+	const projectJsonPaths = fg.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 = 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",
@@ -5362,7 +6083,13 @@ const defineConfig = (options) => ({
 const analyze = async (config) => {
 	const pipelineStartTime = performance.now();
 	const workspaceDiscovery = resolveWorkspaces(resolve(config.rootDir));
-	const workspacePackages = workspaceDiscovery.packages;
+	const workspacePackages = [...workspaceDiscovery.packages];
+	const monorepoRoot = findMonorepoRoot(config.rootDir);
+	if (monorepoRoot) {
+		const monorepoWorkspaces = resolveWorkspaces(monorepoRoot);
+		const existingDirectories = new Set(workspacePackages.map((workspacePackage) => workspacePackage.directory));
+		for (const monorepoPackage of monorepoWorkspaces.packages) if (!existingDirectories.has(monorepoPackage.directory)) workspacePackages.push(monorepoPackage);
+	}
 	const frameworkIgnorePatterns = getFrameworkExclusions(config.rootDir);
 	const absoluteRoot = resolve(config.rootDir);
 	const outputDirectoryExclusions = OUTPUT_DIRECTORIES.flatMap((outputDirectory) => {
@@ -5388,7 +6115,10 @@ const analyze = async (config) => {
 	const moduleResolver = createResolver(config, workspacePackages.map((workspacePackage) => ({
 		name: workspacePackage.name,
 		directory: workspacePackage.directory
-	})), { hasReactNative });
+	})), {
+		hasReactNative,
+		monorepoRoot
+	});
 	const graphInputs = [];
 	for (const file of files) {
 		const parsedModule = parseSourceFile(file.path);