react-doctor 0.2.10 → 0.2.11-dev.d0f5206

package/dist/{cli-logger-BRBUS1pE.js → cli-logger-Df45H6Lw.js}

@@ -22,7 +22,6 @@ import * as Option from "effect/Option";
 import * as Ref from "effect/Ref";
 import * as Stream from "effect/Stream";
 import * as Cache from "effect/Cache";
-import { Worker } from "node:worker_threads";
 import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
 import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
 import * as NodePath from "@effect/platform-node-shared/NodePath";
@@ -2698,6 +2697,21 @@ const findDependencyInfoFromMonorepoRoot = (directory) => {
 		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",
@@ -2728,27 +2742,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 hasPreact = (packageJson) => {
-	return "preact" in {
+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",
@@ -2763,6 +2763,16 @@ 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 hasUpperBoundOnlyPeerRange = (range) => {
 	if (typeof range !== "string") return false;
 	const normalizedRange = normalizeDependencyVersion(range);
@@ -2849,12 +2859,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);
@@ -2866,10 +2886,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;
@@ -2937,6 +2961,8 @@ const discoverProject = (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,
@@ -2947,13 +2973,16 @@ const discoverProject = (directory) => {
 		hasTypeScript,
 		hasReactCompiler: detectReactCompiler(directory, packageJson),
 		hasTanStackQuery: hasTanStackQuery(packageJson),
-		hasPreact: hasPreact(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;
@@ -3923,17 +3952,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",
@@ -4539,47 +4577,57 @@ const collectIgnorePatterns = (rootDirectory) => {
 };
 const TSCONFIG_FILENAMES$1 = ["tsconfig.json", "tsconfig.base.json"];
 const DEAD_CODE_WORKER_SCRIPT = `
-const { parentPort, workerData } = require("node:worker_threads");
+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 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 serializeError = (error) =>
+    error instanceof Error
+      ? { name: error.name, message: error.message, stack: error.stack }
+      : { message: String(error) };
 
-(async () => {
-  try {
-    const { analyze, defineConfig } = await import(workerData.deslopJsModuleSpecifier);
-    const config = {
-      rootDir: workerData.rootDirectory,
-      ...(workerData.tsConfigPath ? { tsConfigPath: workerData.tsConfigPath } : {}),
-      ...(workerData.ignorePatterns.length > 0 ? { ignorePatterns: workerData.ignorePatterns } : {}),
-    };
-    const result = await analyze(defineConfig(config));
-    parentPort.postMessage({ ok: true, result: normalizeResult(result) });
-  } catch (error) {
-    parentPort.postMessage({ ok: false, error: serializeError(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) {
@@ -4702,43 +4750,54 @@ const buildDeadCodeWorkerError = (workerError) => {
 	return error;
 };
 const createDeadCodeWorker = (input) => {
-	const worker = new Worker(DEAD_CODE_WORKER_SCRIPT, {
-		eval: true,
-		workerData: 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;
-	return {
-		result: new Promise((resolve, reject) => {
-			const settle = (callback) => {
-				if (didSettle) return;
-				didSettle = true;
-				worker.removeAllListeners();
-				callback();
-			};
-			worker.once("message", (message) => {
-				try {
-					const parsedMessage = parseDeadCodeWorkerMessage(message);
-					if (parsedMessage.ok) {
-						settle(() => resolve(parsedMessage.result));
-						return;
-					}
-					settle(() => reject(buildDeadCodeWorkerError(parsedMessage.error)));
-				} catch (error) {
-					settle(() => reject(error));
+	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;
 				}
-			});
-			worker.once("error", (error) => {
+				settle(() => reject(buildDeadCodeWorkerError(parsedMessage.error)));
+			} catch (error) {
 				settle(() => reject(error));
-			});
-			worker.once("exit", (exitCode) => {
-				if (exitCode === 0) return;
-				settle(() => reject(/* @__PURE__ */ new Error(`Dead-code worker exited with code ${exitCode}.`)));
-			});
-		}),
+			}
+		});
+	});
+	child.stdin.on("error", () => {});
+	child.stdin.end(JSON.stringify(input));
+	return {
+		result,
 		terminate: () => {
 			didSettle = true;
-			worker.removeAllListeners();
-			return worker.terminate();
+			child.kill("SIGKILL");
 		}
 	};
 };
@@ -4980,8 +5039,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 });
@@ -5143,7 +5209,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");
@@ -5151,7 +5222,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,
@@ -5399,7 +5475,8 @@ const buildCapabilities = (project) => {
 	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}`);
+		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,
@@ -5417,8 +5494,13 @@ const buildCapabilities = (project) => {
 	if (project.hasReactCompiler) capabilities.add("react-compiler");
 	if (project.hasTanStackQuery) capabilities.add("tanstack-query");
 	if (project.hasTypeScript) capabilities.add("typescript");
-	if (project.hasPreact) {
+	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;
@@ -5675,6 +5757,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";
@@ -5998,7 +6087,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,
@@ -6067,13 +6156,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
@@ -6090,7 +6172,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
@@ -6099,9 +6181,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 = [];
@@ -6111,7 +6193,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;
@@ -6137,7 +6219,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;
 		}
@@ -6178,7 +6260,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 = [];
@@ -6186,7 +6268,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) {
@@ -6289,13 +6371,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);
@@ -6310,6 +6390,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(),
@@ -6336,7 +6418,9 @@ const runOxlint = async (options) => {
 			nodeBinaryPath,
 			project,
 			onPartialFailure,
-			onFileProgress: options.onFileProgress
+			onFileProgress: options.onFileProgress,
+			spawnTimeoutMs,
+			outputMaxBytes
 		});
 		writeOxlintConfig(configPath, buildConfig(extendsPaths));
 		try {
@@ -6402,6 +6486,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({
@@ -6418,7 +6504,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
 		});
@@ -6716,7 +6804,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)),
@@ -6744,7 +6832,8 @@ 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,
@@ -6766,13 +6855,14 @@ 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;
 	}))));
@@ -6832,6 +6922,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
@@ -7318,4 +7409,4 @@ 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 };
 
-//# sourceMappingURL=cli-logger-BRBUS1pE.js.map
+//# sourceMappingURL=cli-logger-Df45H6Lw.js.map