react-doctor 0.7.2 → 0.7.3-dev.6b70b32

package/dist/cli.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7d3c9a4a-cf80-5529-97be-47427cc1e986")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d6c8e327-6382-5aed-99c8-f3e537c25f51")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as NodeChildProcess from "node:child_process";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
@@ -35959,6 +35959,25 @@ var AmbiguousProjectError = class extends Error {
 	}
 };
 const isProjectDiscoveryError = (value) => value instanceof ProjectNotFoundError || value instanceof NoReactDependencyError || value instanceof PackageJsonNotFoundError || value instanceof NotADirectoryError || value instanceof AmbiguousProjectError;
+const isErrnoException = (error) => error instanceof Error && "code" in error;
+const IGNORABLE_READDIR_ERROR_CODES = new Set([
+	"EACCES",
+	"EPERM",
+	"ENOENT",
+	"ENOTDIR",
+	"EINVAL",
+	"ELOOP",
+	"ENAMETOOLONG"
+]);
+const isIgnorableReaddirError = (error) => isErrnoException(error) && typeof error.code === "string" && IGNORABLE_READDIR_ERROR_CODES.has(error.code);
+const readDirectoryEntries = (directoryPath) => {
+	try {
+		return NFS.readdirSync(directoryPath, { withFileTypes: true });
+	} catch (error) {
+		if (isIgnorableReaddirError(error)) return [];
+		throw error;
+	}
+};
 const isFile = (filePath) => {
 	try {
 		return NFS.statSync(filePath).isFile();
@@ -35966,6 +35985,18 @@ const isFile = (filePath) => {
 		return false;
 	}
 };
+const isDirectory = (directoryPath) => {
+	try {
+		return NFS.statSync(directoryPath).isDirectory();
+	} catch {
+		return false;
+	}
+};
+const isPlainObject = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype;
+};
 const SOURCE_FILE_PATTERN = /\.(tsx?|jsx?|mts|mjs)$/;
 const GENERATED_BUNDLE_FILE_PATTERN = /\.(iife|umd|global|min)\.m?js$/i;
 const GENERATED_SOURCE_DIRECTORY_PATTERN = /(?:^|\/)__generated__\//;
@@ -36100,6 +36131,8 @@ const OXLINT_SPAWN_TIMEOUT_MS = 6e4;
 const NODE_COMPILE_CACHE_DIR_NAME = "node-compile-cache";
 const DEAD_CODE_WORKER_TIMEOUT_MS = 12e4;
 const OXLINT_SPLIT_TOTAL_BUDGET_MS = 18e4;
+const ABORT_EXIT_CODES = new Set([134, 3221226505]);
+const OXLINT_OOM_RESCUE_BUDGET_MS = 6e4;
 const DEAD_CODE_PHASE_TIMEOUT_MS = 15e4;
 const LINT_PHASE_TIMEOUT_MS = 3e5;
 const SCAN_TOTAL_DEADLINE_MS = 9e5;
@@ -36146,7 +36179,7 @@ const SOCKET_FREE_USER_AGENT = "react-doctor-supply-chain";
 const FILE_LINT_CACHE_FILENAME = "file-lint-cache.json";
 const FILE_LINT_CACHE_MAX_FILE_COUNT = 5e4;
 const SIDECAR_LINT_CACHE_FILENAME = "sidecar-lint-cache.json";
-const CORE_PACKAGE_VERSION = "0.7.2";
+const CORE_PACKAGE_VERSION = "0.7.3";
 const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
 const DEAD_CODE_SUMMARY_CACHE_FILENAME = "dead-code-summaries.json";
 const SUPPLY_CHAIN_PLUGIN = "socket";
@@ -36192,25 +36225,6 @@ const isLargeMinifiedFile = (absolutePath, knownSizeBytes) => {
 	cachedIsLargeMinifiedByPath.set(absolutePath, result);
 	return result;
 };
-const isErrnoException = (error) => error instanceof Error && "code" in error;
-const IGNORABLE_READDIR_ERROR_CODES = new Set([
-	"EACCES",
-	"EPERM",
-	"ENOENT",
-	"ENOTDIR",
-	"EINVAL",
-	"ELOOP",
-	"ENAMETOOLONG"
-]);
-const isIgnorableReaddirError = (error) => isErrnoException(error) && typeof error.code === "string" && IGNORABLE_READDIR_ERROR_CODES.has(error.code);
-const readDirectoryEntries = (directoryPath) => {
-	try {
-		return NFS.readdirSync(directoryPath, { withFileTypes: true });
-	} catch (error) {
-		if (isIgnorableReaddirError(error)) return [];
-		throw error;
-	}
-};
 function* walkSourceTreeFiles(rootDirectory) {
 	const stack = [rootDirectory];
 	while (stack.length > 0) {
@@ -36265,23 +36279,6 @@ const listSourceFilesViaFilesystem = (rootDirectory) => {
 const listSourceFilesWithSize = (rootDirectory) => collectSizedSourceFiles(rootDirectory, (listSourceFilesViaGit(rootDirectory) ?? listSourceFilesViaFilesystem(rootDirectory)).sort());
 const listSourceFiles = (rootDirectory) => listSourceFilesWithSize(rootDirectory).map((entry) => entry.path);
 const countSourceFiles = (rootDirectory) => listSourceFilesWithSize(rootDirectory).length;
-/**
-* The chain of ancestor directories of `startDirectory`, nearest first, up to
-* and including the filesystem root. With `includeStart`, the chain begins at
-* `startDirectory` itself; otherwise at its parent. The one place the "walk up
-* the tree" traversal is expressed, so each caller adds only its own match /
-* stop policy instead of re-deriving the `path.dirname` loop.
-*/
-const ancestorDirectories = (startDirectory, { includeStart }) => {
-	const directories = [];
-	let currentDirectory = includeStart ? startDirectory : Path.dirname(startDirectory);
-	while (true) {
-		directories.push(currentDirectory);
-		const parentDirectory = Path.dirname(currentDirectory);
-		if (parentDirectory === currentDirectory) return directories;
-		currentDirectory = parentDirectory;
-	}
-};
 const cachedPackageJsons = /* @__PURE__ */ new Map();
 const readPackageJsonUncached = (packageJsonPath) => {
 	try {
@@ -36312,7 +36309,11 @@ const isMonorepoRoot = (directory) => {
 	return Array.isArray(packageJson.workspaces) || Boolean(packageJson.workspaces?.packages);
 };
 const findMonorepoRoot = (startDirectory) => {
-	for (const directory of ancestorDirectories(startDirectory, { includeStart: false })) if (isMonorepoRoot(directory)) return directory;
+	let currentDirectory = Path.dirname(startDirectory);
+	while (currentDirectory !== Path.dirname(currentDirectory)) {
+		if (isMonorepoRoot(currentDirectory)) return currentDirectory;
+		currentDirectory = Path.dirname(currentDirectory);
+	}
 	return null;
 };
 /**
@@ -36326,6 +36327,146 @@ const findMonorepoRoot = (startDirectory) => {
 * byte-equivalent copy.
 */
 const isProjectBoundary = (directory) => NFS.existsSync(Path.join(directory, ".git")) || isMonorepoRoot(directory);
+const TSCONFIG_FILENAME = "tsconfig.json";
+const isRelativeExtendsValue = (extendsValue) => extendsValue.startsWith("./") || extendsValue.startsWith("../") || Path.isAbsolute(extendsValue);
+const ensureJsonExtension = (filePath) => Path.extname(filePath) === "" ? `${filePath}.json` : filePath;
+const resolvePackageExtendsPath = (extendsValue, fromConfigDirectory) => {
+	const requireFromConfig = createRequire(Path.join(fromConfigDirectory, "tsconfig.json"));
+	const candidates = [
+		extendsValue,
+		ensureJsonExtension(extendsValue),
+		`${extendsValue.replace(/\/$/, "")}/tsconfig.json`
+	];
+	for (const candidate of candidates) try {
+		return requireFromConfig.resolve(candidate);
+	} catch {
+		continue;
+	}
+	return null;
+};
+const resolveExtendsPath = (extendsValue, fromConfigDirectory) => {
+	if (isRelativeExtendsValue(extendsValue)) return ensureJsonExtension(Path.resolve(fromConfigDirectory, extendsValue));
+	return resolvePackageExtendsPath(extendsValue, fromConfigDirectory);
+};
+const normalizeCompilerOptions = (compilerOptions) => {
+	if (!isPlainObject(compilerOptions)) return { hasExplicitLib: false };
+	const target = typeof compilerOptions.target === "string" ? compilerOptions.target : void 0;
+	const hasExplicitLib = Object.hasOwn(compilerOptions, "lib");
+	return {
+		target,
+		lib: Array.isArray(compilerOptions.lib) ? compilerOptions.lib.filter((entry) => typeof entry === "string") : void 0,
+		hasExplicitLib
+	};
+};
+const readTsConfig = (filePath) => {
+	let content;
+	try {
+		content = NFS.readFileSync(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+	const parsed = ts.parseConfigFileTextToJson(filePath, content);
+	if (!isPlainObject(parsed.config)) return null;
+	return {
+		extends: typeof parsed.config.extends === "string" ? parsed.config.extends : void 0,
+		referencePaths: normalizeReferencePaths(parsed.config.references),
+		compilerOptions: normalizeCompilerOptions(parsed.config.compilerOptions)
+	};
+};
+const normalizeReferencePaths = (references) => {
+	if (!Array.isArray(references)) return [];
+	return references.map((reference) => isPlainObject(reference) && typeof reference.path === "string" ? reference.path : null).filter((referencePath) => referencePath !== null);
+};
+const mergeCompilerOptions = (inherited, current) => {
+	const target = current.target ?? inherited?.target;
+	const hasExplicitLib = current.hasExplicitLib || Boolean(inherited?.hasExplicitLib);
+	return {
+		target,
+		lib: current.hasExplicitLib ? current.lib : inherited?.lib,
+		hasExplicitLib
+	};
+};
+const readResolvedCompilerOptions = (tsConfigPath, extendsDepth, visitedPaths) => {
+	const realPath = NFS.realpathSync.native(tsConfigPath);
+	if (visitedPaths.has(realPath)) return null;
+	const tsConfig = readTsConfig(realPath);
+	if (!tsConfig) return null;
+	const nextVisitedPaths = new Set(visitedPaths);
+	nextVisitedPaths.add(realPath);
+	if (tsConfig.extends && extendsDepth < 8) {
+		const parentPath = resolveExtendsPath(tsConfig.extends, Path.dirname(realPath));
+		if (parentPath && isFile(parentPath)) return mergeCompilerOptions(readResolvedCompilerOptions(parentPath, extendsDepth + 1, nextVisitedPaths), tsConfig.compilerOptions);
+	}
+	return tsConfig.compilerOptions;
+};
+const targetYearIsPreES2023 = (target) => {
+	const year = ES_TARGET_YEAR_BY_NAME[target.toLowerCase()];
+	return year !== void 0 && year < 2023;
+};
+const libEntryIncludesES2023Array = (entry) => {
+	const normalizedEntry = entry.toLowerCase();
+	if (normalizedEntry === "esnext" || normalizedEntry === "esnext.array") return true;
+	const esYearMatch = /^es(\d{4})(?:\.(.+))?$/.exec(normalizedEntry);
+	if (!esYearMatch) return false;
+	if (Number(esYearMatch[1]) < 2023) return false;
+	const component = esYearMatch[2];
+	return component === void 0 || component === "array";
+};
+const libIncludesES2023 = (lib) => lib.some(libEntryIncludesES2023Array);
+const compilerOptionsArePreES2023 = (compilerOptions) => {
+	if (compilerOptions.target) return targetYearIsPreES2023(compilerOptions.target);
+	if (compilerOptions.hasExplicitLib) return !libIncludesES2023(compilerOptions.lib ?? []);
+	return false;
+};
+const compilerOptionsDeclareTargetOrLib = (compilerOptions) => compilerOptions.hasExplicitLib || compilerOptions.target !== void 0;
+const detectPreES2023FromConfig = (tsConfigPath, visitedConfigPaths = /* @__PURE__ */ new Set()) => {
+	if (visitedConfigPaths.has(tsConfigPath)) return false;
+	const compilerOptions = readResolvedCompilerOptions(tsConfigPath, 0, /* @__PURE__ */ new Set());
+	if (!compilerOptions) return false;
+	if (!compilerOptionsDeclareTargetOrLib(compilerOptions)) {
+		const tsConfig = readTsConfig(tsConfigPath);
+		if (!tsConfig) return false;
+		const nextVisitedConfigPaths = new Set(visitedConfigPaths);
+		nextVisitedConfigPaths.add(tsConfigPath);
+		const configDirectory = Path.dirname(tsConfigPath);
+		return tsConfig.referencePaths.some((referencePath) => {
+			const resolvedReferencePath = Path.resolve(configDirectory, referencePath);
+			const referencedConfigPath = isFile(resolvedReferencePath) ? resolvedReferencePath : Path.join(resolvedReferencePath, TSCONFIG_FILENAME);
+			return isFile(referencedConfigPath) && detectPreES2023FromConfig(referencedConfigPath, nextVisitedConfigPaths);
+		});
+	}
+	return compilerOptionsArePreES2023(compilerOptions);
+};
+const detectPreES2023Target = (directory) => {
+	const tsConfigPath = Path.join(directory, TSCONFIG_FILENAME);
+	if (isFile(tsConfigPath)) return detectPreES2023FromConfig(tsConfigPath);
+	for (const fallbackFilename of FALLBACK_TSCONFIG_FILENAMES) {
+		const fallbackPath = Path.join(directory, fallbackFilename);
+		if (isFile(fallbackPath)) return detectPreES2023FromConfig(fallbackPath);
+	}
+	return false;
+};
+const FALLBACK_TSCONFIG_FILENAMES = ["tsconfig.app.json", "tsconfig.build.json"];
+const FRAMEWORK_PACKAGES = {
+	next: "nextjs",
+	"@tanstack/react-start": "tanstack-start",
+	vite: "vite",
+	"react-scripts": "cra",
+	"@remix-run/react": "remix",
+	gatsby: "gatsby",
+	expo: "expo",
+	"react-native": "react-native"
+};
+const detectFramework = (dependencies) => {
+	for (const [packageName, frameworkName] of Object.entries(FRAMEWORK_PACKAGES)) if (dependencies[packageName]) return frameworkName;
+	if (dependencies.preact && !dependencies.react) return "preact";
+	return "unknown";
+};
+const MOBILE_FRAMEWORKS = new Set(["expo", "react-native"]);
+const frameworkMergeRank = (framework) => {
+	if (framework === "unknown") return 3;
+	return MOBILE_FRAMEWORKS.has(framework) ? 2 : 1;
+};
 const REACT_COMPILER_PACKAGES = new Set([
 	"babel-plugin-react-compiler",
 	"react-compiler-runtime",
@@ -36362,6 +36503,7 @@ const EXPO_APP_CONFIG_FILENAMES = [
 ];
 const REACT_COMPILER_PACKAGE_REFERENCE_PATTERN = /babel-plugin-react-compiler|react-compiler-runtime|eslint-plugin-react-compiler|["']react-compiler["']/;
 const REACT_COMPILER_ENABLED_FLAG_PATTERN = /["']?reactCompiler["']?\s*:\s*(?:true\b|\{)/;
+const STATIC_EXPORT_OUTPUT_PATTERN = /(?:^|[^.\w])["']?output["']?\s*:\s*["']export["']/m;
 const hasCompilerPackage = (packageJson) => {
 	const allDependencies = {
 		...packageJson.peerDependencies,
@@ -36394,34 +36536,10 @@ const detectReactCompiler = (directory, packageJson) => {
 	}
 	return false;
 };
-const FRAMEWORK_PACKAGES = {
-	next: "nextjs",
-	"@tanstack/react-start": "tanstack-start",
-	vite: "vite",
-	"react-scripts": "cra",
-	"@remix-run/react": "remix",
-	gatsby: "gatsby",
-	expo: "expo",
-	"react-native": "react-native"
-};
-const FRAMEWORK_DISPLAY_NAMES = {
-	nextjs: "Next.js",
-	"tanstack-start": "TanStack Start",
-	vite: "Vite",
-	cra: "Create React App",
-	remix: "Remix",
-	gatsby: "Gatsby",
-	expo: "Expo",
-	"react-native": "React Native",
-	preact: "Preact",
-	unknown: "React"
-};
-const formatFrameworkName = (framework) => FRAMEWORK_DISPLAY_NAMES[framework];
-const detectFramework = (dependencies) => {
-	for (const [packageName, frameworkName] of Object.entries(FRAMEWORK_PACKAGES)) if (dependencies[packageName]) return frameworkName;
-	if (dependencies.preact && !dependencies.react) return "preact";
-	return "unknown";
-};
+const detectNextjsStaticExport = (directory) => NEXT_CONFIG_FILENAMES.some((filename) => {
+	const filePath = Path.join(directory, filename);
+	return isFile(filePath) && STATIC_EXPORT_OUTPUT_PATTERN.test(NFS.readFileSync(filePath, "utf-8"));
+});
 const UNRESOLVABLE_PROTOCOL_VERSION = /^(?:file|git|github|https?|link|patch|portal|workspace|npm):/i;
 const DIST_TAG_VERSION = /^[a-z][a-z0-9._-]*$/i;
 const WILDCARD_VERSION = /^[*xX](?:\.[*xX])*$/;
@@ -36559,10 +36677,76 @@ const isConcreteDependencyVersion = (version) => {
 	const normalizedVersion = normalizeDependencyVersion(version);
 	return normalizedVersion !== null && /\d/.test(normalizedVersion);
 };
-const isPlainObject = (value) => {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype;
+const isMajorMinorAtLeast = (detected, required) => {
+	if (detected === null) return true;
+	if (detected.major !== required.major) return detected.major > required.major;
+	return detected.minor >= required.minor;
+};
+const parseReactMajor = (reactVersion) => {
+	if (typeof reactVersion !== "string") return null;
+	return getLowestDependencyMajor(reactVersion);
+};
+const MAJOR_MINOR_PATTERN = /(\d{1,4})\.(\d{1,4})/;
+const MAJOR_ONLY_PATTERN = /(\d{1,4})/;
+const UPPER_BOUND_COMPARATOR_PATTERN = /<=?\s{0,8}\d{1,4}(?:\.\d{1,4}){0,2}(?:-[^\s,|]+)?/g;
+const parseReactMajorMinor = (reactVersion) => {
+	if (typeof reactVersion !== "string") return null;
+	const trimmed = reactVersion.trim();
+	if (trimmed.length === 0) return null;
+	const lowerBoundsOnly = trimmed.replace(UPPER_BOUND_COMPARATOR_PATTERN, " ").trim();
+	if (lowerBoundsOnly.length === 0) return null;
+	const majorMinorMatch = lowerBoundsOnly.match(MAJOR_MINOR_PATTERN);
+	if (majorMinorMatch) {
+		const major = Number.parseInt(majorMinorMatch[1], 10);
+		const minor = Number.parseInt(majorMinorMatch[2], 10);
+		if (!Number.isFinite(major) || major <= 0) return null;
+		if (!Number.isFinite(minor) || minor < 0) return null;
+		return {
+			major,
+			minor
+		};
+	}
+	const majorOnlyMatch = lowerBoundsOnly.match(MAJOR_ONLY_PATTERN);
+	if (!majorOnlyMatch) return null;
+	const major = Number.parseInt(majorOnlyMatch[1], 10);
+	if (!Number.isFinite(major) || major <= 0) return null;
+	return {
+		major,
+		minor: 0
+	};
+};
+const parseLowerBoundVersion = (versionSpec) => import_semver.validRange(versionSpec) !== null ? import_semver.minVersion(versionSpec) : import_semver.coerce(versionSpec);
+const parseTailwindMajorMinor = (tailwindVersion) => {
+	if (typeof tailwindVersion !== "string") return null;
+	const trimmed = tailwindVersion.trim();
+	if (trimmed.length === 0) return null;
+	const lowerBound = parseLowerBoundVersion(trimmed);
+	if (lowerBound === null || lowerBound.major <= 0) return null;
+	return {
+		major: lowerBound.major,
+		minor: lowerBound.minor
+	};
+};
+const hasUpperBoundOnlyPeerRange = (range) => {
+	if (typeof range !== "string") return false;
+	const normalizedRange = normalizeDependencyVersion(range);
+	if (normalizedRange === null) return false;
+	return splitDependencyVersionBranches(normalizedRange).some((branch) => {
+		const normalizedBranch = normalizeDependencyVersion(branch);
+		return normalizedBranch !== null && getBranchLowestMajor(normalizedBranch) === null && hasUpperBoundComparator(normalizedBranch);
+	});
+};
+const peerRangeMinMajor = (range) => {
+	if (typeof range !== "string") return null;
+	return getLowestDependencyMajor(range);
+};
+const resolveEffectiveReactMajor = (reactVersion, packageJson) => {
+	const installedReactMajor = parseReactMajor(reactVersion);
+	const peerReactRange = packageJson.peerDependencies?.react;
+	if (typeof peerReactRange !== "string") return installedReactMajor;
+	const peerFloor = peerRangeMinMajor(peerReactRange);
+	if (peerFloor === null) return hasUpperBoundOnlyPeerRange(peerReactRange) ? null : installedReactMajor;
+	return installedReactMajor !== null ? Math.min(installedReactMajor, peerFloor) : peerFloor;
 };
 const isCatalogReference = (version) => version.startsWith("catalog:");
 const extractCatalogName = (version) => {
@@ -36704,6 +36888,16 @@ const resolveCatalogVersion = (packageJson, packageName, rootDirectory, explicit
 	}
 	return null;
 };
+const REACT_SECTIONS = [
+	"dependencies",
+	"peerDependencies",
+	"devDependencies"
+];
+const TAILWIND_ZOD_SECTIONS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies"
+];
 const EMPTY_DEPENDENCY_INFO = {
 	reactVersion: null,
 	tailwindVersion: null,
@@ -36744,6 +36938,10 @@ const extractDependencyInfo = (packageJson) => {
 		framework: detectFramework(allDependencies)
 	};
 };
+const getDependencySpec = (packageJson, packageName) => {
+	const spec = packageJson.dependencies?.[packageName] ?? packageJson.devDependencies?.[packageName] ?? packageJson.peerDependencies?.[packageName] ?? packageJson.optionalDependencies?.[packageName];
+	return typeof spec === "string" ? spec : null;
+};
 const getDependencyDeclaration = ({ packageJson, packageName, sections }) => {
 	for (const section of sections) {
 		const version = packageJson[section]?.[packageName];
@@ -36760,31 +36958,141 @@ const getDependencyDeclaration = ({ packageJson, packageName, sections }) => {
 		version: null
 	};
 };
-const isDirectory = (directoryPath) => {
-	try {
-		return NFS.statSync(directoryPath).isDirectory();
-	} catch {
-		return false;
+const REACT_DEPENDENCY_NAMES = new Set([
+	"react",
+	"react-native",
+	"next",
+	"preact"
+]);
+const hasReactDependency = (packageJson) => {
+	const allDependencies = {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	return Object.keys(allDependencies).some((packageName) => REACT_DEPENDENCY_NAMES.has(packageName));
+};
+const getPreactVersion = (packageJson) => {
+	return {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	}.preact ?? null;
+};
+const TANSTACK_QUERY_PACKAGES = new Set([
+	"@tanstack/react-query",
+	"@tanstack/query-core",
+	"react-query"
+]);
+const hasTanStackQuery = (packageJson) => {
+	const allDependencies = {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	return Object.keys(allDependencies).some((packageName) => TANSTACK_QUERY_PACKAGES.has(packageName));
+};
+const resolveCatalogBackedDependencyVersion = ({ rootDirectory, rootPackageJson, packageName, version }) => {
+	if (version === null || !isCatalogReference(version)) return version;
+	const catalogName = extractCatalogName(version);
+	const resolvedLocalVersion = resolveCatalogVersion(rootPackageJson, packageName, rootDirectory, catalogName);
+	if (resolvedLocalVersion) return resolvedLocalVersion;
+	const monorepoRoot = findMonorepoRoot(rootDirectory);
+	if (!monorepoRoot) return version;
+	const monorepoPackageJsonPath = Path.join(monorepoRoot, "package.json");
+	if (!isFile(monorepoPackageJsonPath)) return version;
+	return resolveCatalogVersion(readPackageJson$1(monorepoPackageJsonPath), packageName, monorepoRoot, catalogName) ?? version;
+};
+/**
+* The chain of ancestor directories of `startDirectory`, nearest first, up to
+* and including the filesystem root. With `includeStart`, the chain begins at
+* `startDirectory` itself; otherwise at its parent. The one place the "walk up
+* the tree" traversal is expressed, so each caller adds only its own match /
+* stop policy instead of re-deriving the `path.dirname` loop.
+*/
+const ancestorDirectories = (startDirectory, { includeStart }) => {
+	const directories = [];
+	let currentDirectory = includeStart ? startDirectory : Path.dirname(startDirectory);
+	while (true) {
+		directories.push(currentDirectory);
+		const parentDirectory = Path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) return directories;
+		currentDirectory = parentDirectory;
 	}
 };
-const NX_PROJECT_DISCOVERY_DIRS = [
-	"apps",
-	"libs",
-	"packages"
-];
-const getNxWorkspaceDirectories = (rootDirectory) => {
-	if (!isFile(Path.join(rootDirectory, "nx.json"))) return [];
-	const collected = [];
-	for (const candidate of NX_PROJECT_DISCOVERY_DIRS) {
-		const candidatePath = Path.join(rootDirectory, candidate);
-		if (!isDirectory(candidatePath)) continue;
-		for (const entry of readDirectoryEntries(candidatePath)) {
-			if (!entry.isDirectory()) continue;
-			const projectDirectory = Path.join(candidatePath, entry.name);
-			if (isFile(Path.join(projectDirectory, "project.json")) || isFile(Path.join(projectDirectory, "package.json"))) collected.push(`${candidate}/${entry.name}`);
-		}
+/**
+* Walk up from `startDirectory` to the nearest ancestor that owns a
+* `package.json`, stopping at (and including) the enclosing project boundary
+* — the working tree's git root or a monorepo root. Lets a scan of a package
+* subfolder that has no `package.json` of its own adopt the nearest enclosing
+* package as its project root, so it inherits that package's dependency +
+* framework detection instead of synthesizing an empty (React-blind) project.
+*
+* Generalizes the older monorepo-root-only lookup: the nearest ancestor is the
+* most specific owning package (a leaf workspace, not just the repo root), so
+* a subfolder of one workspace no longer borrows a sibling's capabilities.
+*
+* Returns `null` when no ancestor `package.json` exists inside the project
+* boundary (a loose tree of files, or a subfolder of a package-less repo).
+*/
+const findNearestAncestorPackageJson = (startDirectory) => {
+	if (isProjectBoundary(startDirectory)) return null;
+	for (const directory of ancestorDirectories(startDirectory, { includeStart: false })) {
+		if (isFile(Path.join(directory, "package.json"))) return directory;
+		if (isProjectBoundary(directory)) return null;
 	}
-	return collected;
+	return null;
+};
+const NAMES = new Set([
+	"react-native",
+	"react-native-tvos",
+	...new Set([
+		"expo",
+		"expo-router",
+		"@expo/cli",
+		"@expo/metro-config",
+		"@expo/metro-runtime"
+	]),
+	"react-native-windows",
+	"react-native-macos"
+]);
+const PREFIXES = ["@react-native/", "@react-native-"];
+const isReactNativeDependencyName = (dependencyName) => {
+	if (NAMES.has(dependencyName)) return true;
+	for (const prefix of PREFIXES) if (dependencyName.startsWith(prefix)) return true;
+	return false;
+};
+const containsAnyReactNativeDependency = (section) => {
+	if (!section) return false;
+	for (const dependencyName of Object.keys(section)) if (isReactNativeDependencyName(dependencyName)) return true;
+	return false;
+};
+const isPackageJsonReactNativeAware = (packageJson) => {
+	if (typeof packageJson["react-native"] === "string") return true;
+	if (containsAnyReactNativeDependency(packageJson.dependencies)) return true;
+	if (containsAnyReactNativeDependency(packageJson.devDependencies)) return true;
+	if (containsAnyReactNativeDependency(packageJson.peerDependencies)) return true;
+	if (containsAnyReactNativeDependency(packageJson.optionalDependencies)) return true;
+	return false;
+};
+const REANIMATED_DEPENDENCY_NAME$1 = "react-native-reanimated";
+const isPackageJsonReanimatedAware = (packageJson) => {
+	const allDependencies = {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies,
+		...packageJson.optionalDependencies
+	};
+	return Object.hasOwn(allDependencies, REANIMATED_DEPENDENCY_NAME$1);
+};
+const getWorkspacePatterns = (rootDirectory, packageJson) => {
+	const pnpmPatterns = parsePnpmWorkspacePatterns(rootDirectory);
+	if (pnpmPatterns.length > 0) return pnpmPatterns;
+	if (Array.isArray(packageJson.workspaces)) return packageJson.workspaces;
+	if (packageJson.workspaces?.packages) return packageJson.workspaces.packages;
+	const nxPatterns = getNxWorkspaceDirectories(rootDirectory);
+	if (nxPatterns.length > 0) return nxPatterns;
+	return [];
 };
 const parsePnpmWorkspacePatterns = (rootDirectory) => {
 	const workspacePath = Path.join(rootDirectory, "pnpm-workspace.yaml");
@@ -36803,18 +37111,24 @@ const parsePnpmWorkspacePatterns = (rootDirectory) => {
 	}
 	return patterns;
 };
-const getWorkspacePatterns = (rootDirectory, packageJson) => {
-	const pnpmPatterns = parsePnpmWorkspacePatterns(rootDirectory);
-	if (pnpmPatterns.length > 0) return pnpmPatterns;
-	if (Array.isArray(packageJson.workspaces)) return packageJson.workspaces;
-	if (packageJson.workspaces?.packages) return packageJson.workspaces.packages;
-	const nxPatterns = getNxWorkspaceDirectories(rootDirectory);
-	if (nxPatterns.length > 0) return nxPatterns;
-	return [];
-};
-const parseReactMajor = (reactVersion) => {
-	if (typeof reactVersion !== "string") return null;
-	return getLowestDependencyMajor(reactVersion);
+const NX_PROJECT_DISCOVERY_DIRS = [
+	"apps",
+	"libs",
+	"packages"
+];
+const getNxWorkspaceDirectories = (rootDirectory) => {
+	if (!isFile(Path.join(rootDirectory, "nx.json"))) return [];
+	const collected = [];
+	for (const candidate of NX_PROJECT_DISCOVERY_DIRS) {
+		const candidatePath = Path.join(rootDirectory, candidate);
+		if (!isDirectory(candidatePath)) continue;
+		for (const entry of readDirectoryEntries(candidatePath)) {
+			if (!entry.isDirectory()) continue;
+			const projectDirectory = Path.join(candidatePath, entry.name);
+			if (isFile(Path.join(projectDirectory, "project.json")) || isFile(Path.join(projectDirectory, "package.json"))) collected.push(`${candidate}/${entry.name}`);
+		}
+	}
+	return collected;
 };
 const resolveWorkspaceDirectories = (rootDirectory, pattern) => {
 	const cleanPattern = pattern.replace(/["']/g, "").replace(/\/\*\*$/, "/*");
@@ -36834,6 +37148,38 @@ const resolveWorkspaceDirectories = (rootDirectory, pattern) => {
 	}
 	return resolved;
 };
+const listWorkspacePackages = (rootDirectory) => {
+	const packageJsonPath = Path.join(rootDirectory, "package.json");
+	if (!isFile(packageJsonPath)) return [];
+	const packageJson = readPackageJson$1(packageJsonPath);
+	const patterns = getWorkspacePatterns(rootDirectory, packageJson);
+	if (patterns.length === 0) return [];
+	const packages = [];
+	const seenDirectories = /* @__PURE__ */ new Set();
+	const pushIfNew = (workspacePackage) => {
+		if (seenDirectories.has(workspacePackage.directory)) return;
+		seenDirectories.add(workspacePackage.directory);
+		packages.push(workspacePackage);
+	};
+	if (hasReactDependency(packageJson)) pushIfNew({
+		name: packageJson.name ?? Path.basename(rootDirectory),
+		directory: rootDirectory
+	});
+	for (const pattern of patterns) {
+		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
+		for (const workspaceDirectory of directories) {
+			const workspacePackageJson = readPackageJson$1(Path.join(workspaceDirectory, "package.json"));
+			if (!hasReactDependency(workspacePackageJson)) continue;
+			pushIfNew({
+				name: workspacePackageJson.name ?? Path.basename(workspaceDirectory),
+				directory: workspaceDirectory
+			});
+		}
+	}
+	return packages;
+};
+const REANIMATED_DEPENDENCY_NAME = "react-native-reanimated";
+const SHOPIFY_FLASH_LIST_PACKAGE_NAME = "@shopify/flash-list";
 const resolveWorkspaceDependencyVersion = ({ concreteVersion, packageName, rootDirectory, rootPackageJson, sections, workspaceDirectory, workspacePackageJson }) => {
 	const dependencyDeclaration = getDependencyDeclaration({
 		packageJson: workspacePackageJson,
@@ -36851,24 +37197,76 @@ const shouldReplaceReactVersion = (currentVersion, nextVersion) => {
 	if (nextMajor === null) return false;
 	return nextMajor < currentMajor;
 };
-const findReactInWorkspaces = (rootDirectory, packageJson) => {
-	const patterns = getWorkspacePatterns(rootDirectory, packageJson);
-	const result = { ...EMPTY_DEPENDENCY_INFO };
-	for (const pattern of patterns) {
-		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
+const evaluateManifestFacts = (facts, packageJson, directory) => {
+	if (facts.expo.version === null) {
+		const spec = getDependencySpec(packageJson, "expo");
+		if (spec !== null) facts.expo = {
+			version: spec,
+			sourceDirectory: directory
+		};
+	}
+	if (facts.next.version === null) {
+		const spec = getDependencySpec(packageJson, "next");
+		if (spec !== null) facts.next = {
+			version: spec,
+			sourceDirectory: directory
+		};
+	}
+	if (facts.shopifyFlashList.version === null) {
+		const spec = getDependencySpec(packageJson, SHOPIFY_FLASH_LIST_PACKAGE_NAME);
+		if (spec !== null) facts.shopifyFlashList = {
+			version: spec,
+			sourceDirectory: directory
+		};
+	}
+	if (facts.reanimatedVersion === null) {
+		const spec = getDependencySpec(packageJson, REANIMATED_DEPENDENCY_NAME);
+		if (spec !== null) facts.reanimatedVersion = spec;
+	}
+	facts.hasReactNativeAwarePackage = facts.hasReactNativeAwarePackage || isPackageJsonReactNativeAware(packageJson);
+	facts.hasReanimatedAwarePackage = facts.hasReanimatedAwarePackage || isPackageJsonReanimatedAware(packageJson);
+};
+const collectWorkspaceFacts = (rootDirectory, rootPackageJson, { collectReactGroup }) => {
+	const facts = {
+		reactVersion: null,
+		tailwindVersion: null,
+		zodVersion: null,
+		framework: "unknown",
+		expo: {
+			version: null,
+			sourceDirectory: null
+		},
+		next: {
+			version: null,
+			sourceDirectory: null
+		},
+		shopifyFlashList: {
+			version: null,
+			sourceDirectory: null
+		},
+		hasReactNativeAwarePackage: false,
+		hasReanimatedAwarePackage: false,
+		reanimatedVersion: null
+	};
+	evaluateManifestFacts(facts, rootPackageJson, rootDirectory);
+	let isReactGroupSettled = !collectReactGroup;
+	const visitedDirectories = /* @__PURE__ */ new Set();
+	for (const pattern of getWorkspacePatterns(rootDirectory, rootPackageJson)) {
+		const directories = [...resolveWorkspaceDirectories(rootDirectory, pattern)].sort();
 		for (const workspaceDirectory of directories) {
+			if (visitedDirectories.has(workspaceDirectory)) continue;
+			visitedDirectories.add(workspaceDirectory);
 			const workspacePackageJson = readPackageJson$1(Path.join(workspaceDirectory, "package.json"));
+			evaluateManifestFacts(facts, workspacePackageJson, workspaceDirectory);
 			const info = extractDependencyInfo(workspacePackageJson);
+			if (info.framework !== "unknown" && frameworkMergeRank(info.framework) < frameworkMergeRank(facts.framework)) facts.framework = info.framework;
+			if (isReactGroupSettled) continue;
 			const reactVersion = resolveWorkspaceDependencyVersion({
 				concreteVersion: info.reactVersion,
 				packageName: "react",
 				rootDirectory,
-				rootPackageJson: packageJson,
-				sections: [
-					"dependencies",
-					"peerDependencies",
-					"devDependencies"
-				],
+				rootPackageJson,
+				sections: REACT_SECTIONS,
 				workspaceDirectory,
 				workspacePackageJson
 			});
@@ -36876,12 +37274,8 @@ const findReactInWorkspaces = (rootDirectory, packageJson) => {
 				concreteVersion: info.tailwindVersion,
 				packageName: "tailwindcss",
 				rootDirectory,
-				rootPackageJson: packageJson,
-				sections: [
-					"dependencies",
-					"devDependencies",
-					"peerDependencies"
-				],
+				rootPackageJson,
+				sections: TAILWIND_ZOD_SECTIONS,
 				workspaceDirectory,
 				workspacePackageJson
 			});
@@ -36889,24 +37283,19 @@ const findReactInWorkspaces = (rootDirectory, packageJson) => {
 				concreteVersion: info.zodVersion,
 				packageName: "zod",
 				rootDirectory,
-				rootPackageJson: packageJson,
-				sections: [
-					"dependencies",
-					"devDependencies",
-					"peerDependencies"
-				],
+				rootPackageJson,
+				sections: TAILWIND_ZOD_SECTIONS,
 				workspaceDirectory,
 				workspacePackageJson
 			});
-			if (reactVersion && shouldReplaceReactVersion(result.reactVersion, reactVersion)) result.reactVersion = reactVersion;
-			if (tailwindVersion && !result.tailwindVersion) result.tailwindVersion = tailwindVersion;
-			if (zodVersion && !result.zodVersion) result.zodVersion = zodVersion;
-			if (info.framework !== "unknown" && result.framework === "unknown") result.framework = info.framework;
-			const resultReactMajor = parseReactMajor(result.reactVersion);
-			if (result.reactVersion && result.tailwindVersion && result.framework !== "unknown" && resultReactMajor !== null && resultReactMajor <= 17) return result;
+			if (reactVersion && shouldReplaceReactVersion(facts.reactVersion, reactVersion)) facts.reactVersion = reactVersion;
+			if (tailwindVersion && !facts.tailwindVersion) facts.tailwindVersion = tailwindVersion;
+			if (zodVersion && !facts.zodVersion) facts.zodVersion = zodVersion;
+			const settledReactMajor = parseReactMajor(facts.reactVersion);
+			isReactGroupSettled = Boolean(facts.reactVersion && facts.tailwindVersion && facts.framework !== "unknown" && settledReactMajor !== null && settledReactMajor <= 17);
 		}
 	}
-	return result;
+	return facts;
 };
 const findDependencyInfoFromMonorepoRoot = (directory) => {
 	const monorepoRoot = findMonorepoRoot(directory);
@@ -36920,29 +37309,17 @@ const findDependencyInfoFromMonorepoRoot = (directory) => {
 	const leafReactDeclaration = leafPackageJson ? getDependencyDeclaration({
 		packageJson: leafPackageJson,
 		packageName: "react",
-		sections: [
-			"dependencies",
-			"peerDependencies",
-			"devDependencies"
-		]
+		sections: REACT_SECTIONS
 	}) : null;
 	const leafTailwindDeclaration = leafPackageJson ? getDependencyDeclaration({
 		packageJson: leafPackageJson,
 		packageName: "tailwindcss",
-		sections: [
-			"dependencies",
-			"devDependencies",
-			"peerDependencies"
-		]
+		sections: TAILWIND_ZOD_SECTIONS
 	}) : null;
 	const leafZodDeclaration = leafPackageJson ? getDependencyDeclaration({
 		packageJson: leafPackageJson,
 		packageName: "zod",
-		sections: [
-			"dependencies",
-			"devDependencies",
-			"peerDependencies"
-		]
+		sections: TAILWIND_ZOD_SECTIONS
 	}) : null;
 	const shouldUseReactFallback = !leafReactDeclaration?.hasDeclaration;
 	const shouldUseTailwindFallback = leafTailwindDeclaration?.hasDeclaration ?? true;
@@ -36950,38 +37327,15 @@ const findDependencyInfoFromMonorepoRoot = (directory) => {
 	const reactCatalogVersion = shouldUseReactFallback ? resolveCatalogVersion(rootPackageJson, "react", monorepoRoot, leafReactDeclaration?.catalogReference) : null;
 	const tailwindCatalogVersion = shouldUseTailwindFallback ? resolveCatalogVersion(rootPackageJson, "tailwindcss", monorepoRoot, leafTailwindDeclaration?.catalogReference) : null;
 	const zodCatalogVersion = shouldUseZodFallback ? resolveCatalogVersion(rootPackageJson, "zod", monorepoRoot, leafZodDeclaration?.catalogReference) : null;
-	const workspaceInfo = findReactInWorkspaces(monorepoRoot, rootPackageJson);
+	const workspaceFacts = collectWorkspaceFacts(monorepoRoot, rootPackageJson, { collectReactGroup: true });
 	return {
-		reactVersion: shouldUseReactFallback ? reactCatalogVersion ?? rootInfo.reactVersion ?? workspaceInfo.reactVersion : rootInfo.reactVersion ?? workspaceInfo.reactVersion,
-		tailwindVersion: shouldUseTailwindFallback ? tailwindCatalogVersion ?? rootInfo.tailwindVersion ?? workspaceInfo.tailwindVersion : null,
-		zodVersion: shouldUseZodFallback ? zodCatalogVersion ?? rootInfo.zodVersion ?? workspaceInfo.zodVersion : null,
-		framework: rootInfo.framework !== "unknown" ? rootInfo.framework : workspaceInfo.framework
+		reactVersion: shouldUseReactFallback ? reactCatalogVersion ?? rootInfo.reactVersion ?? workspaceFacts.reactVersion : rootInfo.reactVersion ?? workspaceFacts.reactVersion,
+		tailwindVersion: shouldUseTailwindFallback ? tailwindCatalogVersion ?? rootInfo.tailwindVersion ?? workspaceFacts.tailwindVersion : null,
+		zodVersion: shouldUseZodFallback ? zodCatalogVersion ?? rootInfo.zodVersion ?? workspaceFacts.zodVersion : null,
+		framework: rootInfo.framework !== "unknown" ? rootInfo.framework : workspaceFacts.framework
 	};
 };
 /**
-* Walk up from `startDirectory` to the nearest ancestor that owns a
-* `package.json`, stopping at (and including) the enclosing project boundary
-* — the working tree's git root or a monorepo root. Lets a scan of a package
-* subfolder that has no `package.json` of its own adopt the nearest enclosing
-* package as its project root, so it inherits that package's dependency +
-* framework detection instead of synthesizing an empty (React-blind) project.
-*
-* Generalizes the older monorepo-root-only lookup: the nearest ancestor is the
-* most specific owning package (a leaf workspace, not just the repo root), so
-* a subfolder of one workspace no longer borrows a sibling's capabilities.
-*
-* Returns `null` when no ancestor `package.json` exists inside the project
-* boundary (a loose tree of files, or a subfolder of a package-less repo).
-*/
-const findNearestAncestorPackageJson = (startDirectory) => {
-	if (isProjectBoundary(startDirectory)) return null;
-	for (const directory of ancestorDirectories(startDirectory, { includeStart: false })) {
-		if (isFile(Path.join(directory, "package.json"))) return directory;
-		if (isProjectBoundary(directory)) return null;
-	}
-	return null;
-};
-/**
 * Last-resort React detection: locate React the way Node's `node_modules`
 * resolution would from `directory` — check each `node_modules/react` up the
 * tree — but bounded to the enclosing repo so a globally installed React can't
@@ -37026,295 +37380,6 @@ const resolveInstalledReactVersion = (directory) => {
 	}
 	return null;
 };
-const findInWorkspacePackageJsons = (rootDirectory, rootPackageJson, select) => {
-	const rootValue = select(rootPackageJson);
-	if (rootValue !== null) return rootValue;
-	const patterns = getWorkspacePatterns(rootDirectory, rootPackageJson);
-	if (patterns.length === 0) return null;
-	const visitedDirectories = /* @__PURE__ */ new Set();
-	for (const pattern of patterns) {
-		const directories = [...resolveWorkspaceDirectories(rootDirectory, pattern)].sort();
-		for (const workspaceDirectory of directories) {
-			if (visitedDirectories.has(workspaceDirectory)) continue;
-			visitedDirectories.add(workspaceDirectory);
-			const value = select(readPackageJson$1(Path.join(workspaceDirectory, "package.json")));
-			if (value !== null) return value;
-		}
-	}
-	return null;
-};
-const someWorkspacePackageJson = (rootDirectory, rootPackageJson, predicate) => findInWorkspacePackageJsons(rootDirectory, rootPackageJson, (packageJson) => predicate(packageJson) ? true : null) !== null;
-const NAMES = new Set([
-	"react-native",
-	"react-native-tvos",
-	...new Set([
-		"expo",
-		"expo-router",
-		"@expo/cli",
-		"@expo/metro-config",
-		"@expo/metro-runtime"
-	]),
-	"react-native-windows",
-	"react-native-macos"
-]);
-const PREFIXES = ["@react-native/", "@react-native-"];
-const isReactNativeDependencyName = (dependencyName) => {
-	if (NAMES.has(dependencyName)) return true;
-	for (const prefix of PREFIXES) if (dependencyName.startsWith(prefix)) return true;
-	return false;
-};
-const containsAnyReactNativeDependency = (section) => {
-	if (!section) return false;
-	for (const dependencyName of Object.keys(section)) if (isReactNativeDependencyName(dependencyName)) return true;
-	return false;
-};
-const isPackageJsonReactNativeAware = (packageJson) => {
-	if (typeof packageJson["react-native"] === "string") return true;
-	if (containsAnyReactNativeDependency(packageJson.dependencies)) return true;
-	if (containsAnyReactNativeDependency(packageJson.devDependencies)) return true;
-	if (containsAnyReactNativeDependency(packageJson.peerDependencies)) return true;
-	if (containsAnyReactNativeDependency(packageJson.optionalDependencies)) return true;
-	return false;
-};
-const hasReactNativeWorkspaceAnywhere = (rootDirectory, rootPackageJson) => someWorkspacePackageJson(rootDirectory, rootPackageJson, isPackageJsonReactNativeAware);
-const getDependencySpec = (packageJson, packageName) => {
-	const spec = packageJson.dependencies?.[packageName] ?? packageJson.devDependencies?.[packageName] ?? packageJson.peerDependencies?.[packageName] ?? packageJson.optionalDependencies?.[packageName];
-	return typeof spec === "string" ? spec : null;
-};
-const findExpoVersion = (rootDirectory, rootPackageJson) => findInWorkspacePackageJsons(rootDirectory, rootPackageJson, (packageJson) => getDependencySpec(packageJson, "expo"));
-const SHOPIFY_FLASH_LIST_PACKAGE_NAME = "@shopify/flash-list";
-const findShopifyFlashListVersion = (rootDirectory, rootPackageJson) => findInWorkspacePackageJsons(rootDirectory, rootPackageJson, (packageJson) => getDependencySpec(packageJson, SHOPIFY_FLASH_LIST_PACKAGE_NAME));
-const resolveCatalogBackedDependencyVersion = ({ rootDirectory, rootPackageJson, packageName, version }) => {
-	if (version === null || !isCatalogReference(version)) return version;
-	const catalogName = extractCatalogName(version);
-	const resolvedLocalVersion = resolveCatalogVersion(rootPackageJson, packageName, rootDirectory, catalogName);
-	if (resolvedLocalVersion) return resolvedLocalVersion;
-	const monorepoRoot = findMonorepoRoot(rootDirectory);
-	if (!monorepoRoot) return version;
-	const monorepoPackageJsonPath = path.join(monorepoRoot, "package.json");
-	if (!isFile(monorepoPackageJsonPath)) return version;
-	return resolveCatalogVersion(readPackageJson$1(monorepoPackageJsonPath), packageName, monorepoRoot, catalogName) ?? version;
-};
-const findNextjsVersion = (rootDirectory, rootPackageJson) => findInWorkspacePackageJsons(rootDirectory, rootPackageJson, (packageJson) => getDependencySpec(packageJson, "next"));
-const getPreactVersion = (packageJson) => {
-	return {
-		...packageJson.peerDependencies,
-		...packageJson.dependencies,
-		...packageJson.devDependencies
-	}.preact ?? null;
-};
-const TANSTACK_QUERY_PACKAGES = new Set([
-	"@tanstack/react-query",
-	"@tanstack/query-core",
-	"react-query"
-]);
-const hasTanStackQuery = (packageJson) => {
-	const allDependencies = {
-		...packageJson.peerDependencies,
-		...packageJson.dependencies,
-		...packageJson.devDependencies
-	};
-	return Object.keys(allDependencies).some((packageName) => TANSTACK_QUERY_PACKAGES.has(packageName));
-};
-const REANIMATED_DEPENDENCY_NAME = "react-native-reanimated";
-const isPackageJsonReanimatedAware = (packageJson) => {
-	const allDependencies = {
-		...packageJson.peerDependencies,
-		...packageJson.dependencies,
-		...packageJson.devDependencies,
-		...packageJson.optionalDependencies
-	};
-	return Object.hasOwn(allDependencies, REANIMATED_DEPENDENCY_NAME);
-};
-const parseZodMajor = (zodVersion) => {
-	if (typeof zodVersion !== "string") return null;
-	return getLowestDependencyMajor(zodVersion);
-};
-const hasUpperBoundOnlyPeerRange = (range) => {
-	if (typeof range !== "string") return false;
-	const normalizedRange = normalizeDependencyVersion(range);
-	if (normalizedRange === null) return false;
-	return splitDependencyVersionBranches(normalizedRange).some((branch) => {
-		const normalizedBranch = normalizeDependencyVersion(branch);
-		return normalizedBranch !== null && getBranchLowestMajor(normalizedBranch) === null && hasUpperBoundComparator(normalizedBranch);
-	});
-};
-const peerRangeMinMajor = (range) => {
-	if (typeof range !== "string") return null;
-	return getLowestDependencyMajor(range);
-};
-const resolveEffectiveReactMajor = (reactVersion, packageJson) => {
-	const installedReactMajor = parseReactMajor(reactVersion);
-	const peerReactRange = packageJson.peerDependencies?.react;
-	if (typeof peerReactRange !== "string") return installedReactMajor;
-	const peerFloor = peerRangeMinMajor(peerReactRange);
-	if (peerFloor === null) return hasUpperBoundOnlyPeerRange(peerReactRange) ? null : installedReactMajor;
-	return installedReactMajor !== null ? Math.min(installedReactMajor, peerFloor) : peerFloor;
-};
-const TSCONFIG_FILENAME = "tsconfig.json";
-const isRelativeExtendsValue = (extendsValue) => extendsValue.startsWith("./") || extendsValue.startsWith("../") || Path.isAbsolute(extendsValue);
-const ensureJsonExtension = (filePath) => Path.extname(filePath) === "" ? `${filePath}.json` : filePath;
-const resolvePackageExtendsPath = (extendsValue, fromConfigDirectory) => {
-	const requireFromConfig = createRequire(Path.join(fromConfigDirectory, "tsconfig.json"));
-	const candidates = [
-		extendsValue,
-		ensureJsonExtension(extendsValue),
-		`${extendsValue.replace(/\/$/, "")}/tsconfig.json`
-	];
-	for (const candidate of candidates) try {
-		return requireFromConfig.resolve(candidate);
-	} catch {
-		continue;
-	}
-	return null;
-};
-const resolveExtendsPath = (extendsValue, fromConfigDirectory) => {
-	if (isRelativeExtendsValue(extendsValue)) return ensureJsonExtension(Path.resolve(fromConfigDirectory, extendsValue));
-	return resolvePackageExtendsPath(extendsValue, fromConfigDirectory);
-};
-const normalizeCompilerOptions = (compilerOptions) => {
-	if (!isPlainObject(compilerOptions)) return { hasExplicitLib: false };
-	const target = typeof compilerOptions.target === "string" ? compilerOptions.target : void 0;
-	const hasExplicitLib = Object.hasOwn(compilerOptions, "lib");
-	return {
-		target,
-		lib: Array.isArray(compilerOptions.lib) ? compilerOptions.lib.filter((entry) => typeof entry === "string") : void 0,
-		hasExplicitLib
-	};
-};
-const normalizeReferencePaths = (references) => {
-	if (!Array.isArray(references)) return [];
-	return references.map((reference) => isPlainObject(reference) && typeof reference.path === "string" ? reference.path : null).filter((referencePath) => referencePath !== null);
-};
-const readTsConfig = (filePath) => {
-	let content;
-	try {
-		content = NFS.readFileSync(filePath, "utf-8");
-	} catch {
-		return null;
-	}
-	const parsed = ts.parseConfigFileTextToJson(filePath, content);
-	if (!isPlainObject(parsed.config)) return null;
-	return {
-		extends: typeof parsed.config.extends === "string" ? parsed.config.extends : void 0,
-		referencePaths: normalizeReferencePaths(parsed.config.references),
-		compilerOptions: normalizeCompilerOptions(parsed.config.compilerOptions)
-	};
-};
-const mergeCompilerOptions = (inherited, current) => {
-	const target = current.target ?? inherited?.target;
-	const hasExplicitLib = current.hasExplicitLib || Boolean(inherited?.hasExplicitLib);
-	return {
-		target,
-		lib: current.hasExplicitLib ? current.lib : inherited?.lib,
-		hasExplicitLib
-	};
-};
-const readResolvedCompilerOptions = (tsConfigPath, extendsDepth, visitedPaths) => {
-	const realPath = NFS.realpathSync.native(tsConfigPath);
-	if (visitedPaths.has(realPath)) return null;
-	const tsConfig = readTsConfig(realPath);
-	if (!tsConfig) return null;
-	const nextVisitedPaths = new Set(visitedPaths);
-	nextVisitedPaths.add(realPath);
-	if (tsConfig.extends && extendsDepth < 8) {
-		const parentPath = resolveExtendsPath(tsConfig.extends, Path.dirname(realPath));
-		if (parentPath && isFile(parentPath)) return mergeCompilerOptions(readResolvedCompilerOptions(parentPath, extendsDepth + 1, nextVisitedPaths), tsConfig.compilerOptions);
-	}
-	return tsConfig.compilerOptions;
-};
-const targetYearIsPreES2023 = (target) => {
-	const year = ES_TARGET_YEAR_BY_NAME[target.toLowerCase()];
-	return year !== void 0 && year < 2023;
-};
-const libEntryIncludesES2023Array = (entry) => {
-	const normalizedEntry = entry.toLowerCase();
-	if (normalizedEntry === "esnext" || normalizedEntry === "esnext.array") return true;
-	const esYearMatch = /^es(\d{4})(?:\.(.+))?$/.exec(normalizedEntry);
-	if (!esYearMatch) return false;
-	if (Number(esYearMatch[1]) < 2023) return false;
-	const component = esYearMatch[2];
-	return component === void 0 || component === "array";
-};
-const libIncludesES2023 = (lib) => lib.some(libEntryIncludesES2023Array);
-const compilerOptionsArePreES2023 = (compilerOptions) => {
-	if (compilerOptions.target && targetYearIsPreES2023(compilerOptions.target)) return true;
-	if (compilerOptions.hasExplicitLib) return !libIncludesES2023(compilerOptions.lib ?? []);
-	return false;
-};
-const compilerOptionsDeclareTargetOrLib = (compilerOptions) => compilerOptions.hasExplicitLib || compilerOptions.target !== void 0;
-const detectPreES2023FromConfig = (tsConfigPath, visitedConfigPaths = /* @__PURE__ */ new Set()) => {
-	if (visitedConfigPaths.has(tsConfigPath)) return false;
-	const compilerOptions = readResolvedCompilerOptions(tsConfigPath, 0, /* @__PURE__ */ new Set());
-	if (!compilerOptions) return false;
-	if (!compilerOptionsDeclareTargetOrLib(compilerOptions)) {
-		const tsConfig = readTsConfig(tsConfigPath);
-		if (!tsConfig) return false;
-		const nextVisitedConfigPaths = new Set(visitedConfigPaths);
-		nextVisitedConfigPaths.add(tsConfigPath);
-		const configDirectory = Path.dirname(tsConfigPath);
-		return tsConfig.referencePaths.some((referencePath) => {
-			const resolvedReferencePath = Path.resolve(configDirectory, referencePath);
-			const referencedConfigPath = isFile(resolvedReferencePath) ? resolvedReferencePath : Path.join(resolvedReferencePath, TSCONFIG_FILENAME);
-			return isFile(referencedConfigPath) && detectPreES2023FromConfig(referencedConfigPath, nextVisitedConfigPaths);
-		});
-	}
-	return compilerOptionsArePreES2023(compilerOptions);
-};
-const FALLBACK_TSCONFIG_FILENAMES = ["tsconfig.app.json", "tsconfig.build.json"];
-const detectPreES2023Target = (directory) => {
-	const tsConfigPath = Path.join(directory, TSCONFIG_FILENAME);
-	if (isFile(tsConfigPath)) return detectPreES2023FromConfig(tsConfigPath);
-	for (const fallbackFilename of FALLBACK_TSCONFIG_FILENAMES) {
-		const fallbackPath = Path.join(directory, fallbackFilename);
-		if (isFile(fallbackPath)) return detectPreES2023FromConfig(fallbackPath);
-	}
-	return false;
-};
-const REACT_DEPENDENCY_NAMES = new Set([
-	"react",
-	"react-native",
-	"next",
-	"preact"
-]);
-const hasReactDependency = (packageJson) => {
-	const allDependencies = {
-		...packageJson.peerDependencies,
-		...packageJson.dependencies,
-		...packageJson.devDependencies
-	};
-	return Object.keys(allDependencies).some((packageName) => REACT_DEPENDENCY_NAMES.has(packageName));
-};
-const listWorkspacePackages = (rootDirectory) => {
-	const packageJsonPath = Path.join(rootDirectory, "package.json");
-	if (!isFile(packageJsonPath)) return [];
-	const packageJson = readPackageJson$1(packageJsonPath);
-	const patterns = getWorkspacePatterns(rootDirectory, packageJson);
-	if (patterns.length === 0) return [];
-	const packages = [];
-	const seenDirectories = /* @__PURE__ */ new Set();
-	const pushIfNew = (workspacePackage) => {
-		if (seenDirectories.has(workspacePackage.directory)) return;
-		seenDirectories.add(workspacePackage.directory);
-		packages.push(workspacePackage);
-	};
-	if (hasReactDependency(packageJson)) pushIfNew({
-		name: packageJson.name ?? Path.basename(rootDirectory),
-		directory: rootDirectory
-	});
-	for (const pattern of patterns) {
-		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
-		for (const workspaceDirectory of directories) {
-			const workspacePackageJson = readPackageJson$1(Path.join(workspaceDirectory, "package.json"));
-			if (!hasReactDependency(workspacePackageJson)) continue;
-			pushIfNew({
-				name: workspacePackageJson.name ?? Path.basename(workspaceDirectory),
-				directory: workspaceDirectory
-			});
-		}
-	}
-	return packages;
-};
 const toReactWorkspacePackages = (directories) => {
 	const packages = [];
 	for (const directory of directories) {
@@ -37384,14 +37449,13 @@ const discoverReactSubprojects = (rootDirectory) => {
 const cachedProjectInfos = /* @__PURE__ */ new Map();
 /**
 * Build a `ProjectInfo` for a directory that has no `package.json` of
-* its own — a package subfolder like `repo/packages` or `app/src/features`,
-* or any loose tree of TypeScript/JavaScript files. Dependency + framework
-* detection is inherited from the nearest enclosing package (a leaf
-* workspace, a plain app root, or a monorepo root — whichever is closest,
-* bounded by the git root), so scanning a subdirectory of a React project
-* still gets the React capabilities; a standalone non-React directory simply
-* scans with the framework-agnostic rules. Throws only when the directory has
-* nothing to scan (no enclosing project and no source files of its own).
+* its own — a monorepo subfolder like `repo/packages`, or any loose tree
+* of TypeScript/JavaScript files. Dependency + framework detection is
+* inherited from the enclosing workspace root when there is one, so
+* scanning a subdirectory of a React monorepo still gets the React
+* capabilities; a standalone non-React directory simply scans with the
+* framework-agnostic rules. Throws only when the directory has nothing
+* to scan (no enclosing project and no source files of its own).
 */
 const discoverProjectWithoutPackageJson = (directory) => {
 	const sourceFileCount = countSourceFiles(directory);
@@ -37429,6 +37493,7 @@ const discoverProjectWithoutPackageJson = (directory) => {
 		hasReanimated: false,
 		reanimatedVersion: null,
 		isPreES2023Target: hasOwnTsConfig && detectPreES2023Target(directory),
+		isStaticExport: false,
 		sourceFileCount
 	};
 };
@@ -37442,90 +37507,85 @@ const discoverProject = (directory) => {
 		return synthesized;
 	}
 	const packageJson = readPackageJson$1(packageJsonPath);
-	let { reactVersion, tailwindVersion, zodVersion, framework } = extractDependencyInfo(packageJson);
-	const reactDeclaration = getDependencyDeclaration({
-		packageJson,
-		packageName: "react",
-		sections: [
-			"dependencies",
-			"peerDependencies",
-			"devDependencies"
-		]
-	});
-	const tailwindDeclaration = getDependencyDeclaration({
-		packageJson,
-		packageName: "tailwindcss",
-		sections: [
-			"dependencies",
-			"devDependencies",
-			"peerDependencies"
-		]
-	});
-	const zodDeclaration = getDependencyDeclaration({
+	const rootInfo = extractDependencyInfo(packageJson);
+	let framework = rootInfo.framework;
+	const tracked = {
+		react: {
+			version: rootInfo.reactVersion,
+			sections: REACT_SECTIONS
+		},
+		tailwindcss: {
+			version: rootInfo.tailwindVersion,
+			sections: TAILWIND_ZOD_SECTIONS
+		},
+		zod: {
+			version: rootInfo.zodVersion,
+			sections: TAILWIND_ZOD_SECTIONS
+		}
+	};
+	const declarations = Object.fromEntries(Object.entries(tracked).map(([packageName, entry]) => [packageName, getDependencyDeclaration({
 		packageJson,
-		packageName: "zod",
-		sections: [
-			"dependencies",
-			"devDependencies",
-			"peerDependencies"
-		]
-	});
-	if (!reactVersion && reactDeclaration.hasDeclaration) reactVersion = resolveCatalogVersion(packageJson, "react", directory, reactDeclaration.catalogReference);
-	if (!tailwindVersion && tailwindDeclaration.hasDeclaration) tailwindVersion = resolveCatalogVersion(packageJson, "tailwindcss", directory, tailwindDeclaration.catalogReference);
-	if (!zodVersion && zodDeclaration.hasDeclaration) zodVersion = resolveCatalogVersion(packageJson, "zod", directory, zodDeclaration.catalogReference);
-	if (!reactVersion || !tailwindVersion || !zodVersion) {
+		packageName,
+		sections: entry.sections
+	})]));
+	const fillFromCatalogs = (source, sourceDirectory) => {
+		for (const [packageName, entry] of Object.entries(tracked)) if (!entry.version && declarations[packageName].hasDeclaration) entry.version = resolveCatalogVersion(source, packageName, sourceDirectory, declarations[packageName].catalogReference);
+	};
+	fillFromCatalogs(packageJson, directory);
+	if (!tracked.react.version || !tracked.tailwindcss.version || !tracked.zod.version) {
 		const monorepoRoot = findMonorepoRoot(directory);
 		if (monorepoRoot) {
 			const monorepoPackageJsonPath = Path.join(monorepoRoot, "package.json");
-			if (isFile(monorepoPackageJsonPath)) {
-				const rootPackageJson = readPackageJson$1(monorepoPackageJsonPath);
-				if (!reactVersion && reactDeclaration.hasDeclaration) reactVersion = resolveCatalogVersion(rootPackageJson, "react", monorepoRoot, reactDeclaration.catalogReference);
-				if (!tailwindVersion && tailwindDeclaration.hasDeclaration) tailwindVersion = resolveCatalogVersion(rootPackageJson, "tailwindcss", monorepoRoot, tailwindDeclaration.catalogReference);
-				if (!zodVersion && zodDeclaration.hasDeclaration) zodVersion = resolveCatalogVersion(rootPackageJson, "zod", monorepoRoot, zodDeclaration.catalogReference);
-			}
+			if (isFile(monorepoPackageJsonPath)) fillFromCatalogs(readPackageJson$1(monorepoPackageJsonPath), monorepoRoot);
 		}
 	}
-	if (!reactVersion || framework === "unknown") {
-		const workspaceInfo = findReactInWorkspaces(directory, packageJson);
-		if (!reactVersion && workspaceInfo.reactVersion) reactVersion = workspaceInfo.reactVersion;
-		if (!tailwindVersion && workspaceInfo.tailwindVersion) tailwindVersion = workspaceInfo.tailwindVersion;
-		if (!zodVersion && workspaceInfo.zodVersion) zodVersion = workspaceInfo.zodVersion;
-		if (framework === "unknown" && workspaceInfo.framework !== "unknown") framework = workspaceInfo.framework;
+	const shouldCollectReactGroup = !tracked.react.version || framework === "unknown";
+	const workspaceFacts = collectWorkspaceFacts(directory, packageJson, { collectReactGroup: shouldCollectReactGroup });
+	if (shouldCollectReactGroup) {
+		tracked.react.version ||= workspaceFacts.reactVersion;
+		tracked.tailwindcss.version ||= workspaceFacts.tailwindVersion;
+		tracked.zod.version ||= workspaceFacts.zodVersion;
+		if (framework === "unknown" && workspaceFacts.framework !== "unknown") framework = workspaceFacts.framework;
 	}
-	if ((!reactVersion || framework === "unknown") && !isMonorepoRoot(directory)) {
+	if ((!tracked.react.version || framework === "unknown") && !isMonorepoRoot(directory)) {
 		const monorepoInfo = findDependencyInfoFromMonorepoRoot(directory);
-		if (!reactVersion) reactVersion = monorepoInfo.reactVersion;
-		if (!tailwindVersion) tailwindVersion = monorepoInfo.tailwindVersion;
-		if (!zodVersion) zodVersion = monorepoInfo.zodVersion;
+		tracked.react.version ||= monorepoInfo.reactVersion;
+		tracked.tailwindcss.version ||= monorepoInfo.tailwindVersion;
+		tracked.zod.version ||= monorepoInfo.zodVersion;
 		if (framework === "unknown") framework = monorepoInfo.framework;
 	}
-	if (!reactVersion && reactDeclaration.version && !isCatalogReference(reactDeclaration.version)) reactVersion = reactDeclaration.version;
-	if (!tailwindVersion && tailwindDeclaration.version && !isCatalogReference(tailwindDeclaration.version)) tailwindVersion = tailwindDeclaration.version;
-	if (!zodVersion && zodDeclaration.version && !isCatalogReference(zodDeclaration.version)) zodVersion = zodDeclaration.version;
+	for (const [packageName, entry] of Object.entries(tracked)) {
+		const declaredVersion = declarations[packageName].version;
+		if (!entry.version && declaredVersion && !isCatalogReference(declaredVersion)) entry.version = declaredVersion;
+	}
+	const { react, tailwindcss, zod } = tracked;
+	let reactVersion = react.version;
 	if (!reactVersion || parseReactMajor(reactVersion) === null) reactVersion = resolveInstalledReactVersion(directory) ?? reactVersion;
+	const tailwindVersion = tailwindcss.version;
+	const zodVersion = zod.version;
 	const projectName = packageJson.name ?? Path.basename(directory);
 	const hasTypeScript = NFS.existsSync(Path.join(directory, "tsconfig.json"));
 	const sourceFileCount = countSourceFiles(directory);
-	const hasReactNativeWorkspace = framework === "expo" || framework === "react-native" || hasReactNativeWorkspaceAnywhere(directory, packageJson);
+	const hasReactNativeWorkspace = framework === "expo" || framework === "react-native" || workspaceFacts.hasReactNativeAwarePackage;
 	const expoVersion = hasReactNativeWorkspace ? resolveCatalogBackedDependencyVersion({
 		rootDirectory: directory,
 		rootPackageJson: packageJson,
 		packageName: "expo",
-		version: findExpoVersion(directory, packageJson)
+		version: workspaceFacts.expo.version
 	}) : null;
 	const shopifyFlashListVersion = hasReactNativeWorkspace ? resolveCatalogBackedDependencyVersion({
 		rootDirectory: directory,
 		rootPackageJson: packageJson,
 		packageName: SHOPIFY_FLASH_LIST_PACKAGE_NAME,
-		version: findShopifyFlashListVersion(directory, packageJson)
+		version: workspaceFacts.shopifyFlashList.version
 	}) : null;
-	const hasReanimated = hasReactNativeWorkspace && someWorkspacePackageJson(directory, packageJson, isPackageJsonReanimatedAware);
-	const reanimatedVersion = hasReanimated ? findInWorkspacePackageJsons(directory, packageJson, (workspacePackageJson) => getDependencySpec(workspacePackageJson, REANIMATED_DEPENDENCY_NAME)) : null;
+	const hasReanimated = hasReactNativeWorkspace && workspaceFacts.hasReanimatedAwarePackage;
+	const reanimatedVersion = hasReanimated ? workspaceFacts.reanimatedVersion : null;
 	const nextjsVersion = framework === "nextjs" ? resolveCatalogBackedDependencyVersion({
 		rootDirectory: directory,
 		rootPackageJson: packageJson,
 		packageName: "next",
-		version: findNextjsVersion(directory, packageJson)
+		version: workspaceFacts.next.version
 	}) : null;
 	const preactVersion = getPreactVersion(packageJson);
 	const isPreES2023Target = hasTypeScript && detectPreES2023Target(directory);
@@ -37536,7 +37596,7 @@ const discoverProject = (directory) => {
 		reactMajorVersion: resolveEffectiveReactMajor(reactVersion, packageJson),
 		tailwindVersion,
 		zodVersion,
-		zodMajorVersion: parseZodMajor(zodVersion),
+		zodMajorVersion: zodVersion === null ? null : getLowestDependencyMajor(zodVersion),
 		framework,
 		hasTypeScript,
 		hasReactCompiler: detectReactCompiler(directory, packageJson),
@@ -37552,6 +37612,7 @@ const discoverProject = (directory) => {
 		hasReanimated,
 		reanimatedVersion,
 		isPreES2023Target,
+		isStaticExport: framework === "nextjs" && detectNextjsStaticExport(workspaceFacts.next.sourceDirectory ?? directory),
 		sourceFileCount
 	};
 	cachedProjectInfos.set(directory, projectInfo);
@@ -37567,57 +37628,6 @@ const discoverProject = (directory) => {
 * single source file has nothing to analyze.
 */
 const isAnalyzableProject = (project) => project.reactVersion !== null || project.preactVersion !== null || project.sourceFileCount > 0;
-const MAJOR_MINOR_PATTERN = /(\d{1,4})\.(\d{1,4})/;
-const MAJOR_ONLY_PATTERN = /(\d{1,4})/;
-const UPPER_BOUND_COMPARATOR_PATTERN = /<=?\s{0,8}\d{1,4}(?:\.\d{1,4}){0,2}(?:-[^\s,|]+)?/g;
-const parseReactMajorMinor = (reactVersion) => {
-	if (typeof reactVersion !== "string") return null;
-	const trimmed = reactVersion.trim();
-	if (trimmed.length === 0) return null;
-	const lowerBoundsOnly = trimmed.replace(UPPER_BOUND_COMPARATOR_PATTERN, " ").trim();
-	if (lowerBoundsOnly.length === 0) return null;
-	const majorMinorMatch = lowerBoundsOnly.match(MAJOR_MINOR_PATTERN);
-	if (majorMinorMatch) {
-		const major = Number.parseInt(majorMinorMatch[1], 10);
-		const minor = Number.parseInt(majorMinorMatch[2], 10);
-		if (!Number.isFinite(major) || major <= 0) return null;
-		if (!Number.isFinite(minor) || minor < 0) return null;
-		return {
-			major,
-			minor
-		};
-	}
-	const majorOnlyMatch = lowerBoundsOnly.match(MAJOR_ONLY_PATTERN);
-	if (!majorOnlyMatch) return null;
-	const major = Number.parseInt(majorOnlyMatch[1], 10);
-	if (!Number.isFinite(major) || major <= 0) return null;
-	return {
-		major,
-		minor: 0
-	};
-};
-const isReactAtLeast = (detected, required) => {
-	if (detected === null) return true;
-	if (detected.major !== required.major) return detected.major > required.major;
-	return detected.minor >= required.minor;
-};
-const parseLowerBoundVersion = (versionSpec) => import_semver.validRange(versionSpec) !== null ? import_semver.minVersion(versionSpec) : import_semver.coerce(versionSpec);
-const parseTailwindMajorMinor = (tailwindVersion) => {
-	if (typeof tailwindVersion !== "string") return null;
-	const trimmed = tailwindVersion.trim();
-	if (trimmed.length === 0) return null;
-	const lowerBound = parseLowerBoundVersion(trimmed);
-	if (lowerBound === null || lowerBound.major <= 0) return null;
-	return {
-		major: lowerBound.major,
-		minor: lowerBound.minor
-	};
-};
-const isTailwindAtLeast = (detected, required) => {
-	if (detected === null) return true;
-	if (detected.major !== required.major) return detected.major > required.major;
-	return detected.minor >= required.minor;
-};
 const messageFromUnknown = (error) => error instanceof Error ? error.message : String(error);
 var InvalidGlobPatternError = class extends Error {
 	pattern;
@@ -40428,64 +40438,64 @@ function* collectSecurityScanFiles(rootDirectory) {
 		}
 	}
 }
-/**
-* Whether project discovery resolved a React-compatible runtime (React or
-* Preact, which ships the same hooks + JSX model). This is the same
-* predicate that grants the `react` capability, so `false` means every
-* React-runtime rule family was gated off for the project.
-*/
-const hasReactRuntime = (project) => project.reactVersion !== null || project.preactVersion !== null;
+const CLIENT_ONLY_FRAMEWORKS = new Set([
+	"vite",
+	"cra",
+	"gatsby",
+	"react-native",
+	"expo"
+]);
+const addMajorLadder = (capabilities, name, major, earliest, latest) => {
+	if (major === null) return;
+	const cappedMajor = Math.min(major, latest);
+	for (let candidate = earliest; candidate <= cappedMajor; candidate += 1) capabilities.add(`${name}:${candidate}`);
+};
 const buildCapabilities = (project) => {
 	const capabilities = /* @__PURE__ */ new Set();
 	capabilities.add(project.framework);
-	if (hasReactRuntime(project)) capabilities.add("react");
+	if (project.reactVersion !== null || project.preactVersion !== null) capabilities.add("react");
 	if (project.framework === "expo" || project.framework === "react-native" || project.hasReactNativeWorkspace) capabilities.add("react-native");
 	if (project.expoVersion !== null) capabilities.add("expo");
+	if ((project.framework === "nextjs" || project.framework === "tanstack-start" || project.framework === "remix") && !project.isStaticExport) capabilities.add("server-actions");
+	if (CLIENT_ONLY_FRAMEWORKS.has(project.framework)) capabilities.add("client-only");
+	if (project.isStaticExport) capabilities.add("nextjs:static-export");
 	if (project.nextjsMajorVersion !== null && project.nextjsMajorVersion >= 15) capabilities.add("nextjs:15");
-	const reactMajor = project.reactMajorVersion;
-	if (reactMajor !== null) {
-		const cappedReactMajor = Math.min(reactMajor, 30);
-		for (let major = 17; major <= cappedReactMajor; major++) capabilities.add(`react:${major}`);
-		if (reactMajor >= 19) {
-			if (isReactAtLeast(parseReactMajorMinor(project.reactVersion), {
-				major: 19,
-				minor: 2
-			})) capabilities.add("react:19.2");
-		}
-	}
-	if (project.tailwindVersion !== null) {
-		capabilities.add("tailwind");
-		if (isTailwindAtLeast(parseTailwindMajorMinor(project.tailwindVersion), {
-			major: 3,
-			minor: 4
-		})) capabilities.add("tailwind:3.4");
-	}
-	if (project.zodVersion !== null) {
-		capabilities.add("zod");
-		if (project.zodMajorVersion !== null && project.zodMajorVersion >= 4) capabilities.add("zod:4");
-	}
+	addMajorLadder(capabilities, "react", project.reactMajorVersion, 17, 30);
+	if (project.reactMajorVersion !== null && project.reactMajorVersion >= 19 && isMajorMinorAtLeast(parseReactMajorMinor(project.reactVersion), {
+		major: 19,
+		minor: 2
+	})) capabilities.add("react:19.2");
+	if (project.tailwindVersion !== null) capabilities.add("tailwind");
+	if (project.tailwindVersion !== null && isMajorMinorAtLeast(parseTailwindMajorMinor(project.tailwindVersion), {
+		major: 3,
+		minor: 4
+	})) capabilities.add("tailwind:3.4");
+	if (project.zodVersion !== null) capabilities.add("zod");
+	if (project.zodMajorVersion !== null && project.zodMajorVersion >= 4) capabilities.add("zod:4");
 	if (project.isPreES2023Target) capabilities.add("pre-es2023");
 	if (project.hasReactCompiler) capabilities.add("react-compiler");
 	if (project.hasTanStackQuery) capabilities.add("tanstack-query");
 	if (project.hasTypeScript) capabilities.add("typescript");
-	if (project.preactVersion !== null) {
-		capabilities.add("preact");
-		const preactMajor = project.preactMajorVersion;
-		if (preactMajor !== null) {
-			const cappedPreactMajor = Math.min(preactMajor, 20);
-			for (let major = 10; major <= cappedPreactMajor; major++) capabilities.add(`preact:${major}`);
-		}
-		if (project.reactVersion === null) capabilities.add("pure-preact");
-	}
+	if (project.preactVersion !== null) capabilities.add("preact");
+	addMajorLadder(capabilities, "preact", project.preactMajorVersion, 10, 20);
+	if (project.preactVersion !== null && project.reactVersion === null) capabilities.add("pure-preact");
 	return capabilities;
 };
-const shouldEnableRule = (requires, tags, capabilities, ignoredTags, disabledBy) => {
+const capabilitiesByProject = /* @__PURE__ */ new WeakMap();
+const getCapabilities = (project) => {
+	const cached = capabilitiesByProject.get(project);
+	if (cached !== void 0) return cached;
+	const capabilities = buildCapabilities(project);
+	capabilitiesByProject.set(project, capabilities);
+	return capabilities;
+};
+const shouldEnableRule = (requires, tags, capabilities, ignoredTags, disabledWhen) => {
 	if (requires) {
 		for (const capability of requires) if (!capabilities.has(capability)) return false;
 	}
 	if (tags?.includes("react-jsx-only") && !capabilities.has("react")) return false;
-	if (disabledBy) {
-		for (const capability of disabledBy) if (capabilities.has(capability)) return false;
+	if (disabledWhen) {
+		for (const capability of disabledWhen) if (capabilities.has(capability)) return false;
 	}
 	if (tags) {
 		for (const tag of tags) if (ignoredTags.has(tag)) return false;
@@ -40496,14 +40506,14 @@ const yieldToEventLoop = () => new Promise((resolve) => {
 	setImmediate(resolve);
 });
 const createSecurityScanSession = (rootDirectory, options) => {
-	const capabilities = options.project ? buildCapabilities(options.project) : /* @__PURE__ */ new Set();
+	const capabilities = options.project ? getCapabilities(options.project) : /* @__PURE__ */ new Set();
 	const ignoredTags = options.ignoredTags ?? /* @__PURE__ */ new Set();
 	const enabledScanRules = REACT_DOCTOR_RULES.flatMap((entry) => {
 		const rule = entry.rule;
 		const scan = rule.scan;
 		if (typeof scan !== "function") return [];
 		if (rule.defaultEnabled === false) return [];
-		if (!shouldEnableRule(rule.requires, rule.tags, capabilities, ignoredTags, rule.disabledBy)) return [];
+		if (!shouldEnableRule(rule.requires, rule.tags, capabilities, ignoredTags, rule.disabledWhen)) return [];
 		return [{
 			entry,
 			scan,
@@ -40523,6 +40533,7 @@ const createSecurityScanSession = (rootDirectory, options) => {
 		return status === true;
 	};
 	const scanFileByRule = function* (file) {
+		if (file === null) return;
 		for (const { entry, scan, committedFilesOnly } of enabledScanRules) {
 			for (const finding of scan(file)) {
 				if (committedFilesOnly && isFileGitIgnored(file)) continue;
@@ -42419,7 +42430,7 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 	const reactCompilerRules = reactHooksJsPlugin ? applyRuleSeverityControls(filterRulesToAvailable(REACT_COMPILER_RULES, "react-hooks-js", reactHooksJsPlugin.availableRuleNames), severityControls) : {};
 	const jsPlugins = [];
 	if (reactHooksJsPlugin) jsPlugins.push(reactHooksJsPlugin.entry);
-	const capabilities = buildCapabilities(project);
+	const capabilities = getCapabilities(project);
 	const enabledReactDoctorRules = {};
 	for (const registryEntry of REACT_DOCTOR_RULES) {
 		const rule = reactDoctorPlugin.rules[registryEntry.id];
@@ -42430,7 +42441,7 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 		if (rule.scan !== void 0) continue;
 		if (customRulesOnly && registryEntry.originallyExternal) continue;
 		if (rule.framework !== "global" && !rule.requires) continue;
-		if (!shouldEnableRule(rule.requires, rule.tags, capabilities, ignoredTags, rule.disabledBy)) continue;
+		if (!shouldEnableRule(rule.requires, rule.tags, capabilities, ignoredTags, rule.disabledWhen)) continue;
 		const explicitRuleOverride = resolveRuleSeverityOverride({ ruleKey: registryEntry.key }, severityControls);
 		if (rule.defaultEnabled === false && explicitRuleOverride === void 0) continue;
 		const severity = resolveRuleSeverityOverride({
@@ -42461,6 +42472,7 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 		settings: { "react-doctor": {
 			framework: project.framework,
 			rootDirectory: resolveSettingsRootDirectory(project.rootDirectory),
+			capabilities: [...capabilities].sort(),
 			...project.shopifyFlashListMajorVersion !== null ? { shopifyFlashListMajorVersion: project.shopifyFlashListMajorVersion } : {},
 			...serverAuthFunctionNames && serverAuthFunctionNames.length > 0 ? { serverAuthFunctionNames: [...serverAuthFunctionNames] } : {}
 		} },
@@ -42751,21 +42763,6 @@ const mapWithConcurrency = async (items, concurrency, task) => {
 	if (errors.length > 0) throw errors[0];
 	return results;
 };
-const getPublicEnvPrefix = (framework) => {
-	switch (framework) {
-		case "nextjs": return "NEXT_PUBLIC_*";
-		case "vite":
-		case "tanstack-start": return "VITE_*";
-		case "cra": return "REACT_APP_*";
-		case "gatsby": return "GATSBY_*";
-		default: return null;
-	}
-};
-const buildNoSecretsRecommendation = (project, fallbackRecommendation) => {
-	const publicEnvPrefix = getPublicEnvPrefix(project.framework);
-	if (!publicEnvPrefix) return fallbackRecommendation;
-	return `Move secrets to server-only code. In ${formatFrameworkName(project.framework)}, only \`${publicEnvPrefix}\` env vars are exposed to the browser, and they must not contain secrets`;
-};
 const REANIMATED_SHARED_VALUE_HINT = "If this is a Reanimated shared value, prefer its React Compiler-compatible `.get()` / `.set()` accessors over `.value` — https://docs.swmansion.com/react-native-reanimated/docs/core/useSharedValue/#react-compiler-support";
 const ACCESSORS_MIN_VERSION = "3.15.0";
 const supportsAccessors = (reanimatedVersion) => {
@@ -43446,8 +43443,14 @@ const PLUGIN_CATEGORY_MAP = {
 };
 const lookupOwnString = (record, key) => Object.hasOwn(record, key) ? record[key] : void 0;
 const getRuleRecommendation = (ruleName, project) => {
-	if (ruleName === "no-secrets-in-client-code") return buildNoSecretsRecommendation(project, reactDoctorPlugin.rules["no-secrets-in-client-code"]?.recommendation ?? "Move secrets to server-only code");
-	return reactDoctorPlugin.rules[ruleName]?.recommendation;
+	const rule = reactDoctorPlugin.rules[ruleName];
+	if (!rule) return void 0;
+	if (rule.recommendationFor) {
+		const capabilities = getCapabilities(project);
+		const conditionalRecommendation = rule.recommendationFor((capability) => capabilities.has(capability));
+		if (conditionalRecommendation !== void 0) return conditionalRecommendation;
+	}
+	return rule.recommendation;
 };
 const getRuleCategory = (ruleName) => reactDoctorPlugin.rules[ruleName]?.category;
 const getRuleTitle = (ruleName) => reactDoctorPlugin.rules[ruleName]?.title;
@@ -43601,7 +43604,9 @@ const SANITIZED_ENV = buildOxlintChildEnv(process.env);
 * - `OxlintBatchExceeded { kind: "output-too-large" }` — stdout+stderr
 *   crossed `OXLINT_OUTPUT_MAX_BYTES`.
 * - `OxlintBatchExceeded { kind: "oom" | "killed" }` — child exited
-*   on a signal (SIGABRT → OOM, others → generic kill).
+*   on a signal (SIGABRT → OOM, others → generic kill), or with one
+*   of the abort exit codes Windows reports instead of a signal
+*   (`ABORT_EXIT_CODES` → OOM).
 * - `OxlintSpawnFailed { cause }` — `spawn` itself errored, or the
 *   child exited successfully but printed only stderr.
 *
@@ -43667,7 +43672,7 @@ const spawnOxlint = (args, rootDirectory, nodeBinaryPath, spawnTimeoutMs = OXLIN
 		clearAbortListener();
 		reject(new ReactDoctorError({ reason: new OxlintSpawnFailed({ cause: error }) }));
 	});
-	child.on("close", (_code, signal) => {
+	child.on("close", (code, signal) => {
 		clearTimeout(timeoutHandle);
 		clearAbortListener();
 		if (didKillForSize) {
@@ -43677,10 +43682,11 @@ const spawnOxlint = (args, rootDirectory, nodeBinaryPath, spawnTimeoutMs = OXLIN
 			}) }));
 			return;
 		}
-		if (signal) {
+		const isAbortExitCode = code !== null && ABORT_EXIT_CODES.has(code);
+		if (signal || isAbortExitCode) {
 			const stderrOutput = Buffer.concat(stderrBuffers).toString("utf-8").trim();
-			const isOom = signal === "SIGABRT";
-			const detailParts = [`killed by ${signal}`];
+			const isOom = signal === "SIGABRT" || isAbortExitCode;
+			const detailParts = [signal ? `killed by ${signal}` : `aborted with exit code ${code}`];
 			if (isOom) detailParts.push("try scanning fewer files with --diff");
 			if (stderrOutput) detailParts.push(stderrOutput);
 			reject(new ReactDoctorError({ reason: new OxlintBatchExceeded({
@@ -43723,12 +43729,19 @@ const isParallelismRelatedSpawnError = (error) => {
 * (surfaced via `onPartialFailure`) so JSON-mode consumers see WHICH
 * files were skipped instead of silently losing them.
 *
-* Parallel runs (concurrency > 1) get one extra safety net: if the pass
-* fails with a resource-exhaustion error that's exclusive to running
-* many oxlint subprocesses at once (EAGAIN / EMFILE / ENFILE / ENOMEM —
-* see `isParallelismRelatedSpawnError`), the whole pass replays once
-* with a single worker. That's the only failure a serial replay can
-* clear, so every other error class is left to propagate.
+* Parallel runs (concurrency > 1) get two extra safety nets:
+* - If the pass fails with a resource-exhaustion error that's exclusive
+*   to running many oxlint subprocesses at once (EAGAIN / EMFILE /
+*   ENFILE / ENOMEM — see `isParallelismRelatedSpawnError`), the whole
+*   pass replays once with a single worker. That's the only failure a
+*   serial replay can clear, so every other error class is left to
+*   propagate.
+* - Files dropped because oxlint's native binding SIGABRT'd under
+*   memory pressure (`OxlintBatchExceeded { kind: "oom" }`) get one
+*   serial single-file-batch rescue pass: the OOM is usually a function
+*   of N concurrent oxlint allocator arenas, not the file itself, so a
+*   lone process with the machine to itself typically clears it —
+*   turning a partial scan into a complete (if slower) one.
 *
 * Errors that aren't splittable and aren't parallelism-related (oxlint
 * config crash, JS plugin resolution failure, etc.) propagate to the
@@ -43738,13 +43751,16 @@ const isParallelismRelatedSpawnError = (error) => {
 const spawnLintBatches = async (input) => {
 	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes, splitTotalBudgetMs = OXLINT_SPLIT_TOTAL_BUDGET_MS, splitMaxDepth = 8, signal, deadlineEpochMs } = input;
 	const requestedConcurrency = resolveScanConcurrency(input.concurrency ?? 1);
-	const totalFileCount = fileBatches.reduce((sum, batch) => sum + batch.length, 0);
-	const runBatchPass = async (concurrency) => {
+	let rescueDeadlineEpochMs;
+	const isPastDeadline = () => deadlineEpochMs !== void 0 && remainingDeadlineBudgetMs(deadlineEpochMs) === 0 || rescueDeadlineEpochMs !== void 0 && remainingDeadlineBudgetMs(rescueDeadlineEpochMs) === 0;
+	const runBatchPass = async (concurrency, passBatches, passOnFileProgress) => {
+		const totalFileCount = passBatches.reduce((sum, batch) => sum + batch.length, 0);
 		const allDiagnostics = [];
 		const droppedFiles = [];
+		const oomDroppedFiles = [];
 		const deadlineSkippedFiles = [];
-		const isPastDeadline = () => deadlineEpochMs !== void 0 && remainingDeadlineBudgetMs(deadlineEpochMs) === 0;
 		let firstDropReason = null;
+		let firstNonOomDropReason = null;
 		const spawnLintBatch = async (batch, depth, batchState) => {
 			if (isPastDeadline()) {
 				deadlineSkippedFiles.push(...batch);
@@ -43766,12 +43782,14 @@ const spawnLintBatches = async (input) => {
 				const isDepthCapReached = depth >= splitMaxDepth;
 				if (batch.length <= 1 || isBudgetElapsed || isDepthCapReached) {
 					droppedFiles.push(...batch);
-					if (firstDropReason === null) {
-						let limitHint = "";
-						if (isDepthCapReached) limitHint = ` (split depth cap of ${splitMaxDepth} levels reached)`;
-						else if (isBudgetElapsed) limitHint = ` (split budget of ${splitTotalBudgetMs / MILLISECONDS_PER_SECOND}s exhausted at depth ${depth})`;
-						firstDropReason = batch.length > 1 ? `${error.message}${limitHint}` : error.message;
-					}
+					const isOomDrop = error.reason._tag === "OxlintBatchExceeded" && error.reason.kind === "oom";
+					if (isOomDrop) oomDroppedFiles.push(...batch);
+					let limitHint = "";
+					if (isDepthCapReached) limitHint = ` (split depth cap of ${splitMaxDepth} levels reached)`;
+					else if (isBudgetElapsed) limitHint = ` (split budget of ${splitTotalBudgetMs / MILLISECONDS_PER_SECOND}s exhausted at depth ${depth})`;
+					const dropReason = batch.length > 1 ? `${error.message}${limitHint}` : error.message;
+					firstDropReason ??= dropReason;
+					if (!isOomDrop) firstNonOomDropReason ??= dropReason;
 					return [];
 				}
 				const splitIndex = Math.ceil(batch.length / 2);
@@ -43781,16 +43799,16 @@ const spawnLintBatches = async (input) => {
 		let startedFileCount = 0;
 		let scannedFileCount = 0;
 		let displayedFileCount = 0;
-		const progressTimer = onFileProgress && totalFileCount > 1 ? setInterval(() => {
+		const progressTimer = passOnFileProgress && totalFileCount > 1 ? setInterval(() => {
 			const ceiling = Math.min(startedFileCount, totalFileCount - 1);
 			if (displayedFileCount < ceiling) {
 				displayedFileCount += 1;
-				onFileProgress(displayedFileCount, totalFileCount);
+				passOnFileProgress(displayedFileCount, totalFileCount);
 			}
 		}, 50) : null;
 		progressTimer?.unref?.();
 		try {
-			const batchResults = await mapWithConcurrency(fileBatches, concurrency, async (batch) => {
+			const batchResults = await mapWithConcurrency(passBatches, concurrency, async (batch) => {
 				if (isPastDeadline()) {
 					deadlineSkippedFiles.push(...batch);
 					return [];
@@ -43802,9 +43820,9 @@ const spawnLintBatches = async (input) => {
 				};
 				const batchDiagnostics = await spawnLintBatch(batch, 0, batchState);
 				scannedFileCount += batch.length - batchState.deadlineSkippedFileCount;
-				if (onFileProgress) {
+				if (passOnFileProgress) {
 					displayedFileCount = Math.min(Math.max(displayedFileCount, scannedFileCount), totalFileCount);
-					onFileProgress(displayedFileCount, totalFileCount);
+					passOnFileProgress(displayedFileCount, totalFileCount);
 				}
 				return batchDiagnostics;
 			});
@@ -43812,22 +43830,53 @@ const spawnLintBatches = async (input) => {
 		} finally {
 			if (progressTimer !== null) clearInterval(progressTimer);
 		}
-		const reportSkippedFiles = (skippedFiles, buildMessage) => {
-			if (skippedFiles.length === 0 || !onPartialFailure) return;
-			onPartialFailure(buildMessage(`${skippedFiles.slice(0, 3).join(", ")}${skippedFiles.length > 3 ? `, +${skippedFiles.length - 3} more` : ""}`));
+		return {
+			diagnostics: allDiagnostics,
+			droppedFiles,
+			oomDroppedFiles,
+			deadlineSkippedFiles,
+			firstDropReason,
+			firstNonOomDropReason
 		};
-		const reasonHint = firstDropReason ? ` — first failure: ${firstDropReason}` : "";
-		reportSkippedFiles(droppedFiles, (fileListPreview) => `${droppedFiles.length} file(s) failed to lint and were skipped (${fileListPreview})${reasonHint}`);
-		reportSkippedFiles(deadlineSkippedFiles, (fileListPreview) => `${deadlineSkippedFiles.length} file(s) skipped — max scan duration reached before they were linted (${fileListPreview})`);
-		return allDiagnostics;
 	};
-	let diagnostics;
+	let outcome;
+	let effectiveConcurrency = requestedConcurrency;
 	try {
-		diagnostics = await runBatchPass(requestedConcurrency);
+		outcome = await runBatchPass(requestedConcurrency, fileBatches, onFileProgress);
 	} catch (error) {
 		if (requestedConcurrency <= 1 || !isParallelismRelatedSpawnError(error)) throw error;
-		diagnostics = await runBatchPass(1);
+		effectiveConcurrency = 1;
+		outcome = await runBatchPass(1, fileBatches, onFileProgress);
+	}
+	let { droppedFiles, firstDropReason } = outcome;
+	const diagnostics = outcome.diagnostics;
+	if (outcome.oomDroppedFiles.length > 0 && effectiveConcurrency > 1 && !isPastDeadline()) {
+		rescueDeadlineEpochMs = Date.now() + OXLINT_OOM_RESCUE_BUDGET_MS;
+		const rescuedFiles = /* @__PURE__ */ new Set();
+		let firstRescueFailureReason = null;
+		for (const oomDroppedFile of outcome.oomDroppedFiles) {
+			if (isPastDeadline()) break;
+			try {
+				const rescueOutcome = await runBatchPass(1, [[oomDroppedFile]], void 0);
+				diagnostics.push(...rescueOutcome.diagnostics);
+				if (rescueOutcome.droppedFiles.length > 0 || rescueOutcome.deadlineSkippedFiles.length > 0) firstRescueFailureReason ??= rescueOutcome.firstDropReason;
+				else rescuedFiles.add(oomDroppedFile);
+			} catch (error) {
+				firstRescueFailureReason ??= error instanceof Error ? error.message : String(error);
+			}
+		}
+		rescueDeadlineEpochMs = void 0;
+		droppedFiles = droppedFiles.filter((filePath) => !rescuedFiles.has(filePath));
+		if (droppedFiles.length === 0) firstDropReason = null;
+		else firstDropReason = firstRescueFailureReason ?? outcome.firstNonOomDropReason ?? firstDropReason;
 	}
+	const reportSkippedFiles = (skippedFiles, buildMessage) => {
+		if (skippedFiles.length === 0 || !onPartialFailure) return;
+		onPartialFailure(buildMessage(`${skippedFiles.slice(0, 3).join(", ")}${skippedFiles.length > 3 ? `, +${skippedFiles.length - 3} more` : ""}`));
+	};
+	const reasonHint = firstDropReason ? ` — first failure: ${firstDropReason}` : "";
+	reportSkippedFiles(droppedFiles, (fileListPreview) => `${droppedFiles.length} file(s) failed to lint and were skipped (${fileListPreview})${reasonHint}`);
+	reportSkippedFiles(outcome.deadlineSkippedFiles, (fileListPreview) => `${outcome.deadlineSkippedFiles.length} file(s) skipped — max scan duration reached before they were linted (${fileListPreview})`);
 	return dedupeDiagnostics(diagnostics);
 };
 let didValidate = false;
@@ -45796,6 +45845,13 @@ const summarizeDiagnostics = (diagnostics, worstScore = null, worstScoreLabel =
 		scoreLabel: worstScoreLabel
 	};
 };
+/**
+* Whether project discovery resolved a React-compatible runtime (React or
+* Preact, which ships the same hooks + JSX model). This is the same
+* predicate that grants the `react` capability, so `false` means every
+* React-runtime rule family was gated off for the project.
+*/
+const hasReactRuntime = (project) => project.reactVersion !== null || project.preactVersion !== null;
 const toJsonDiff = (diff) => {
 	if (!diff) return null;
 	return {
@@ -46378,7 +46434,7 @@ const makeNoopConsole = () => ({
 });
 //#endregion
 //#region src/cli/utils/version.ts
-const VERSION = "0.7.2";
+const VERSION = "0.7.3-dev.6b70b32";
 //#endregion
 //#region src/cli/utils/json-mode.ts
 let context = null;
@@ -46747,13 +46803,13 @@ const isDevVersion = (version) => version === "0.0.0" || version.includes("-");
 * uploads source-map artifacts under, so stack frames symbolicate. Honors the
 * standard `SENTRY_RELEASE` override.
 */
-const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@0.7.2`;
+const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@0.7.3-dev.6b70b32`;
 /**
 * Deployment environment shown in Sentry's environment filter. Defaults to
 * `production` for tagged releases and `development` for dev/unbuilt versions,
 * overridable via the standard `SENTRY_ENVIRONMENT` env var.
 */
-const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion("0.7.2") ? "development" : "production");
+const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion("0.7.3-dev.6b70b32") ? "development" : "production");
 /**
 * Performance-tracing sample rate in `[0, 1]`. Reads `SENTRY_TRACES_SAMPLE_RATE`
 * (set to `0` to disable tracing) and falls back to
@@ -64928,4 +64984,4 @@ Promise.resolve().then(() => assertNoRemovedFlags(process.argv)).then(() => prog
 export {};
 
 //# sourceMappingURL=cli.js.map
-//# debugId=7d3c9a4a-cf80-5529-97be-47427cc1e986
+//# debugId=d6c8e327-6382-5aed-99c8-f3e537c25f51