react-doctor 0.2.9 → 0.2.11-dev.f036b0f

package/dist/index.js

@@ -2298,11 +2298,13 @@ 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;
@@ -2721,6 +2723,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",
@@ -2751,20 +2768,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",
@@ -2779,6 +2789,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);
@@ -2803,7 +2823,8 @@ const resolveEffectiveReactMajor = (reactVersion, packageJson) => {
 const REACT_DEPENDENCY_NAMES = new Set([
 	"react",
 	"react-native",
-	"next"
+	"next",
+	"preact"
 ]);
 const hasReactDependency = (packageJson) => {
 	const allDependencies = {
@@ -2864,12 +2885,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);
@@ -2881,10 +2912,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;
@@ -2955,6 +2990,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,
@@ -2965,12 +3002,50 @@ const discoverProject = (directory) => {
 		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();
@@ -3001,6 +3076,7 @@ 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 FETCH_TIMEOUT_MS = 1e4;
 const GITHUB_VIEWER_PERMISSION_TIMEOUT_MS = 2e3;
@@ -3901,17 +3977,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",
@@ -4522,6 +4607,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);
@@ -4542,16 +4680,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({
@@ -4757,8 +5070,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 });
@@ -4920,7 +5240,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");
@@ -4928,7 +5253,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,
@@ -5175,7 +5505,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), {
@@ -5186,6 +5525,15 @@ 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.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) => {
@@ -5440,6 +5788,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";
@@ -5763,7 +6118,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,
@@ -5832,13 +6187,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
@@ -5855,7 +6203,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
@@ -5864,9 +6212,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 = [];
@@ -5876,7 +6224,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;
@@ -5902,7 +6250,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;
 		}
@@ -5943,7 +6291,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 = [];
@@ -5951,7 +6299,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) {
@@ -6054,13 +6402,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);
@@ -6075,6 +6421,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(),
@@ -6101,7 +6449,9 @@ const runOxlint = async (options) => {
 			nodeBinaryPath,
 			project,
 			onPartialFailure,
-			onFileProgress: options.onFileProgress
+			onFileProgress: options.onFileProgress,
+			spawnTimeoutMs,
+			outputMaxBytes
 		});
 		writeOxlintConfig(configPath, buildConfig(extendsPaths));
 		try {
@@ -6167,6 +6517,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({
@@ -6183,7 +6535,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
 		});
@@ -6481,7 +6835,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)),
@@ -6509,23 +6863,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;
@@ -6542,24 +6886,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);
@@ -6601,6 +6953,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
@@ -7035,11 +7388,12 @@ const buildInspectProgram = (scanTarget, options, configOverride) => {
 const outputToDiagnoseResult = (output, elapsedMilliseconds) => {
 	if (output.didLintFail && output.lintFailureReason !== null) console.error("Lint failed:", output.lintFailureReason);
 	const skippedChecks = [];
+	if (output.didLintFail) skippedChecks.push("lint");
+	if (output.didDeadCodeFail) skippedChecks.push("dead-code");
 	const skippedCheckReasons = {};
-	if (output.didDeadCodeFail && output.deadCodeFailureReason !== null) {
-		skippedChecks.push("dead-code");
-		skippedCheckReasons["dead-code"] = output.deadCodeFailureReason;
-	}
+	if (output.didLintFail && output.lintFailureReason !== null) skippedCheckReasons.lint = output.lintFailureReason;
+	else if (output.lintPartialFailures.length > 0) skippedCheckReasons["lint:partial"] = output.lintPartialFailures.join("; ");
+	if (output.didDeadCodeFail && output.deadCodeFailureReason !== null) skippedCheckReasons["dead-code"] = output.deadCodeFailureReason;
 	return {
 		diagnostics: [...output.diagnostics],
 		score: output.score,