react-doctor 0.2.9 → 0.2.11-dev.15e5fec

package/dist/{cli-logger-BliQX9s8.js → cli-logger-CSZagq1E.js}

@@ -2272,22 +2272,100 @@ const FRAMEWORK_DISPLAY_NAMES = {
 	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 UPPER_BOUND_COMPARATOR = /<\s*=?\s*\d+(?:\.\d+){0,2}(?:-[^\s,|]+)?/g;
-const HAS_UPPER_BOUND_COMPARATOR = /<\s*=?\s*\d+(?:\.\d+){0,2}(?:-[^\s,|]+)?/;
-const OR_SEPARATOR = /\s*\|\|\s*/;
 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])*$/;
-const NON_LOWER_BOUND_COMPARATOR = /(?:^|[\s,|])(?:>(?!=)|!={0,2})\s*\d/;
-const LOWER_BOUND_MAJOR = /(?:^|[\s,|])(?:>=\s*|[~^=v]\s*)?(\d+)(?=$|[\s,|.*xX-])/g;
 const NPM_ALIAS_VERSION = /^npm:(?:@[^/]+\/[^@]+|[^@]+)@(.+)$/i;
+const isDigit = (value) => value !== void 0 && value >= "0" && value <= "9";
+const isWhitespace = (value) => value === " " || value === "	" || value === "\n" || value === "\r" || value === "\f" || value === "\v";
+const isSeparator = (value) => isWhitespace(value) || value === "," || value === "|";
+const skipWhitespace = (value, start) => {
+	let index = start;
+	while (isWhitespace(value[index])) index += 1;
+	return index;
+};
+const skipSeparators = (value, start) => {
+	let index = start;
+	while (isSeparator(value[index])) index += 1;
+	return index;
+};
+const readDigits = (value, start) => {
+	let index = start;
+	while (isDigit(value[index])) index += 1;
+	return index;
+};
+const getUpperBoundComparatorEnd = (version, start) => {
+	if (version[start] !== "<") return null;
+	let index = skipWhitespace(version, start + 1);
+	if (version[index] === "=") index = skipWhitespace(version, index + 1);
+	const majorStart = index;
+	index = readDigits(version, index);
+	if (index === majorStart) return null;
+	for (let segments = 0; segments < 2 && version[index] === "."; segments += 1) {
+		const segmentStart = index + 1;
+		const segmentEnd = readDigits(version, segmentStart);
+		if (segmentEnd === segmentStart) break;
+		index = segmentEnd;
+	}
+	if (version[index] === "-") {
+		index += 1;
+		while (index < version.length && !isSeparator(version[index])) index += 1;
+	}
+	return index;
+};
+const stripUpperBoundComparators = (version) => {
+	let stripped = "";
+	let index = 0;
+	while (index < version.length) {
+		const comparatorEnd = getUpperBoundComparatorEnd(version, index);
+		if (comparatorEnd === null) {
+			stripped += version[index];
+			index += 1;
+			continue;
+		}
+		stripped += " ";
+		index = comparatorEnd;
+	}
+	return stripped;
+};
+const hasNonLowerBoundComparator = (branch) => {
+	for (let index = 0; index < branch.length; index += 1) {
+		if (index > 0 && !isSeparator(branch[index - 1])) continue;
+		if (branch[index] === ">" && branch[index + 1] !== "=") {
+			if (isDigit(branch[skipWhitespace(branch, index + 1)])) return true;
+			continue;
+		}
+		if (branch[index] !== "!") continue;
+		let valueIndex = index + 1;
+		if (branch[valueIndex] === "=") valueIndex += 1;
+		if (branch[valueIndex] === "=") valueIndex += 1;
+		valueIndex = skipWhitespace(branch, valueIndex);
+		if (isDigit(branch[valueIndex])) return true;
+	}
+	return false;
+};
+const isMajorTerminator = (value) => value === void 0 || isSeparator(value) || value === "." || value === "*" || value === "x" || value === "X" || value === "-";
+const getLowerBoundMajorAt = (branch, start) => {
+	let index = start;
+	if (branch[index] === ">" && branch[index + 1] === "=") index = skipWhitespace(branch, index + 2);
+	else if (branch[index] === "~" || branch[index] === "^" || branch[index] === "=" || branch[index] === "v") index = skipWhitespace(branch, index + 1);
+	const majorStart = index;
+	const majorEnd = readDigits(branch, majorStart);
+	if (majorEnd === majorStart || !isMajorTerminator(branch[majorEnd])) return null;
+	return {
+		end: majorEnd,
+		major: Number.parseInt(branch.slice(majorStart, majorEnd), 10)
+	};
+};
 const normalizeDependencyVersion = (version) => {
 	const trimmed = version.trim();
 	if (trimmed.length === 0) return null;
@@ -2297,17 +2375,29 @@ const normalizeDependencyVersion = (version) => {
 	if (WILDCARD_VERSION.test(normalizedVersion)) return null;
 	return normalizedVersion;
 };
-const splitDependencyVersionBranches = (version) => version.split(OR_SEPARATOR).filter(Boolean);
-const hasUpperBoundComparator = (version) => HAS_UPPER_BOUND_COMPARATOR.test(version);
+const splitDependencyVersionBranches = (version) => version.split("||").map((branch) => branch.trim()).filter(Boolean);
+const hasUpperBoundComparator = (version) => {
+	for (let index = 0; index < version.length; index += 1) if (getUpperBoundComparatorEnd(version, index) !== null) return true;
+	return false;
+};
 const getBranchLowestMajor = (branch) => {
-	if (NON_LOWER_BOUND_COMPARATOR.test(branch)) return null;
-	const lowerBoundComparators = branch.replace(UPPER_BOUND_COMPARATOR, " ").trim();
+	if (hasNonLowerBoundComparator(branch)) return null;
+	const lowerBoundComparators = stripUpperBoundComparators(branch).trim();
 	if (lowerBoundComparators.length === 0) return null;
 	let branchLowestMajor = null;
-	for (const match of lowerBoundComparators.matchAll(LOWER_BOUND_MAJOR)) {
-		const major = Number.parseInt(match[1], 10);
-		if (!Number.isFinite(major) || major <= 0) continue;
-		if (branchLowestMajor === null || major < branchLowestMajor) branchLowestMajor = major;
+	let index = 0;
+	while (index < lowerBoundComparators.length) {
+		const lowerBoundStart = skipSeparators(lowerBoundComparators, index);
+		if (lowerBoundStart > 0 && !isSeparator(lowerBoundComparators[lowerBoundStart - 1])) {
+			index = lowerBoundStart + 1;
+			continue;
+		}
+		const lowerBoundMajor = getLowerBoundMajorAt(lowerBoundComparators, lowerBoundStart);
+		if (lowerBoundMajor !== null && Number.isFinite(lowerBoundMajor.major) && lowerBoundMajor.major > 0) {
+			const major = lowerBoundMajor.major;
+			if (branchLowestMajor === null || major < branchLowestMajor) branchLowestMajor = major;
+		}
+		index = lowerBoundMajor?.end ?? lowerBoundStart + 1;
 	}
 	return branchLowestMajor;
 };
@@ -2476,6 +2566,7 @@ const resolveCatalogVersion = (packageJson, packageName, rootDirectory, explicit
 const EMPTY_DEPENDENCY_INFO = {
 	reactVersion: null,
 	tailwindVersion: null,
+	zodVersion: null,
 	framework: "unknown"
 };
 const pickConcreteVersion = (packageJson, packageName, sections) => {
@@ -2504,6 +2595,11 @@ const extractDependencyInfo = (packageJson) => {
 			"devDependencies",
 			"peerDependencies"
 		]),
+		zodVersion: pickConcreteVersion(packageJson, "zod", [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies"
+		]),
 		framework: detectFramework(allDependencies)
 	};
 };
@@ -2648,8 +2744,22 @@ const findReactInWorkspaces = (rootDirectory, packageJson) => {
 				workspaceDirectory,
 				workspacePackageJson
 			});
+			const zodVersion = resolveWorkspaceDependencyVersion({
+				concreteVersion: info.zodVersion,
+				packageName: "zod",
+				rootDirectory,
+				rootPackageJson: packageJson,
+				sections: [
+					"dependencies",
+					"devDependencies",
+					"peerDependencies"
+				],
+				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;
@@ -2684,17 +2794,44 @@ const findDependencyInfoFromMonorepoRoot = (directory) => {
 			"peerDependencies"
 		]
 	}) : null;
+	const leafZodDeclaration = leafPackageJson ? getDependencyDeclaration({
+		packageJson: leafPackageJson,
+		packageName: "zod",
+		sections: [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies"
+		]
+	}) : null;
 	const shouldUseReactFallback = !leafReactDeclaration?.hasDeclaration;
 	const shouldUseTailwindFallback = leafTailwindDeclaration?.hasDeclaration ?? true;
+	const shouldUseZodFallback = leafZodDeclaration?.hasDeclaration ?? true;
 	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);
 	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
 	};
 };
+const someWorkspacePackageJson = (rootDirectory, rootPackageJson, predicate) => {
+	if (predicate(rootPackageJson)) return true;
+	const patterns = getWorkspacePatterns(rootDirectory, rootPackageJson);
+	if (patterns.length === 0) return false;
+	const visitedDirectories = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) {
+		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
+		for (const workspaceDirectory of directories) {
+			if (visitedDirectories.has(workspaceDirectory)) continue;
+			visitedDirectories.add(workspaceDirectory);
+			if (predicate(readPackageJson(path.join(workspaceDirectory, "package.json")))) return true;
+		}
+	}
+	return false;
+};
 const NAMES = new Set([
 	"react-native",
 	"react-native-tvos",
@@ -2725,20 +2862,13 @@ const isPackageJsonReactNativeAware = (packageJson) => {
 	if (containsAnyReactNativeDependency(packageJson.optionalDependencies)) return true;
 	return false;
 };
-const hasReactNativeWorkspaceAnywhere = (rootDirectory, rootPackageJson) => {
-	if (isPackageJsonReactNativeAware(rootPackageJson)) return true;
-	const patterns = getWorkspacePatterns(rootDirectory, rootPackageJson);
-	if (patterns.length === 0) return false;
-	const visitedDirectories = /* @__PURE__ */ new Set();
-	for (const pattern of patterns) {
-		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
-		for (const workspaceDirectory of directories) {
-			if (visitedDirectories.has(workspaceDirectory)) continue;
-			visitedDirectories.add(workspaceDirectory);
-			if (isPackageJsonReactNativeAware(readPackageJson(path.join(workspaceDirectory, "package.json")))) return true;
-		}
-	}
-	return false;
+const hasReactNativeWorkspaceAnywhere = (rootDirectory, rootPackageJson) => someWorkspacePackageJson(rootDirectory, rootPackageJson, isPackageJsonReactNativeAware);
+const getPreactVersion = (packageJson) => {
+	return {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	}.preact ?? null;
 };
 const TANSTACK_QUERY_PACKAGES = new Set([
 	"@tanstack/react-query",
@@ -2753,6 +2883,20 @@ const hasTanStackQuery = (packageJson) => {
 	};
 	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);
@@ -2777,7 +2921,8 @@ const resolveEffectiveReactMajor = (reactVersion, packageJson) => {
 const REACT_DEPENDENCY_NAMES = new Set([
 	"react",
 	"react-native",
-	"next"
+	"next",
+	"preact"
 ]);
 const hasReactDependency = (packageJson) => {
 	const allDependencies = {
@@ -2838,12 +2983,22 @@ const listManifestWorkspacePackages = (rootDirectory) => {
 	const nxPatterns = patterns.length > 0 ? [] : getNxWorkspaceDirectories(rootDirectory);
 	return toReactWorkspacePackages((patterns.length > 0 ? patterns : nxPatterns).flatMap((pattern) => resolveWorkspaceDirectories(rootDirectory, pattern)));
 };
+const NON_PROJECT_DIRECTORIES = new Set([
+	"AppData",
+	"Application Data",
+	"Library"
+]);
+const MAX_SCAN_DEPTH = 6;
 const discoverReactSubprojectsByFilesystem = (rootDirectory) => {
 	const packages = [];
-	const pendingDirectories = [rootDirectory];
+	const pendingDirectories = [{
+		directory: rootDirectory,
+		depth: 0
+	}];
 	while (pendingDirectories.length > 0) {
-		const currentDirectory = pendingDirectories.pop();
-		if (!currentDirectory) continue;
+		const current = pendingDirectories.pop();
+		if (!current) continue;
+		const { directory: currentDirectory, depth } = current;
 		const packageJsonPath = path.join(currentDirectory, "package.json");
 		if (isFile(packageJsonPath)) {
 			const packageJson = readPackageJson(packageJsonPath);
@@ -2855,10 +3010,14 @@ const discoverReactSubprojectsByFilesystem = (rootDirectory) => {
 				});
 			}
 		}
+		if (depth >= MAX_SCAN_DEPTH) continue;
 		const entries = readDirectoryEntries(currentDirectory).toSorted((firstEntry, secondEntry) => firstEntry.name.localeCompare(secondEntry.name));
 		for (const entry of entries) {
-			if (!entry.isDirectory() || entry.name.startsWith(".") || IGNORED_DIRECTORIES.has(entry.name)) continue;
-			pendingDirectories.push(path.join(currentDirectory, entry.name));
+			if (!entry.isDirectory() || entry.name.startsWith(".") || IGNORED_DIRECTORIES.has(entry.name) || NON_PROJECT_DIRECTORIES.has(entry.name)) continue;
+			pendingDirectories.push({
+				directory: path.join(currentDirectory, entry.name),
+				depth: depth + 1
+			});
 		}
 	}
 	return packages;
@@ -2876,7 +3035,7 @@ const discoverProject = (directory) => {
 	const packageJsonPath = path.join(directory, "package.json");
 	if (!isFile(packageJsonPath)) throw new PackageJsonNotFoundError(directory);
 	const packageJson = readPackageJson(packageJsonPath);
-	let { reactVersion, tailwindVersion, framework } = extractDependencyInfo(packageJson);
+	let { reactVersion, tailwindVersion, zodVersion, framework } = extractDependencyInfo(packageJson);
 	const reactDeclaration = getDependencyDeclaration({
 		packageJson,
 		packageName: "react",
@@ -2895,9 +3054,19 @@ const discoverProject = (directory) => {
 			"peerDependencies"
 		]
 	});
+	const zodDeclaration = 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 (!reactVersion || !tailwindVersion) {
+	if (!zodVersion && zodDeclaration.hasDeclaration) zodVersion = resolveCatalogVersion(packageJson, "zod", directory, zodDeclaration.catalogReference);
+	if (!reactVersion || !tailwindVersion || !zodVersion) {
 		const monorepoRoot = findMonorepoRoot(directory);
 		if (monorepoRoot) {
 			const monorepoPackageJsonPath = path.join(monorepoRoot, "package.json");
@@ -2905,6 +3074,7 @@ const discoverProject = (directory) => {
 				const rootPackageJson = readPackageJson(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);
 			}
 		}
 	}
@@ -2912,36 +3082,81 @@ const discoverProject = (directory) => {
 		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;
 	}
 	if ((!reactVersion || framework === "unknown") && !isMonorepoRoot(directory)) {
 		const monorepoInfo = findDependencyInfoFromMonorepoRoot(directory);
 		if (!reactVersion) reactVersion = monorepoInfo.reactVersion;
 		if (!tailwindVersion) tailwindVersion = monorepoInfo.tailwindVersion;
+		if (!zodVersion) zodVersion = 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;
 	const projectName = packageJson.name ?? path.basename(directory);
 	const hasTypeScript = fs.existsSync(path.join(directory, "tsconfig.json"));
 	const sourceFileCount = countSourceFiles(directory);
 	const hasReactNativeWorkspace = framework === "expo" || framework === "react-native" || hasReactNativeWorkspaceAnywhere(directory, packageJson);
+	const hasReanimated = hasReactNativeWorkspace && someWorkspacePackageJson(directory, packageJson, isPackageJsonReanimatedAware);
+	const preactVersion = getPreactVersion(packageJson);
 	const projectInfo = {
 		rootDirectory: directory,
 		projectName,
 		reactVersion,
 		reactMajorVersion: resolveEffectiveReactMajor(reactVersion, packageJson),
 		tailwindVersion,
+		zodVersion,
+		zodMajorVersion: parseZodMajor(zodVersion),
 		framework,
 		hasTypeScript,
 		hasReactCompiler: detectReactCompiler(directory, packageJson),
 		hasTanStackQuery: hasTanStackQuery(packageJson),
+		preactVersion,
+		preactMajorVersion: parseReactMajor(preactVersion),
 		hasReactNativeWorkspace,
+		hasReanimated,
 		sourceFileCount
 	};
 	cachedProjectInfos.set(directory, projectInfo);
 	return projectInfo;
 };
+const isAnalyzableProject = (project) => project.reactVersion !== null || project.preactVersion !== null;
+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 parseTailwindMajorMinor = (tailwindVersion) => {
 	if (typeof tailwindVersion !== "string") return null;
 	const trimmed = tailwindVersion.trim();
@@ -2972,8 +3187,10 @@ const isTailwindAtLeast = (detected, required) => {
 	return detected.minor >= required.minor;
 };
 const JSX_FILE_PATTERN = /\.(tsx|jsx)$/;
+const MILLISECONDS_PER_SECOND = 1e3;
 const SCORE_API_URL = "https://www.react.doctor/api/score";
 const SHARE_BASE_URL = "https://www.react.doctor/share";
+const PROMPTS_RULES_BASE_URL = "https://www.react.doctor/prompts/rules";
 const FETCH_TIMEOUT_MS = 1e4;
 const GITHUB_VIEWER_PERMISSION_TIMEOUT_MS = 2e3;
 const DEFAULT_BRANCH_CANDIDATES = ["main", "master"];
@@ -3876,17 +4093,26 @@ const layerOtlp = Layer.unwrap(Effect.gen(function* () {
 		headers
 	}).pipe(Layer.provide(FetchHttpClient.layer));
 }).pipe(Effect.orDie));
-Schema.String.pipe(Schema.brand("OxlintBinaryPath"));
-Schema.String.pipe(Schema.brand("NodeBinaryPath"));
-Context.Reference("react-doctor/OxlintSpawnTimeoutMs", { defaultValue: () => {
+/**
+* Per-batch oxlint wall-clock budget. Reads from the env var on
+* startup so the eval harness can raise the budget under sandbox
+* microVMs without recompiling react-doctor. Tests override via
+* `Layer.succeed(OxlintSpawnTimeoutMs, ...)`.
+*/
+var OxlintSpawnTimeoutMs = class extends Context.Reference("react-doctor/OxlintSpawnTimeoutMs", { defaultValue: () => {
 	const raw = process.env["REACT_DOCTOR_OXLINT_SPAWN_TIMEOUT_MS"];
 	if (raw === void 0) return OXLINT_SPAWN_TIMEOUT_MS;
 	const parsed = Number(raw);
 	if (!Number.isFinite(parsed) || parsed <= 0) return OXLINT_SPAWN_TIMEOUT_MS;
 	return parsed;
-} });
-Context.Reference("react-doctor/OxlintOutputMaxBytes", { defaultValue: () => OXLINT_OUTPUT_MAX_BYTES });
-Context.Reference("react-doctor/StagedFilesTempDirPrefix", { defaultValue: () => "react-doctor-staged-" });
+} }) {};
+/**
+* Hard cap on combined stdout+stderr bytes per oxlint batch. The
+* subprocess gets SIGKILL'd if it produces more; the recovery path
+* suggests narrowing the scan with --diff. Override via Layer in
+* tests that exercise the cap behavior.
+*/
+var OxlintOutputMaxBytes = class extends Context.Reference("react-doctor/OxlintOutputMaxBytes", { defaultValue: () => OXLINT_OUTPUT_MAX_BYTES }) {};
 const DIAGNOSTIC_SURFACES = [
 	"cli",
 	"prComment",
@@ -4491,6 +4717,59 @@ const collectIgnorePatterns = (rootDirectory) => {
 	return patterns;
 };
 const TSCONFIG_FILENAMES$1 = ["tsconfig.json", "tsconfig.base.json"];
+const DEAD_CODE_WORKER_SCRIPT = `
+const inputChunks = [];
+process.stdin.on("data", (chunk) => inputChunks.push(chunk));
+process.stdin.on("end", () => {
+  const workerInput = JSON.parse(Buffer.concat(inputChunks).toString("utf8"));
+
+  const normalizeResult = (result) => ({
+    unusedFiles: result.unusedFiles.map((unusedFile) => ({
+      path: unusedFile.path,
+    })),
+    unusedExports: result.unusedExports.map((unusedExport) => ({
+      path: unusedExport.path,
+      name: unusedExport.name,
+      line: unusedExport.line,
+      column: unusedExport.column,
+      isTypeOnly: unusedExport.isTypeOnly,
+    })),
+    unusedDependencies: result.unusedDependencies.map((unusedDependency) => ({
+      name: unusedDependency.name,
+      isDevDependency: unusedDependency.isDevDependency,
+    })),
+    circularDependencies: result.circularDependencies.map((cycle) => ({
+      files: cycle.files,
+    })),
+  });
+
+  const serializeError = (error) =>
+    error instanceof Error
+      ? { name: error.name, message: error.message, stack: error.stack }
+      : { message: String(error) };
+
+  const emit = (message) => {
+    process.stdout.write(JSON.stringify(message), () => process.exit(0));
+  };
+
+  (async () => {
+    try {
+      const { analyze, defineConfig } = await import(workerInput.deslopJsModuleSpecifier);
+      const config = {
+        rootDir: workerInput.rootDirectory,
+        ...(workerInput.tsConfigPath ? { tsConfigPath: workerInput.tsConfigPath } : {}),
+        ...(workerInput.ignorePatterns.length > 0
+          ? { ignorePatterns: workerInput.ignorePatterns }
+          : {}),
+      };
+      const result = await analyze(defineConfig(config));
+      emit({ ok: true, result: normalizeResult(result) });
+    } catch (error) {
+      emit({ ok: false, error: serializeError(error) });
+    }
+  })();
+});
+`;
 const resolveTsConfigPath = (rootDirectory) => {
 	for (const filename of TSCONFIG_FILENAMES$1) {
 		const candidate = path.join(rootDirectory, filename);
@@ -4511,16 +4790,191 @@ const toRelativeFilePath = (rootDirectory, filePath) => {
 	const relative = toRelativePath(filePath, rootDirectory);
 	return relative.length > 0 ? relative : filePath.replace(/\\/g, "/");
 };
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseArray = (value, label) => {
+	if (!Array.isArray(value)) throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseString = (value, label) => {
+	if (typeof value !== "string") throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseNumber = (value, label) => {
+	if (typeof value !== "number") throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseBoolean = (value, label) => {
+	if (typeof value !== "boolean") throw new Error(`Dead-code worker returned invalid ${label}.`);
+	return value;
+};
+const parseStringArray = (value, label) => {
+	return parseArray(value, label).map((entry, index) => parseString(entry, `${label}[${index}]`));
+};
+const parseUnusedFiles = (value) => {
+	const values = parseArray(value, "unusedFiles");
+	const unusedFiles = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid unusedFiles[${index}].`);
+		unusedFiles.push({ path: parseString(entry.path, `unusedFiles[${index}].path`) });
+	}
+	return unusedFiles;
+};
+const parseUnusedExports = (value) => {
+	const values = parseArray(value, "unusedExports");
+	const unusedExports = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid unusedExports[${index}].`);
+		unusedExports.push({
+			path: parseString(entry.path, `unusedExports[${index}].path`),
+			name: parseString(entry.name, `unusedExports[${index}].name`),
+			line: parseNumber(entry.line, `unusedExports[${index}].line`),
+			column: parseNumber(entry.column, `unusedExports[${index}].column`),
+			isTypeOnly: parseBoolean(entry.isTypeOnly, `unusedExports[${index}].isTypeOnly`)
+		});
+	}
+	return unusedExports;
+};
+const parseUnusedDependencies = (value) => {
+	const values = parseArray(value, "unusedDependencies");
+	const unusedDependencies = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid unusedDependencies[${index}].`);
+		unusedDependencies.push({
+			name: parseString(entry.name, `unusedDependencies[${index}].name`),
+			isDevDependency: parseBoolean(entry.isDevDependency, `unusedDependencies[${index}].isDevDependency`)
+		});
+	}
+	return unusedDependencies;
+};
+const parseCircularDependencies = (value) => {
+	const values = parseArray(value, "circularDependencies");
+	const circularDependencies = [];
+	for (const [index, entry] of values.entries()) {
+		if (!isRecord(entry)) throw new Error(`Dead-code worker returned invalid circularDependencies[${index}].`);
+		circularDependencies.push({ files: parseStringArray(entry.files, `circularDependencies[${index}].files`) });
+	}
+	return circularDependencies;
+};
+const parseDeadCodeWorkerResult = (value) => {
+	if (!isRecord(value)) throw new Error("Dead-code worker returned an invalid result.");
+	return {
+		unusedFiles: parseUnusedFiles(value.unusedFiles),
+		unusedExports: parseUnusedExports(value.unusedExports),
+		unusedDependencies: parseUnusedDependencies(value.unusedDependencies),
+		circularDependencies: parseCircularDependencies(value.circularDependencies)
+	};
+};
+const parseDeadCodeWorkerError = (value) => {
+	if (!isRecord(value) || typeof value.message !== "string") return { message: "Dead-code worker failed." };
+	return {
+		...typeof value.name === "string" ? { name: value.name } : {},
+		message: value.message,
+		...typeof value.stack === "string" ? { stack: value.stack } : {}
+	};
+};
+const parseDeadCodeWorkerMessage = (value) => {
+	if (!isRecord(value)) throw new Error("Dead-code worker returned an invalid message.");
+	if (value.ok === true) return {
+		ok: true,
+		result: value.result
+	};
+	if (value.ok === false) return {
+		ok: false,
+		error: parseDeadCodeWorkerError(value.error)
+	};
+	throw new Error("Dead-code worker returned an invalid status.");
+};
+const buildDeadCodeWorkerError = (workerError) => {
+	const error = new Error(workerError.message);
+	if (workerError.name !== void 0) error.name = workerError.name;
+	if (workerError.stack !== void 0) error.stack = workerError.stack;
+	return error;
+};
+const createDeadCodeWorker = (input) => {
+	const child = spawn(process.execPath, ["-e", DEAD_CODE_WORKER_SCRIPT], {
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true
+	});
+	const stdoutChunks = [];
+	const stderrChunks = [];
+	child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+	child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+	let didSettle = false;
+	const result = new Promise((resolve, reject) => {
+		const settle = (callback) => {
+			if (didSettle) return;
+			didSettle = true;
+			callback();
+		};
+		child.once("error", (error) => {
+			settle(() => reject(error));
+		});
+		child.once("close", (exitCode) => {
+			const stdout = Buffer.concat(stdoutChunks).toString("utf8").trim();
+			if (stdout.length === 0) {
+				const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+				settle(() => reject(/* @__PURE__ */ new Error(`Dead-code worker exited with code ${exitCode ?? "null"}${stderr ? `: ${stderr}` : ""}.`)));
+				return;
+			}
+			try {
+				const parsedMessage = parseDeadCodeWorkerMessage(JSON.parse(stdout));
+				if (parsedMessage.ok) {
+					settle(() => resolve(parsedMessage.result));
+					return;
+				}
+				settle(() => reject(buildDeadCodeWorkerError(parsedMessage.error)));
+			} catch (error) {
+				settle(() => reject(error));
+			}
+		});
+	});
+	child.stdin.on("error", () => {});
+	child.stdin.end(JSON.stringify(input));
+	return {
+		result,
+		terminate: () => {
+			didSettle = true;
+			child.kill("SIGKILL");
+		}
+	};
+};
+const runDeadCodeWorkerWithTimeout = (handle, timeoutMs) => new Promise((resolve, reject) => {
+	let didSettle = false;
+	const timeoutHandle = setTimeout(() => {
+		if (didSettle) return;
+		didSettle = true;
+		handle.terminate?.();
+		reject(/* @__PURE__ */ new Error(`Dead-code worker timed out after ${timeoutMs / MILLISECONDS_PER_SECOND}s.`));
+	}, timeoutMs);
+	timeoutHandle.unref?.();
+	handle.result.then((value) => {
+		if (didSettle) return;
+		didSettle = true;
+		clearTimeout(timeoutHandle);
+		handle.terminate?.();
+		resolve(value);
+	}, (error) => {
+		if (didSettle) return;
+		didSettle = true;
+		clearTimeout(timeoutHandle);
+		handle.terminate?.();
+		reject(error);
+	});
+});
 const checkDeadCode = async (options) => {
 	const { rootDirectory, userConfig } = options;
 	if (!fs.existsSync(path.join(rootDirectory, "package.json"))) return [];
-	const { analyze, defineConfig } = await import("deslop-js");
 	const ignorePatterns = collectDeadCodeIgnorePatterns(rootDirectory, userConfig);
-	const result = await analyze(defineConfig({
-		rootDir: rootDirectory,
+	const result = parseDeadCodeWorkerResult(await runDeadCodeWorkerWithTimeout((options.createWorker ?? createDeadCodeWorker)({
+		rootDirectory,
 		tsConfigPath: resolveTsConfigPath(rootDirectory),
-		...ignorePatterns.length > 0 ? { ignorePatterns } : {}
-	}));
+		ignorePatterns,
+		deslopJsModuleSpecifier: options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js")
+	}), options.workerTimeoutMs ?? 12e4));
 	const toRelative = (filePath) => toRelativeFilePath(rootDirectory, filePath);
 	const diagnostics = [];
 	for (const unusedFile of result.unusedFiles) diagnostics.push({
@@ -4726,8 +5180,15 @@ var Git = class Git extends Context.Service()("react-doctor/Git") {
 				env: input.env,
 				extendEnv: true
 			}));
+			const maxStdoutBytes = input.maxStdoutBytes;
+			const stdoutByteCount = yield* Ref.make(0);
+			const stdoutStream = maxStdoutBytes === void 0 ? handle.stdout : handle.stdout.pipe(Stream.tap((chunk) => Ref.updateAndGet(stdoutByteCount, (total) => total + chunk.length).pipe(Effect.flatMap((total) => total > maxStdoutBytes ? Effect.fail(new ReactDoctorError({ reason: new GitInvocationFailed({
+				args: [...input.args],
+				directory: input.directory,
+				cause: /* @__PURE__ */ new Error(`git stdout exceeded ${maxStdoutBytes} bytes`)
+			}) })) : Effect.void))));
 			const [stdout, stderr, status] = yield* Effect.all([
-				Stream.mkString(Stream.decodeText(handle.stdout)),
+				Stream.mkString(Stream.decodeText(stdoutStream)),
 				Stream.mkString(Stream.decodeText(handle.stderr)),
 				handle.exitCode
 			], { concurrency: 3 });
@@ -4889,7 +5350,12 @@ var Git = class Git extends Context.Service()("react-doctor/Git") {
 				if (result.status !== 0) return [];
 				return splitNullSeparated(result.stdout);
 			})),
-			showStagedContent: (directory, relativePath) => runGit(directory, ["show", `:${relativePath}`]).pipe(Effect.map((result) => result.status === 0 ? result.stdout : null)),
+			showStagedContent: (directory, relativePath, options) => runCommand({
+				command: "git",
+				args: ["show", `:${relativePath}`],
+				directory,
+				maxStdoutBytes: options?.maxBufferBytes
+			}).pipe(Effect.map((result) => result.status === 0 ? result.stdout : null)),
 			grep: (input) => Effect.gen(function* () {
 				const args = ["grep"];
 				if (input.listMatchingFiles ?? true) args.push("-l");
@@ -4897,7 +5363,12 @@ var Git = class Git extends Context.Service()("react-doctor/Git") {
 				if (input.extendedRegexp ?? false) args.push("-E");
 				args.push(input.pattern);
 				if (input.includePaths && input.includePaths.length > 0) args.push("--", ...input.includePaths);
-				const result = yield* runGit(input.directory, args);
+				const result = yield* runCommand({
+					command: "git",
+					args,
+					directory: input.directory,
+					maxStdoutBytes: input.maxBufferBytes
+				});
 				if (result.status === 128) return null;
 				return {
 					status: result.status,
@@ -5144,7 +5615,16 @@ const buildCapabilities = (project) => {
 	capabilities.add(project.framework);
 	if (project.framework === "expo" || project.framework === "react-native" || project.hasReactNativeWorkspace) capabilities.add("react-native");
 	const reactMajor = project.reactMajorVersion;
-	if (reactMajor !== null) for (let major = 17; major <= reactMajor; major++) capabilities.add(`react:${major}`);
+	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), {
@@ -5152,9 +5632,22 @@ const buildCapabilities = (project) => {
 			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.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");
+	}
 	return capabilities;
 };
 const shouldEnableRule = (requires, tags, capabilities, ignoredTags, disabledBy) => {
@@ -5409,6 +5902,13 @@ const buildNoSecretsRecommendation = (project, fallbackRecommendation) => {
 	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 appendReanimatedSharedValueHint = (help, rule, project) => {
+	if (rule !== "immutability") return help;
+	if (!project.hasReanimated) return help;
+	if (!help) return REANIMATED_SHARED_VALUE_HINT;
+	return `${help}\n\n${REANIMATED_SHARED_VALUE_HINT}`;
+};
 const REACT_MODULE_SOURCE = "react";
 const REQUIRE_IDENTIFIER = "require";
 const USE_IDENTIFIER = "use";
@@ -5732,7 +6232,7 @@ const getRuleCategory = (ruleName) => reactDoctorPlugin.rules[ruleName]?.categor
 const cleanDiagnosticMessage = (message, help, plugin, rule, project) => {
 	if (plugin === "react-hooks-js") return {
 		message: REACT_COMPILER_MESSAGE,
-		help: message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || help
+		help: appendReanimatedSharedValueHint(message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || help, rule, project)
 	};
 	return {
 		message: message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || message,
@@ -5801,13 +6301,6 @@ const SANITIZED_ENV = (() => {
 	}
 	return sanitized;
 })();
-const OXLINT_SPAWN_TIMEOUT_MS$1 = (() => {
-	const raw = process.env["REACT_DOCTOR_OXLINT_SPAWN_TIMEOUT_MS"];
-	if (raw === void 0) return OXLINT_SPAWN_TIMEOUT_MS;
-	const parsed = Number(raw);
-	if (!Number.isFinite(parsed) || parsed <= 0) return OXLINT_SPAWN_TIMEOUT_MS;
-	return parsed;
-})();
 /**
 * Spawn one oxlint subprocess with hard ceilings on wall time and
 * output size. Returns stdout on success; raises a tagged
@@ -5824,7 +6317,7 @@ const OXLINT_SPAWN_TIMEOUT_MS$1 = (() => {
 * The first three are splittable (the caller's binary-split retry
 * shrinks the batch and re-spawns); the fourth isn't.
 */
-const spawnOxlint = (args, rootDirectory, nodeBinaryPath) => new Promise((resolve, reject) => {
+const spawnOxlint = (args, rootDirectory, nodeBinaryPath, spawnTimeoutMs = OXLINT_SPAWN_TIMEOUT_MS, outputMaxBytes = OXLINT_OUTPUT_MAX_BYTES) => new Promise((resolve, reject) => {
 	const child = spawn(nodeBinaryPath, args, {
 		cwd: rootDirectory,
 		env: SANITIZED_ENV
@@ -5833,9 +6326,9 @@ const spawnOxlint = (args, rootDirectory, nodeBinaryPath) => new Promise((resolv
 		child.kill("SIGKILL");
 		reject(new ReactDoctorError({ reason: new OxlintBatchExceeded({
 			kind: "timeout",
-			detail: `${OXLINT_SPAWN_TIMEOUT_MS$1 / 1e3}s budget exceeded`
+			detail: `${spawnTimeoutMs / 1e3}s budget exceeded`
 		}) }));
-	}, OXLINT_SPAWN_TIMEOUT_MS$1);
+	}, spawnTimeoutMs);
 	timeoutHandle.unref?.();
 	const stdoutBuffers = [];
 	const stderrBuffers = [];
@@ -5845,7 +6338,7 @@ const spawnOxlint = (args, rootDirectory, nodeBinaryPath) => new Promise((resolv
 	const killIfTooLarge = (incomingBytes, isStdout) => {
 		if (isStdout) stdoutByteCount += incomingBytes;
 		else stderrByteCount += incomingBytes;
-		if (stdoutByteCount + stderrByteCount > 52428800 && !didKillForSize) {
+		if (stdoutByteCount + stderrByteCount > outputMaxBytes && !didKillForSize) {
 			didKillForSize = true;
 			child.kill("SIGKILL");
 			return true;
@@ -5871,7 +6364,7 @@ const spawnOxlint = (args, rootDirectory, nodeBinaryPath) => new Promise((resolv
 		if (didKillForSize) {
 			reject(new ReactDoctorError({ reason: new OxlintBatchExceeded({
 				kind: "output-too-large",
-				detail: `exceeded ${OXLINT_OUTPUT_MAX_BYTES} bytes — scan a smaller subset with --diff or --staged`
+				detail: `exceeded ${outputMaxBytes} bytes — scan a smaller subset with --diff or --staged`
 			}) }));
 			return;
 		}
@@ -5912,7 +6405,7 @@ const spawnOxlint = (args, rootDirectory, nodeBinaryPath) => new Promise((resolv
 * with a slimmer config in that case.
 */
 const spawnLintBatches = async (input) => {
-	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, onPartialFailure, onFileProgress } = input;
+	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes } = input;
 	const totalFileCount = fileBatches.reduce((sum, batch) => sum + batch.length, 0);
 	const allDiagnostics = [];
 	const droppedFiles = [];
@@ -5920,7 +6413,7 @@ const spawnLintBatches = async (input) => {
 	const spawnLintBatch = async (batch) => {
 		const batchArgs = [...baseArgs, ...batch];
 		try {
-			return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath), project, rootDirectory);
+			return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes), project, rootDirectory);
 		} catch (error) {
 			if (!isSplittableReactDoctorError(error)) throw error;
 			if (batch.length <= 1) {
@@ -6023,13 +6516,11 @@ const writeOxlintConfig = (configPath, configToWrite) => {
 *   6. always restore disable directives + clean up the temp dir
 */
 const runOxlint = async (options) => {
-	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure } = options;
+	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), userConfig, configSourceDirectory = rootDirectory, onPartialFailure, spawnTimeoutMs, outputMaxBytes } = options;
 	const serverAuthFunctionNames = Array.isArray(userConfig?.serverAuthFunctionNames) ? userConfig.serverAuthFunctionNames.filter((entry) => typeof entry === "string" && entry.length > 0) : void 0;
 	const severityControls = buildRuleSeverityControls(userConfig);
 	validateRuleRegistration();
 	if (includePaths !== void 0 && includePaths.length === 0) return [];
-	const configDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "react-doctor-oxlintrc-"));
-	const configPath = path.join(configDirectory, "oxlintrc.json");
 	const pluginPath = resolvePluginPath();
 	const extendsPaths = (adoptExistingLintConfig && !customRulesOnly ? detectUserLintConfigPaths(rootDirectory) : []).filter(canOxlintExtendConfig);
 	const userPlugins = resolveUserPlugins(userConfig?.plugins, configSourceDirectory);
@@ -6044,6 +6535,8 @@ const runOxlint = async (options) => {
 		userPlugins
 	});
 	const restoreDisableDirectives = respectInlineDisables ? () => {} : await neutralizeDisableDirectives(rootDirectory, includePaths);
+	const configDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "react-doctor-oxlintrc-"));
+	const configPath = path.join(configDirectory, "oxlintrc.json");
 	try {
 		const baseArgs = [
 			resolveOxlintBinary(),
@@ -6070,7 +6563,9 @@ const runOxlint = async (options) => {
 			nodeBinaryPath,
 			project,
 			onPartialFailure,
-			onFileProgress: options.onFileProgress
+			onFileProgress: options.onFileProgress,
+			spawnTimeoutMs,
+			outputMaxBytes
 		});
 		writeOxlintConfig(configPath, buildConfig(extendsPaths));
 		try {
@@ -6136,6 +6631,8 @@ var Linter = class Linter extends Context.Service()("react-doctor/Linter") {
 	*/
 	static layerOxlint = Layer.succeed(Linter, Linter.of({ run: (input) => Stream.unwrap(Effect.fn("Linter.run")(function* () {
 		const partialFailures = yield* LintPartialFailures;
+		const spawnTimeoutMs = yield* OxlintSpawnTimeoutMs;
+		const outputMaxBytes = yield* OxlintOutputMaxBytes;
 		const collectedFailures = [];
 		const diagnostics = yield* Effect.tryPromise({
 			try: () => runOxlint({
@@ -6152,7 +6649,9 @@ var Linter = class Linter extends Context.Service()("react-doctor/Linter") {
 				onPartialFailure: (reason) => {
 					collectedFailures.push(reason);
 				},
-				onFileProgress: input.onFileProgress
+				onFileProgress: input.onFileProgress,
+				spawnTimeoutMs,
+				outputMaxBytes
 			}),
 			catch: ensureReactDoctorError
 		});
@@ -6450,7 +6949,7 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 	const resolvedConfig = yield* configService.resolve(input.directory);
 	const scanDirectory = resolvedConfig.resolvedDirectory;
 	const project = yield* projectService.discover(scanDirectory);
-	if (project.reactVersion === null) return yield* new ReactDoctorError({ reason: new NoReactDependency({ directory: scanDirectory }) });
+	if (!isAnalyzableProject(project)) return yield* new ReactDoctorError({ reason: new NoReactDependency({ directory: scanDirectory }) });
 	const [repo, sha, defaultBranch] = yield* Effect.all([
 		gitService.githubRepo(scanDirectory).pipe(Effect.orElseSucceed(() => null)),
 		gitService.headSha(scanDirectory).pipe(Effect.orElseSucceed(() => null)),
@@ -6478,23 +6977,13 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 	const lintFailure = yield* Ref.make({
 		didFail: false,
 		reason: null,
-		reasonTag: null
+		reasonTag: null,
+		reasonKind: null
 	});
 	const deadCodeFailure = yield* Ref.make({
 		didFail: false,
 		reason: null
 	});
-	const shouldRunDeadCode = input.runDeadCode && !isDiffMode;
-	const deadCodeFiber = yield* Effect.forkChild(shouldRunDeadCode ? Stream.runCollect(applyPerElementPipeline(deadCodeService.run({
-		rootDirectory: scanDirectory,
-		userConfig: resolvedConfig.config
-	}).pipe(Stream.catchTag("ReactDoctorError", (error) => Stream.unwrap(Effect.gen(function* () {
-		yield* Ref.set(deadCodeFailure, {
-			didFail: true,
-			reason: error.message
-		});
-		return Stream.empty;
-	})))))) : Effect.succeed([]));
 	const scanProgress = yield* progressService.start("Scanning...");
 	const scanStartTime = Date.now();
 	let lastReportedTotalFileCount = 0;
@@ -6511,24 +7000,32 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 		configSourceDirectory: resolvedConfig.configSourceDirectory ?? void 0,
 		onFileProgress: (scannedFileCount, totalFileCount) => {
 			lastReportedTotalFileCount = totalFileCount;
-			Effect.runSync(scanProgress.update(`Scanning (${scannedFileCount}/${totalFileCount})...`));
+			Effect.runSync(scanProgress.update(`Scanning files (${scannedFileCount}/${totalFileCount})...`));
 		}
 	}).pipe(Stream.catchTag("ReactDoctorError", (error) => Stream.unwrap(Effect.gen(function* () {
 		yield* Ref.set(lintFailure, {
 			didFail: true,
 			reason: error.message,
-			reasonTag: error.reason._tag
+			reasonTag: error.reason._tag,
+			reasonKind: error.reason._tag === "OxlintUnavailable" ? error.reason.kind : null
 		});
 		return Stream.empty;
 	}))));
 	const lintCollected = yield* Stream.runCollect(applyPerElementPipeline(rawLintStream));
 	const lintFailureState = yield* Ref.get(lintFailure);
 	yield* afterLint(lintFailureState.didFail);
-	if (lintFailureState.didFail) {
-		yield* Fiber.interrupt(deadCodeFiber);
-		yield* scanProgress.fail(formatLintFailText(lintFailureState.reasonTag, process.version));
-	}
-	const deadCodeCollected = lintFailureState.didFail ? [] : yield* Fiber.join(deadCodeFiber);
+	if (lintFailureState.didFail) yield* scanProgress.fail(formatLintFailText(lintFailureState.reasonTag, process.version));
+	const shouldRunDeadCode = input.runDeadCode && !isDiffMode;
+	const deadCodeCollected = lintFailureState.didFail || !shouldRunDeadCode ? [] : yield* scanProgress.update("Analyzing dead code...").pipe(Effect.andThen(Stream.runCollect(applyPerElementPipeline(deadCodeService.run({
+		rootDirectory: scanDirectory,
+		userConfig: resolvedConfig.config
+	}).pipe(Stream.catchTag("ReactDoctorError", (error) => Stream.unwrap(Effect.gen(function* () {
+		yield* Ref.set(deadCodeFailure, {
+			didFail: true,
+			reason: error.message
+		});
+		return Stream.empty;
+	}))))))));
 	const deadCodeFailureState = yield* Ref.get(deadCodeFailure);
 	const scanElapsedSeconds = ((Date.now() - scanStartTime) / 1e3).toFixed(1);
 	const totalFileCount = lastReportedTotalFileCount || (lintIncludePaths?.length ?? project.sourceFileCount);
@@ -6570,6 +7067,7 @@ const runInspect = (input, hooks = {}) => Effect.gen(function* () {
 		didLintFail: lintFailureState.didFail,
 		lintFailureReason: lintFailureState.reason,
 		lintFailureReasonTag: lintFailureState.reasonTag,
+		lintFailureReasonKind: lintFailureState.reasonKind,
 		lintPartialFailures,
 		didDeadCodeFail: deadCodeFailureState.didFail,
 		deadCodeFailureReason: deadCodeFailureState.reason
@@ -7007,6 +7505,13 @@ const highlighter = {
 	gray: import_picocolors.default.gray,
 	bold: import_picocolors.default.bold
 };
+/**
+* Canonical URL for a rule's reviewer-tested fix recipe, served at
+* `https://www.react.doctor/prompts/rules/<plugin>/<rule>.md`. The
+* `/doctor` playbook fetches it on demand so each fix follows the
+* canonical recipe instead of being improvised per diagnostic.
+*/
+const buildRulePromptUrl = (plugin, rule) => `${PROMPTS_RULES_BASE_URL}/${plugin}/${rule}.md`;
 const groupBy = (items, keyFn) => {
 	const groups = /* @__PURE__ */ new Map();
 	for (const item of items) {
@@ -7023,7 +7528,7 @@ var cli_logger_exports = /* @__PURE__ */ __exportAll({ cliLogger: () => cliLogge
 /**
 * Thin synchronous façade over Effect's `Console` module. Used by
 * the imperative CLI helper files (`select-projects`, `run-explain`,
-* `install-skill`, the legacy paths in `cli/commands/inspect.ts`)
+* `install-react-doctor`, the legacy paths in `cli/commands/inspect.ts`)
 * that aren't yet Effect-typed. Every call drains into a single
 * `Console.*` Effect via `Effect.runSync`, so the underlying logging
 * pipeline is identical to the canonical `yield* Console.log(...)`
@@ -7054,6 +7559,6 @@ const cliLogger = {
 	}
 };
 //#endregion
-export { isReactDoctorError as A, filterSourceFiles as C, groupBy as D, getDiffInfo as E, runInspect as F, toRelativePath as I, listWorkspacePackages as M, resolveScanTarget as N, highlighter as O, restoreLegacyThrow as P, filterDiagnosticsForSurface as S, formatReactDoctorError as T, Score as _, DeadCode as a, buildJsonReportError as b, LintPartialFailures as c, OXLINT_NODE_REQUIREMENT as d, Progress as f, SKILL_NAME as g, SHARE_BASE_URL as h, Config as i, layerOtlp as j, isMonorepoRoot as k, Linter as l, Reporter as m, cli_logger_exports as n, Files as o, Project as p, CANONICAL_GITHUB_URL as r, Git as s, cliLogger as t, NodeResolver as u, StagedFiles as v, formatErrorChain as w, discoverReactSubprojects as x, buildJsonReport as y };
+export { isMonorepoRoot as A, filterDiagnosticsForSurface as C, getDiffInfo as D, formatReactDoctorError as E, restoreLegacyThrow as F, runInspect as I, toRelativePath as L, layerOtlp as M, listWorkspacePackages as N, groupBy as O, resolveScanTarget as P, discoverReactSubprojects as S, formatErrorChain as T, Score as _, DeadCode as a, buildJsonReportError as b, LintPartialFailures as c, OXLINT_NODE_REQUIREMENT as d, Progress as f, SKILL_NAME as g, SHARE_BASE_URL as h, Config as i, isReactDoctorError as j, highlighter as k, Linter as l, Reporter as m, cli_logger_exports as n, Files as o, Project as p, CANONICAL_GITHUB_URL as r, Git as s, cliLogger as t, NodeResolver as u, StagedFiles as v, filterSourceFiles as w, buildRulePromptUrl as x, buildJsonReport as y };
 
-//# sourceMappingURL=cli-logger-BliQX9s8.js.map
+//# sourceMappingURL=cli-logger-CSZagq1E.js.map