react-doctor 0.0.42 → 0.0.45

package/dist/index.js

@@ -1,18 +1,39 @@
 import { createRequire } from "node:module";
 import path from "node:path";
-import { execSync, spawn, spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
+import pc from "picocolors";
 import { main } from "knip";
 import { createOptions } from "knip/session";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
-//#region src/core/build-diagnose-result.ts
-const buildDiagnoseResult = (params) => ({
-	diagnostics: params.diagnostics,
-	score: params.score,
-	project: params.project,
-	elapsedMilliseconds: params.elapsedMilliseconds
-});
+//#region src/constants.ts
+const SOURCE_FILE_PATTERN = /\.(tsx?|jsx?)$/;
+const JSX_FILE_PATTERN = /\.(tsx|jsx)$/;
+const SCORE_API_URL = "https://www.react.doctor/api/score";
+const FETCH_TIMEOUT_MS = 1e4;
+const GIT_LS_FILES_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+const DEFAULT_BRANCH_CANDIDATES = ["main", "master"];
+const ERROR_RULE_PENALTY = 1.5;
+const WARNING_RULE_PENALTY = .75;
+const KNIP_CONFIG_LOCATIONS = [
+	"knip.json",
+	"knip.jsonc",
+	".knip.json",
+	".knip.jsonc",
+	"knip.ts",
+	"knip.js",
+	"knip.config.ts",
+	"knip.config.js"
+];
+const IGNORED_DIRECTORIES = new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"coverage"
+]);
+const PROXY_OUTPUT_MAX_BYTES = 50 * 1024 * 1024;
+const buildNoReactDependencyError = (directory) => `No React dependency found in ${directory}/package.json. Add "react" to dependencies (or peerDependencies) and re-run.`;
 //#endregion
 //#region src/utils/match-glob-pattern.ts
 const REGEX_SPECIAL_CHARACTERS = /[.+^${}()|[\]\\]/g;
@@ -48,7 +69,11 @@ const toRelativePath = (filePath, rootDirectory) => {
 	if (normalizedFilePath.startsWith(normalizedRoot)) return normalizedFilePath.slice(normalizedRoot.length);
 	return normalizedFilePath.replace(/^\.\//, "");
 };
-const compileIgnoredFilePatterns = (userConfig) => Array.isArray(userConfig?.ignore?.files) ? userConfig.ignore.files.map(compileGlobPattern) : [];
+const compileIgnoredFilePatterns = (userConfig) => {
+	const files = userConfig?.ignore?.files;
+	if (!Array.isArray(files)) return [];
+	return files.filter((entry) => typeof entry === "string").map(compileGlobPattern);
+};
 const isFileIgnoredByPatterns = (filePath, rootDirectory, patterns) => {
 	if (patterns.length === 0) return false;
 	const relativePath = toRelativePath(filePath, rootDirectory);
@@ -89,9 +114,9 @@ const isRuleSuppressed = (commentRules, ruleId) => {
 	return commentRules.split(/[,\s]+/).some((rule) => rule.trim() === ruleId);
 };
 const filterIgnoredDiagnostics = (diagnostics, config, rootDirectory, readFileLinesSync) => {
-	const ignoredRules = new Set(Array.isArray(config.ignore?.rules) ? config.ignore.rules : []);
+	const ignoredRules = new Set(Array.isArray(config.ignore?.rules) ? config.ignore.rules.filter((rule) => typeof rule === "string") : []);
 	const ignoredFilePatterns = compileIgnoredFilePatterns(config);
-	const textComponentNames = new Set(Array.isArray(config.textComponents) ? config.textComponents : []);
+	const textComponentNames = new Set(Array.isArray(config.textComponents) ? config.textComponents.filter((name) => typeof name === "string") : []);
 	const hasTextComponents = textComponentNames.size > 0;
 	const getFileLines = createFileLinesCache(rootDirectory, readFileLinesSync);
 	return diagnostics.filter((diagnostic) => {
@@ -144,32 +169,6 @@ const buildDiagnoseTimedResult = async (input) => {
 	};
 };
 //#endregion
-//#region src/constants.ts
-const SOURCE_FILE_PATTERN = /\.(tsx?|jsx?)$/;
-const JSX_FILE_PATTERN = /\.(tsx|jsx)$/;
-const SCORE_API_URL = "https://www.react.doctor/api/score";
-const FETCH_TIMEOUT_MS = 1e4;
-const GIT_LS_FILES_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
-const DEFAULT_BRANCH_CANDIDATES = ["main", "master"];
-const ERROR_RULE_PENALTY = 1.5;
-const WARNING_RULE_PENALTY = .75;
-const KNIP_CONFIG_LOCATIONS = [
-	"knip.json",
-	"knip.jsonc",
-	".knip.json",
-	".knip.jsonc",
-	"knip.ts",
-	"knip.js",
-	"knip.config.ts",
-	"knip.config.js"
-];
-const IGNORED_DIRECTORIES = new Set([
-	"node_modules",
-	"dist",
-	"build",
-	"coverage"
-]);
-//#endregion
 //#region src/utils/jsx-include-paths.ts
 const computeJsxIncludePaths = (includePaths) => includePaths.length > 0 ? includePaths.filter((filePath) => JSX_FILE_PATTERN.test(filePath)) : void 0;
 //#endregion
@@ -183,7 +182,7 @@ const diagnoseCore = async (deps, options = {}) => {
 	const userConfig = deps.loadUserConfig();
 	const effectiveLint = options.lint ?? userConfig?.lint ?? true;
 	const effectiveDeadCode = options.deadCode ?? userConfig?.deadCode ?? true;
-	if (!projectInfo.reactVersion) throw new Error("No React dependency found in package.json");
+	if (!projectInfo.reactVersion) throw new Error(buildNoReactDependencyError(deps.rootDirectory));
 	const lintIncludePaths = options.lintIncludePaths !== void 0 ? options.lintIncludePaths : computeJsxIncludePaths(includePaths);
 	const { runLint, runDeadCode } = deps.createRunners({
 		resolvedDirectory,
@@ -201,7 +200,11 @@ const diagnoseCore = async (deps, options = {}) => {
 		console.error("Dead code analysis failed:", error);
 		return emptyDiagnostics;
 	}) : Promise.resolve(emptyDiagnostics);
-	const [lintDiagnostics, deadCodeDiagnostics] = await Promise.all([lintPromise, deadCodePromise]);
+	const [lintSettled, deadCodeSettled] = await Promise.allSettled([lintPromise, deadCodePromise]);
+	const lintDiagnostics = lintSettled.status === "fulfilled" ? lintSettled.value : emptyDiagnostics;
+	const deadCodeDiagnostics = deadCodeSettled.status === "fulfilled" ? deadCodeSettled.value : emptyDiagnostics;
+	if (lintSettled.status === "rejected") console.error("Lint rejected:", lintSettled.reason);
+	if (deadCodeSettled.status === "rejected") console.error("Dead code rejected:", deadCodeSettled.reason);
 	const environmentDiagnostics = deps.getExtraDiagnostics?.() ?? [];
 	const timed = await buildDiagnoseTimedResult({
 		mergedDiagnostics: [
@@ -215,12 +218,145 @@ const diagnoseCore = async (deps, options = {}) => {
 		startTime,
 		calculateDiagnosticsScore: deps.calculateDiagnosticsScore
 	});
-	return buildDiagnoseResult({
+	return {
 		diagnostics: timed.diagnostics,
 		score: timed.score,
 		project: projectInfo,
 		elapsedMilliseconds: timed.elapsedMilliseconds
-	});
+	};
+};
+//#endregion
+//#region src/utils/summarize-diagnostics.ts
+const summarizeDiagnostics = (diagnostics, worstScore = null, worstScoreLabel = null) => {
+	let errorCount = 0;
+	let warningCount = 0;
+	const affectedFiles = /* @__PURE__ */ new Set();
+	for (const diagnostic of diagnostics) {
+		if (diagnostic.severity === "error") errorCount++;
+		else warningCount++;
+		affectedFiles.add(diagnostic.filePath);
+	}
+	return {
+		errorCount,
+		warningCount,
+		affectedFileCount: affectedFiles.size,
+		totalDiagnosticCount: diagnostics.length,
+		score: worstScore,
+		scoreLabel: worstScoreLabel
+	};
+};
+//#endregion
+//#region src/utils/build-json-report.ts
+const toJsonDiff = (diff) => {
+	if (!diff) return null;
+	return {
+		baseBranch: diff.baseBranch,
+		currentBranch: diff.currentBranch,
+		changedFileCount: diff.changedFiles.length,
+		isCurrentChanges: Boolean(diff.isCurrentChanges)
+	};
+};
+const findWorstScoredProject = (projects) => {
+	let worst = null;
+	let worstScore = Number.POSITIVE_INFINITY;
+	for (const project of projects) {
+		const score = project.score?.score;
+		if (typeof score !== "number") continue;
+		if (score < worstScore) {
+			worstScore = score;
+			worst = project;
+		}
+	}
+	return worst;
+};
+const buildJsonReport = (input) => {
+	const projects = input.scans.map(({ directory, result }) => ({
+		directory,
+		project: result.project,
+		diagnostics: result.diagnostics,
+		score: result.score,
+		skippedChecks: result.skippedChecks,
+		elapsedMilliseconds: result.elapsedMilliseconds
+	}));
+	const flattenedDiagnostics = projects.flatMap((entry) => entry.diagnostics);
+	const worstScoredProject = findWorstScoredProject(projects);
+	const summary = summarizeDiagnostics(flattenedDiagnostics, worstScoredProject?.score?.score ?? null, worstScoredProject?.score?.label ?? null);
+	return {
+		schemaVersion: 1,
+		version: input.version,
+		ok: true,
+		directory: input.directory,
+		mode: input.mode,
+		diff: toJsonDiff(input.diff),
+		projects,
+		diagnostics: flattenedDiagnostics,
+		summary,
+		elapsedMilliseconds: input.totalElapsedMilliseconds,
+		error: null
+	};
+};
+//#endregion
+//#region src/utils/format-error-chain.ts
+const collectErrorChain = (rootError) => {
+	const errorChain = [];
+	const visitedErrors = /* @__PURE__ */ new Set();
+	let currentError = rootError;
+	while (currentError !== void 0 && !visitedErrors.has(currentError)) {
+		visitedErrors.add(currentError);
+		errorChain.push(currentError);
+		currentError = currentError instanceof Error ? currentError.cause : void 0;
+	}
+	return errorChain;
+};
+const formatErrorMessage = (error) => error instanceof Error ? error.message || error.name : String(error);
+const getErrorChainMessages = (rootError) => collectErrorChain(rootError).map(formatErrorMessage);
+//#endregion
+//#region src/utils/build-json-report-error.ts
+const safeStringify = (value) => {
+	try {
+		return String(value);
+	} catch {
+		return "Unrepresentable error";
+	}
+};
+const safeGetErrorChain = (error) => {
+	try {
+		return getErrorChainMessages(error);
+	} catch {
+		return [safeStringify(error)];
+	}
+};
+const buildJsonReportError = (input) => {
+	const chain = safeGetErrorChain(input.error);
+	const errorPayload = input.error instanceof Error ? {
+		message: input.error.message || input.error.name || "Error",
+		name: input.error.name || "Error",
+		chain
+	} : {
+		message: safeStringify(input.error),
+		name: "Error",
+		chain
+	};
+	return {
+		schemaVersion: 1,
+		version: input.version,
+		ok: false,
+		directory: input.directory,
+		mode: input.mode ?? "full",
+		diff: null,
+		projects: [],
+		diagnostics: [],
+		summary: {
+			errorCount: 0,
+			warningCount: 0,
+			affectedFileCount: 0,
+			totalDiagnosticCount: 0,
+			score: null,
+			scoreLabel: null
+		},
+		elapsedMilliseconds: input.elapsedMilliseconds,
+		error: errorPayload
+	};
 };
 //#endregion
 //#region src/plugin/constants.ts
@@ -236,7 +372,11 @@ const isFile = (filePath) => {
 };
 //#endregion
 //#region src/utils/read-package-json.ts
-const readPackageJson = (packageJsonPath) => {
+const cachedPackageJsons = /* @__PURE__ */ new Map();
+const clearPackageJsonCache = () => {
+	cachedPackageJsons.clear();
+};
+const readPackageJsonUncached = (packageJsonPath) => {
 	try {
 		return JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
 	} catch (error) {
@@ -248,10 +388,25 @@ const readPackageJson = (packageJsonPath) => {
 		throw error;
 	}
 };
+const readPackageJson = (packageJsonPath) => {
+	const absolutePath = path.resolve(packageJsonPath);
+	const cached = cachedPackageJsons.get(absolutePath);
+	if (cached !== void 0) return cached;
+	const result = readPackageJsonUncached(absolutePath);
+	cachedPackageJsons.set(absolutePath, result);
+	return result;
+};
 //#endregion
 //#region src/utils/check-reduced-motion.ts
 const REDUCED_MOTION_GREP_PATTERN = "prefers-reduced-motion|useReducedMotion|MotionConfig|reducedMotion";
-const REDUCED_MOTION_FILE_GLOBS = "\"*.ts\" \"*.tsx\" \"*.js\" \"*.jsx\" \"*.css\" \"*.scss\"";
+const REDUCED_MOTION_FILE_GLOBS = [
+	"*.ts",
+	"*.tsx",
+	"*.js",
+	"*.jsx",
+	"*.css",
+	"*.scss"
+];
 const MISSING_REDUCED_MOTION_DIAGNOSTIC = {
 	filePath: "package.json",
 	plugin: "react-doctor",
@@ -261,8 +416,7 @@ const MISSING_REDUCED_MOTION_DIAGNOSTIC = {
 	help: "Add `useReducedMotion()` from your animation library, or a `@media (prefers-reduced-motion: reduce)` CSS query",
 	line: 0,
 	column: 0,
-	category: "Accessibility",
-	weight: 2
+	category: "Accessibility"
 };
 const checkReducedMotion = (rootDirectory) => {
 	const packageJsonPath = path.join(rootDirectory, "package.json");
@@ -279,17 +433,145 @@ const checkReducedMotion = (rootDirectory) => {
 		return [];
 	}
 	if (!hasMotionLibrary) return [];
+	const result = spawnSync("git", [
+		"grep",
+		"-ql",
+		"-E",
+		REDUCED_MOTION_GREP_PATTERN,
+		"--",
+		...REDUCED_MOTION_FILE_GLOBS
+	], {
+		cwd: rootDirectory,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	if (result.error) return [MISSING_REDUCED_MOTION_DIAGNOSTIC];
+	if (result.status === 0) return [];
+	return [MISSING_REDUCED_MOTION_DIAGNOSTIC];
+};
+//#endregion
+//#region src/utils/parse-gitattributes-linguist.ts
+const LINGUIST_ATTRIBUTE_PATTERN = /^linguist-(?:vendored|generated)(?:=([a-zA-Z0-9]+))?$/i;
+const FALSY_VALUES = new Set([
+	"false",
+	"0",
+	"off",
+	"no"
+]);
+const isTruthyLinguistAttribute = (token) => {
+	const match = LINGUIST_ATTRIBUTE_PATTERN.exec(token);
+	if (!match) return false;
+	if (match[1] === void 0) return true;
+	return !FALSY_VALUES.has(match[1].toLowerCase());
+};
+const parseGitattributesLinguistPaths = (filePath) => {
+	let content;
 	try {
-		execSync(`git grep -ql -E "${REDUCED_MOTION_GREP_PATTERN}" -- ${REDUCED_MOTION_FILE_GLOBS}`, {
-			cwd: rootDirectory,
-			stdio: "pipe"
-		});
-		return [];
+		content = fs.readFileSync(filePath, "utf-8");
 	} catch {
-		return [MISSING_REDUCED_MOTION_DIAGNOSTIC];
+		return [];
+	}
+	const paths = [];
+	for (const rawLine of content.split("\n")) {
+		const line = rawLine.trim();
+		if (line.length === 0 || line.startsWith("#")) continue;
+		const tokens = line.split(/\s+/);
+		if (tokens.length < 2) continue;
+		const [pathSpec, ...attributes] = tokens;
+		if (attributes.some(isTruthyLinguistAttribute)) paths.push(pathSpec);
+	}
+	return paths;
+};
+//#endregion
+//#region src/utils/highlighter.ts
+const highlighter = {
+	error: pc.red,
+	warn: pc.yellow,
+	info: pc.cyan,
+	success: pc.green,
+	dim: pc.dim
+};
+const logger = {
+	error(...args) {
+		console.error(highlighter.error(args.join(" ")));
+	},
+	warn(...args) {
+		console.warn(highlighter.warn(args.join(" ")));
+	},
+	info(...args) {
+		console.log(highlighter.info(args.join(" ")));
+	},
+	success(...args) {
+		console.log(highlighter.success(args.join(" ")));
+	},
+	dim(...args) {
+		console.log(highlighter.dim(args.join(" ")));
+	},
+	log(...args) {
+		console.log(args.join(" "));
+	},
+	break() {
+		console.log("");
 	}
 };
 //#endregion
+//#region src/utils/read-ignore-file.ts
+const stripGitignoreEscape = (pattern) => {
+	if (pattern.startsWith("\\#") || pattern.startsWith("\\!")) return pattern.slice(1);
+	return pattern;
+};
+const readIgnoreFile = (filePath) => {
+	let content;
+	try {
+		content = fs.readFileSync(filePath, "utf-8");
+	} catch (error) {
+		const errnoCode = error?.code;
+		if (errnoCode && errnoCode !== "ENOENT") logger.warn(`Could not read ignore file ${filePath}: ${errnoCode}`);
+		return [];
+	}
+	const patterns = [];
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) continue;
+		if (trimmed.startsWith("#")) continue;
+		patterns.push(stripGitignoreEscape(trimmed));
+	}
+	return patterns;
+};
+//#endregion
+//#region src/utils/collect-ignore-patterns.ts
+const IGNORE_FILENAMES = [
+	".eslintignore",
+	".oxlintignore",
+	".prettierignore"
+];
+const cachedPatternsByRoot = /* @__PURE__ */ new Map();
+const clearIgnorePatternsCache = () => {
+	cachedPatternsByRoot.clear();
+};
+const computeIgnorePatterns = (rootDirectory) => {
+	const seen = /* @__PURE__ */ new Set();
+	const patterns = [];
+	const addPattern = (pattern) => {
+		if (seen.has(pattern)) return;
+		seen.add(pattern);
+		patterns.push(pattern);
+	};
+	for (const filename of IGNORE_FILENAMES) for (const pattern of readIgnoreFile(path.join(rootDirectory, filename))) addPattern(pattern);
+	for (const linguistPath of parseGitattributesLinguistPaths(path.join(rootDirectory, ".gitattributes"))) addPattern(linguistPath);
+	return patterns;
+};
+const collectIgnorePatterns = (rootDirectory) => {
+	const cached = cachedPatternsByRoot.get(rootDirectory);
+	if (cached !== void 0) return cached;
+	const patterns = computeIgnorePatterns(rootDirectory);
+	cachedPatternsByRoot.set(rootDirectory, patterns);
+	return patterns;
+};
+//#endregion
 //#region src/utils/find-monorepo-root.ts
 const isMonorepoRoot = (directory) => {
 	if (isFile(path.join(directory, "pnpm-workspace.yaml"))) return true;
@@ -309,7 +591,11 @@ const findMonorepoRoot = (startDirectory) => {
 };
 //#endregion
 //#region src/utils/is-plain-object.ts
-const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isPlainObject = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype;
+};
 //#endregion
 //#region src/utils/discover-project.ts
 const REACT_COMPILER_PACKAGES = new Set([
@@ -317,6 +603,11 @@ const REACT_COMPILER_PACKAGES = new Set([
 	"react-compiler-runtime",
 	"eslint-plugin-react-compiler"
 ]);
+const TANSTACK_QUERY_PACKAGES = new Set([
+	"@tanstack/react-query",
+	"@tanstack/query-core",
+	"react-query"
+]);
 const NEXT_CONFIG_FILENAMES = [
 	"next.config.js",
 	"next.config.mjs",
@@ -335,7 +626,11 @@ const VITE_CONFIG_FILENAMES = [
 	"vite.config.js",
 	"vite.config.ts",
 	"vite.config.mjs",
-	"vite.config.cjs"
+	"vite.config.mts",
+	"vite.config.cjs",
+	"vite.config.cts",
+	"vitest.config.ts",
+	"vitest.config.js"
 ];
 const EXPO_APP_CONFIG_FILENAMES = [
 	"app.json",
@@ -343,7 +638,7 @@ const EXPO_APP_CONFIG_FILENAMES = [
 	"app.config.ts"
 ];
 const REACT_COMPILER_PACKAGE_REFERENCE_PATTERN = /babel-plugin-react-compiler|react-compiler-runtime|eslint-plugin-react-compiler|["']react-compiler["']/;
-const REACT_COMPILER_ENABLED_FLAG_PATTERN = /["']?reactCompiler["']?\s*:\s*true\b/;
+const REACT_COMPILER_ENABLED_FLAG_PATTERN = /["']?reactCompiler["']?\s*:\s*(?:true\b|\{)/;
 const FRAMEWORK_PACKAGES = {
 	next: "nextjs",
 	"@tanstack/react-start": "tanstack-start",
@@ -373,6 +668,7 @@ const countSourceFilesViaFilesystem = (rootDirectory) => {
 const countSourceFilesViaGit = (rootDirectory) => {
 	const result = spawnSync("git", [
 		"ls-files",
+		"-z",
 		"--cached",
 		"--others",
 		"--exclude-standard"
@@ -382,7 +678,7 @@ const countSourceFilesViaGit = (rootDirectory) => {
 		maxBuffer: GIT_LS_FILES_MAX_BUFFER_BYTES
 	});
 	if (result.error || result.status !== 0) return null;
-	return result.stdout.split("\n").filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath)).length;
+	return result.stdout.split("\0").filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath)).length;
 };
 const countSourceFiles = (rootDirectory) => countSourceFilesViaGit(rootDirectory) ?? countSourceFilesViaFilesystem(rootDirectory);
 const collectAllDependencies = (packageJson) => ({
@@ -480,17 +776,17 @@ const resolveCatalogVersionFromCollection = (catalogs, packageName, catalogRefer
 const resolveCatalogVersion = (packageJson, packageName, rootDirectory) => {
 	const rawVersion = collectAllDependencies(packageJson)[packageName];
 	const catalogName = rawVersion ? extractCatalogName(rawVersion) : null;
-	const raw = packageJson;
-	if (isPlainObject(raw.catalog)) {
-		const version = resolveVersionFromCatalog(raw.catalog, packageName);
+	if (isPlainObject(packageJson.catalog)) {
+		const version = resolveVersionFromCatalog(packageJson.catalog, packageName);
 		if (version) return version;
 	}
-	if (isPlainObject(raw.catalogs)) {
-		if (catalogName && isPlainObject(raw.catalogs[catalogName])) {
-			const version = resolveVersionFromCatalog(raw.catalogs[catalogName], packageName);
+	if (isPlainObject(packageJson.catalogs)) {
+		const namedCatalog = catalogName ? packageJson.catalogs[catalogName] : void 0;
+		if (namedCatalog && isPlainObject(namedCatalog)) {
+			const version = resolveVersionFromCatalog(namedCatalog, packageName);
 			if (version) return version;
 		}
-		for (const catalogEntries of Object.values(raw.catalogs)) if (isPlainObject(catalogEntries)) {
+		for (const catalogEntries of Object.values(packageJson.catalogs)) if (isPlainObject(catalogEntries)) {
 			const version = resolveVersionFromCatalog(catalogEntries, packageName);
 			if (version) return version;
 		}
@@ -531,11 +827,32 @@ const parsePnpmWorkspacePatterns = (rootDirectory) => {
 	}
 	return patterns;
 };
+const NX_PROJECT_DISCOVERY_DIRS = [
+	"apps",
+	"libs",
+	"packages"
+];
+const getNxWorkspaceDirectories = (rootDirectory) => {
+	if (!isFile(path.join(rootDirectory, "nx.json"))) return [];
+	const collected = [];
+	for (const candidate of NX_PROJECT_DISCOVERY_DIRS) {
+		const candidatePath = path.join(rootDirectory, candidate);
+		if (!fs.existsSync(candidatePath) || !fs.statSync(candidatePath).isDirectory()) continue;
+		for (const entry of fs.readdirSync(candidatePath, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			const projectDirectory = path.join(candidatePath, entry.name);
+			if (isFile(path.join(projectDirectory, "project.json")) || isFile(path.join(projectDirectory, "package.json"))) collected.push(`${candidate}/${entry.name}`);
+		}
+	}
+	return collected;
+};
 const getWorkspacePatterns = (rootDirectory, packageJson) => {
 	const pnpmPatterns = parsePnpmWorkspacePatterns(rootDirectory);
 	if (pnpmPatterns.length > 0) return pnpmPatterns;
 	if (Array.isArray(packageJson.workspaces)) return packageJson.workspaces;
 	if (packageJson.workspaces?.packages) return packageJson.workspaces.packages;
+	const nxPatterns = getNxWorkspaceDirectories(rootDirectory);
+	if (nxPatterns.length > 0) return nxPatterns;
 	return [];
 };
 const resolveWorkspaceDirectories = (rootDirectory, pattern) => {
@@ -598,23 +915,35 @@ const hasCompilerInConfigFile = (filePath) => {
 	return REACT_COMPILER_ENABLED_FLAG_PATTERN.test(content) || REACT_COMPILER_PACKAGE_REFERENCE_PATTERN.test(content);
 };
 const hasCompilerInConfigFiles = (directory, filenames) => filenames.some((filename) => hasCompilerInConfigFile(path.join(directory, filename)));
+const isProjectBoundary$1 = (directory) => {
+	if (fs.existsSync(path.join(directory, ".git"))) return true;
+	return isMonorepoRoot(directory);
+};
 const detectReactCompiler = (directory, packageJson) => {
 	if (hasCompilerPackage(packageJson)) return true;
 	if (hasCompilerInConfigFiles(directory, NEXT_CONFIG_FILENAMES)) return true;
 	if (hasCompilerInConfigFiles(directory, BABEL_CONFIG_FILENAMES)) return true;
 	if (hasCompilerInConfigFiles(directory, VITE_CONFIG_FILENAMES)) return true;
 	if (hasCompilerInConfigFiles(directory, EXPO_APP_CONFIG_FILENAMES)) return true;
+	if (isProjectBoundary$1(directory)) return false;
 	let ancestorDirectory = path.dirname(directory);
 	while (ancestorDirectory !== path.dirname(ancestorDirectory)) {
 		const ancestorPackagePath = path.join(ancestorDirectory, "package.json");
 		if (isFile(ancestorPackagePath)) {
 			if (hasCompilerPackage(readPackageJson(ancestorPackagePath))) return true;
 		}
+		if (isProjectBoundary$1(ancestorDirectory)) return false;
 		ancestorDirectory = path.dirname(ancestorDirectory);
 	}
 	return false;
 };
+const cachedProjectInfos = /* @__PURE__ */ new Map();
+const clearProjectCache = () => {
+	cachedProjectInfos.clear();
+};
 const discoverProject = (directory) => {
+	const cached = cachedProjectInfos.get(directory);
+	if (cached !== void 0) return cached;
 	const packageJsonPath = path.join(directory, "package.json");
 	if (!isFile(packageJsonPath)) throw new Error(`No package.json found in ${directory}`);
 	const packageJson = readPackageJson(packageJsonPath);
@@ -641,15 +970,56 @@ const discoverProject = (directory) => {
 	const hasTypeScript = fs.existsSync(path.join(directory, "tsconfig.json"));
 	const sourceFileCount = countSourceFiles(directory);
 	const hasReactCompiler = detectReactCompiler(directory, packageJson);
-	return {
+	const allDependencies = collectAllDependencies(packageJson);
+	const hasTanStackQuery = Object.keys(allDependencies).some((packageName) => TANSTACK_QUERY_PACKAGES.has(packageName));
+	const projectInfo = {
 		rootDirectory: directory,
 		projectName,
 		reactVersion,
 		framework,
 		hasTypeScript,
 		hasReactCompiler,
+		hasTanStackQuery,
 		sourceFileCount
 	};
+	cachedProjectInfos.set(directory, projectInfo);
+	return projectInfo;
+};
+//#endregion
+//#region src/utils/validate-config-types.ts
+const BOOLEAN_FIELD_NAMES = [
+	"lint",
+	"deadCode",
+	"verbose",
+	"customRulesOnly",
+	"share",
+	"respectInlineDisables"
+];
+const warnConfigField = (message) => {
+	process.stderr.write(`[react-doctor] ${message}\n`);
+};
+const coerceMaybeBooleanString = (fieldName, value) => {
+	if (typeof value === "boolean" || value === void 0) return value;
+	if (value === "true") {
+		warnConfigField(`config field "${fieldName}" is the string "true"; treating as boolean true.`);
+		return true;
+	}
+	if (value === "false") {
+		warnConfigField(`config field "${fieldName}" is the string "false"; treating as boolean false.`);
+		return false;
+	}
+	warnConfigField(`config field "${fieldName}" must be a boolean (got ${typeof value}); ignoring this field.`);
+};
+const validateConfigTypes = (config) => {
+	const validated = { ...config };
+	for (const fieldName of BOOLEAN_FIELD_NAMES) {
+		const original = config[fieldName];
+		if (original === void 0) continue;
+		const coerced = coerceMaybeBooleanString(fieldName, original);
+		if (coerced === void 0) delete validated[fieldName];
+		else validated[fieldName] = coerced;
+	}
+	return validated;
 };
 //#endregion
 //#region src/utils/load-config.ts
@@ -660,30 +1030,55 @@ const loadConfigFromDirectory = (directory) => {
 	if (isFile(configFilePath)) try {
 		const fileContent = fs.readFileSync(configFilePath, "utf-8");
 		const parsed = JSON.parse(fileContent);
-		if (isPlainObject(parsed)) return parsed;
-		console.warn(`Warning: ${CONFIG_FILENAME} must be a JSON object, ignoring.`);
+		if (isPlainObject(parsed)) return validateConfigTypes(parsed);
+		logger.warn(`${CONFIG_FILENAME} must be a JSON object, ignoring.`);
 	} catch (error) {
-		console.warn(`Warning: Failed to parse ${CONFIG_FILENAME}: ${error instanceof Error ? error.message : String(error)}`);
+		logger.warn(`Failed to parse ${CONFIG_FILENAME}: ${error instanceof Error ? error.message : String(error)}`);
 	}
 	const packageJsonPath = path.join(directory, "package.json");
 	if (isFile(packageJsonPath)) try {
 		const fileContent = fs.readFileSync(packageJsonPath, "utf-8");
-		const embeddedConfig = JSON.parse(fileContent)[PACKAGE_JSON_CONFIG_KEY];
-		if (isPlainObject(embeddedConfig)) return embeddedConfig;
+		const packageJson = JSON.parse(fileContent);
+		if (isPlainObject(packageJson)) {
+			const embeddedConfig = packageJson[PACKAGE_JSON_CONFIG_KEY];
+			if (isPlainObject(embeddedConfig)) return validateConfigTypes(embeddedConfig);
+		}
 	} catch {
 		return null;
 	}
 	return null;
 };
+const isProjectBoundary = (directory) => fs.existsSync(path.join(directory, ".git")) || isMonorepoRoot(directory);
+const cachedConfigs = /* @__PURE__ */ new Map();
+const clearConfigCache = () => {
+	cachedConfigs.clear();
+};
 const loadConfig = (rootDirectory) => {
+	const cached = cachedConfigs.get(rootDirectory);
+	if (cached !== void 0) return cached;
 	const localConfig = loadConfigFromDirectory(rootDirectory);
-	if (localConfig) return localConfig;
+	if (localConfig) {
+		cachedConfigs.set(rootDirectory, localConfig);
+		return localConfig;
+	}
+	if (isProjectBoundary(rootDirectory)) {
+		cachedConfigs.set(rootDirectory, null);
+		return null;
+	}
 	let ancestorDirectory = path.dirname(rootDirectory);
 	while (ancestorDirectory !== path.dirname(ancestorDirectory)) {
 		const ancestorConfig = loadConfigFromDirectory(ancestorDirectory);
-		if (ancestorConfig) return ancestorConfig;
+		if (ancestorConfig) {
+			cachedConfigs.set(rootDirectory, ancestorConfig);
+			return ancestorConfig;
+		}
+		if (isProjectBoundary(ancestorDirectory)) {
+			cachedConfigs.set(rootDirectory, null);
+			return null;
+		}
 		ancestorDirectory = path.dirname(ancestorDirectory);
 	}
+	cachedConfigs.set(rootDirectory, null);
 	return null;
 };
 //#endregion
@@ -703,16 +1098,18 @@ const createNodeReadFileLinesSync = (rootDirectory) => {
 const listSourceFilesViaGit = (rootDirectory) => {
 	const result = spawnSync("git", [
 		"ls-files",
+		"-z",
 		"--cached",
 		"--others",
-		"--exclude-standard"
+		"--exclude-standard",
+		"--recurse-submodules"
 	], {
 		cwd: rootDirectory,
 		encoding: "utf-8",
 		maxBuffer: GIT_LS_FILES_MAX_BUFFER_BYTES
 	});
 	if (result.error || result.status !== 0) return null;
-	return result.stdout.split("\n").filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath));
+	return result.stdout.split("\0").filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath));
 };
 const listSourceFilesViaFilesystem = (rootDirectory) => {
 	const filePaths = [];
@@ -785,43 +1182,51 @@ const parseScoreResult = (value) => {
 		label: labelValue
 	};
 };
+const stripFilePaths = (diagnostics) => diagnostics.map(({ filePath: _filePath, ...rest }) => rest);
+const isAbortError = (error) => error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+const describeFailure = (error) => {
+	if (isAbortError(error)) return `timed out after ${FETCH_TIMEOUT_MS / 1e3}s`;
+	if (error instanceof Error && error.message) return error.message;
+	return String(error);
+};
 const tryScoreFromApi = async (diagnostics, fetchImplementation) => {
+	if (typeof fetchImplementation !== "function") return null;
 	const controller = new AbortController();
 	const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
 	try {
 		const response = await fetchImplementation(SCORE_API_URL, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ diagnostics }),
+			body: JSON.stringify({ diagnostics: stripFilePaths(diagnostics) }),
 			signal: controller.signal
 		});
-		if (!response.ok) return null;
+		if (!response.ok) {
+			console.warn(`[react-doctor] Score API returned ${response.status} ${response.statusText} — using local scoring`);
+			return null;
+		}
 		return parseScoreResult(await response.json());
-	} catch {
+	} catch (error) {
+		console.warn(`[react-doctor] Score API unreachable (${describeFailure(error)}) — using local scoring`);
 		return null;
 	} finally {
 		clearTimeout(timeoutId);
 	}
 };
 //#endregion
+//#region src/utils/calculate-score-browser.ts
+const getGlobalFetch = () => typeof fetch === "function" ? fetch : void 0;
+const calculateScore$1 = async (diagnostics, fetchImplementation = getGlobalFetch()) => await tryScoreFromApi(diagnostics, fetchImplementation) ?? calculateScoreLocally(diagnostics);
+//#endregion
 //#region src/utils/proxy-fetch.ts
 const getGlobalProcess = () => {
 	const candidate = globalThis.process;
 	return candidate?.versions?.node ? candidate : void 0;
 };
-const readEnvProxy = () => {
+const getProxyUrl = () => {
 	const proc = getGlobalProcess();
 	if (!proc?.env) return void 0;
 	return proc.env.HTTPS_PROXY ?? proc.env.https_proxy ?? proc.env.HTTP_PROXY ?? proc.env.http_proxy;
 };
-let isProxyUrlResolved = false;
-let resolvedProxyUrl;
-const getProxyUrl = () => {
-	if (isProxyUrlResolved) return resolvedProxyUrl;
-	isProxyUrlResolved = true;
-	resolvedProxyUrl = readEnvProxy();
-	return resolvedProxyUrl;
-};
 const createProxyDispatcher = async (proxyUrl) => {
 	try {
 		const { ProxyAgent } = await import("undici");
@@ -831,27 +1236,17 @@ const createProxyDispatcher = async (proxyUrl) => {
 	}
 };
 const proxyFetch = async (url, init) => {
-	const controller = new AbortController();
-	const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-	try {
-		const proxyUrl = getProxyUrl();
-		const dispatcher = proxyUrl ? await createProxyDispatcher(proxyUrl) : null;
-		return await fetch(url, {
-			...init,
-			signal: controller.signal,
-			...dispatcher ? { dispatcher } : {}
-		});
-	} finally {
-		clearTimeout(timeoutId);
-	}
+	const proxyUrl = getProxyUrl();
+	const dispatcher = proxyUrl ? await createProxyDispatcher(proxyUrl) : null;
+	const fetchInit = {
+		...init,
+		...dispatcher ? { dispatcher } : {}
+	};
+	return fetch(url, fetchInit);
 };
 //#endregion
 //#region src/utils/calculate-score-node.ts
-const calculateScore = async (diagnostics) => {
-	const apiScore = await tryScoreFromApi(diagnostics, proxyFetch);
-	if (apiScore) return apiScore;
-	return calculateScoreLocally(diagnostics);
-};
+const calculateScore = (diagnostics) => calculateScore$1(diagnostics, proxyFetch);
 //#endregion
 //#region src/utils/collect-unused-file-paths.ts
 const collectUnusedFilePaths = (filesIssues) => {
@@ -866,27 +1261,15 @@ const collectUnusedFilePaths = (filesIssues) => {
 	return unusedFilePaths;
 };
 //#endregion
-//#region src/utils/format-error-chain.ts
-const collectErrorChain = (rootError) => {
-	const errorChain = [];
-	const visitedErrors = /* @__PURE__ */ new Set();
-	let currentError = rootError;
-	while (currentError !== void 0 && !visitedErrors.has(currentError)) {
-		visitedErrors.add(currentError);
-		errorChain.push(currentError);
-		currentError = currentError instanceof Error ? currentError.cause : void 0;
-	}
-	return errorChain;
-};
-const formatErrorMessage = (error) => error instanceof Error ? error.message || error.name : String(error);
-const getErrorChainMessages = (rootError) => collectErrorChain(rootError).map(formatErrorMessage);
-//#endregion
 //#region src/utils/extract-failed-plugin-name.ts
 const PLUGIN_CONFIG_PATTERN = /(?:^|[/\\\s])([a-z][a-z0-9-]*)\.config\./i;
+const RC_DOTFILE_PATTERN = /(?:^|[/\\])\.([a-z][a-z0-9-]*?)rc(?:\.[a-z]+)?(?:\b|$)/i;
 const extractFailedPluginName = (error) => {
 	for (const errorMessage of getErrorChainMessages(error)) {
 		const pluginNameMatch = errorMessage.match(PLUGIN_CONFIG_PATTERN);
 		if (pluginNameMatch?.[1]) return pluginNameMatch[1].toLowerCase();
+		const rcMatch = errorMessage.match(RC_DOTFILE_PATTERN);
+		if (rcMatch?.[1]) return rcMatch[1].toLowerCase();
 	}
 	return null;
 };
@@ -895,37 +1278,46 @@ const extractFailedPluginName = (error) => {
 const hasKnipConfig = (directory) => KNIP_CONFIG_LOCATIONS.some((configFilename) => isFile(path.join(directory, configFilename)));
 //#endregion
 //#region src/utils/run-knip.ts
-const KNIP_CATEGORY_MAP = {
-	files: "Dead Code",
-	exports: "Dead Code",
-	types: "Dead Code",
-	duplicates: "Dead Code"
-};
-const KNIP_MESSAGE_MAP = {
-	files: "Unused file",
-	exports: "Unused export",
-	types: "Unused type",
-	duplicates: "Duplicate export"
-};
-const KNIP_SEVERITY_MAP = {
-	files: "warning",
-	exports: "warning",
-	types: "warning",
-	duplicates: "warning"
+const KNIP_ISSUE_TYPE_DESCRIPTORS = {
+	files: {
+		category: "Dead Code",
+		message: "Unused file",
+		severity: "warning"
+	},
+	exports: {
+		category: "Dead Code",
+		message: "Unused export",
+		severity: "warning"
+	},
+	types: {
+		category: "Dead Code",
+		message: "Unused type",
+		severity: "warning"
+	},
+	duplicates: {
+		category: "Dead Code",
+		message: "Duplicate export",
+		severity: "warning"
+	}
+};
+const FALLBACK_KNIP_DESCRIPTOR = {
+	category: "Dead Code",
+	message: "Issue",
+	severity: "warning"
 };
 const collectIssueRecords = (records, issueType, rootDirectory) => {
+	const descriptor = KNIP_ISSUE_TYPE_DESCRIPTORS[issueType] ?? FALLBACK_KNIP_DESCRIPTOR;
 	const diagnostics = [];
 	for (const issues of Object.values(records)) for (const issue of Object.values(issues)) diagnostics.push({
 		filePath: path.relative(rootDirectory, issue.filePath),
 		plugin: "knip",
 		rule: issueType,
-		severity: KNIP_SEVERITY_MAP[issueType] ?? "warning",
-		message: `${KNIP_MESSAGE_MAP[issueType]}: ${issue.symbol}`,
+		severity: descriptor.severity,
+		message: `${descriptor.message}: ${issue.symbol}`,
 		help: "",
 		line: 0,
 		column: 0,
-		category: KNIP_CATEGORY_MAP[issueType] ?? "Dead Code",
-		weight: 1
+		category: descriptor.category
 	});
 	return diagnostics;
 };
@@ -934,10 +1326,11 @@ const silenced = async (fn) => {
 	const originalInfo = console.info;
 	const originalWarn = console.warn;
 	const originalError = console.error;
-	console.log = () => {};
-	console.info = () => {};
-	console.warn = () => {};
-	console.error = () => {};
+	const noop = () => {};
+	console.log = noop;
+	console.info = noop;
+	console.warn = noop;
+	console.error = noop;
 	try {
 		return await fn();
 	} finally {
@@ -947,8 +1340,8 @@ const silenced = async (fn) => {
 		console.error = originalError;
 	}
 };
-const TSCONFIG_FILENAMES = ["tsconfig.base.json", "tsconfig.json"];
-const resolveTsConfigFile = (directory) => TSCONFIG_FILENAMES.find((filename) => fs.existsSync(path.join(directory, filename)));
+const TSCONFIG_FILENAMES$1 = ["tsconfig.base.json", "tsconfig.json"];
+const resolveTsConfigFile = (directory) => TSCONFIG_FILENAMES$1.find((filename) => fs.existsSync(path.join(directory, filename)));
 const tryDisableFailedPlugin = (error, parsedConfig, disabledPlugins) => {
 	const failedPlugin = extractFailedPluginName(error);
 	if (!failedPlugin || !(failedPlugin in parsedConfig) || disabledPlugins.has(failedPlugin)) return false;
@@ -967,7 +1360,7 @@ const runKnipWithOptions = async (knipCwd, workspaceName) => {
 	const parsedConfig = options.parsedConfig;
 	const disabledPlugins = /* @__PURE__ */ new Set();
 	let lastKnipError;
-	for (let attempt = 0; attempt <= 5; attempt++) try {
+	for (let attempt = 0; attempt < 6; attempt++) try {
 		return await silenced(() => main(options));
 	} catch (error) {
 		lastKnipError = error;
@@ -996,17 +1389,17 @@ const runKnip = async (rootDirectory) => {
 	if (!(hasNodeModules(rootDirectory) || monorepoRoot !== null && hasNodeModules(monorepoRoot))) return [];
 	const { issues } = await runKnipForProject(rootDirectory, monorepoRoot);
 	const diagnostics = [];
+	const filesDescriptor = KNIP_ISSUE_TYPE_DESCRIPTORS.files;
 	for (const unusedFilePath of collectUnusedFilePaths(issues.files)) diagnostics.push({
 		filePath: path.relative(rootDirectory, unusedFilePath),
 		plugin: "knip",
 		rule: "files",
-		severity: KNIP_SEVERITY_MAP["files"],
-		message: KNIP_MESSAGE_MAP["files"],
+		severity: filesDescriptor.severity,
+		message: filesDescriptor.message,
 		help: "This file is not imported by any other file in the project.",
 		line: 0,
 		column: 0,
-		category: KNIP_CATEGORY_MAP["files"],
-		weight: 1
+		category: filesDescriptor.category
 	});
 	for (const issueType of [
 		"exports",
@@ -1016,6 +1409,29 @@ const runKnip = async (rootDirectory) => {
 	return diagnostics;
 };
 //#endregion
+//#region src/utils/batch-include-paths.ts
+const estimateArgsLength = (args) => args.reduce((total, argument) => total + argument.length + 1, 0);
+const batchIncludePaths = (baseArgs, includePaths) => {
+	const baseArgsLength = estimateArgsLength(baseArgs);
+	const batches = [];
+	let currentBatch = [];
+	let currentBatchLength = baseArgsLength;
+	for (const filePath of includePaths) {
+		const entryLength = filePath.length + 1;
+		const exceedsArgLength = currentBatch.length > 0 && currentBatchLength + entryLength > 24e3;
+		const exceedsFileCount = currentBatch.length >= 500;
+		if (exceedsArgLength || exceedsFileCount) {
+			batches.push(currentBatch);
+			currentBatch = [];
+			currentBatchLength = baseArgsLength;
+		}
+		currentBatch.push(filePath);
+		currentBatchLength += entryLength;
+	}
+	if (currentBatch.length > 0) batches.push(currentBatch);
+	return batches;
+};
+//#endregion
 //#region src/oxlint-config.ts
 const esmRequire$1 = createRequire(import.meta.url);
 const NEXTJS_RULES = {
@@ -1044,7 +1460,23 @@ const REACT_NATIVE_RULES = {
 	"react-doctor/rn-no-inline-flatlist-renderitem": "warn",
 	"react-doctor/rn-no-legacy-shadow-styles": "warn",
 	"react-doctor/rn-prefer-reanimated": "warn",
-	"react-doctor/rn-no-single-element-style-array": "warn"
+	"react-doctor/rn-no-single-element-style-array": "warn",
+	"react-doctor/rn-prefer-pressable": "warn",
+	"react-doctor/rn-prefer-expo-image": "warn",
+	"react-doctor/rn-no-non-native-navigator": "warn",
+	"react-doctor/rn-no-scroll-state": "error",
+	"react-doctor/rn-no-scrollview-mapped-list": "warn",
+	"react-doctor/rn-no-inline-object-in-list-item": "warn",
+	"react-doctor/rn-animate-layout-property": "error",
+	"react-doctor/rn-prefer-content-inset-adjustment": "warn",
+	"react-doctor/rn-pressable-shared-value-mutation": "warn",
+	"react-doctor/rn-list-data-mapped": "warn",
+	"react-doctor/rn-list-callback-per-row": "warn",
+	"react-doctor/rn-list-recyclable-without-types": "warn",
+	"react-doctor/rn-animation-reaction-as-derived": "warn",
+	"react-doctor/rn-bottom-sheet-prefer-native": "warn",
+	"react-doctor/rn-scrollview-dynamic-padding": "warn",
+	"react-doctor/rn-style-prefer-boxshadow": "warn"
 };
 const TANSTACK_START_RULES = {
 	"react-doctor/tanstack-start-route-property-order": "error",
@@ -1063,22 +1495,41 @@ const TANSTACK_START_RULES = {
 	"react-doctor/tanstack-start-loader-parallel-fetch": "warn"
 };
 const REACT_COMPILER_RULES = {
-	"react-hooks-js/set-state-in-render": "error",
-	"react-hooks-js/immutability": "error",
-	"react-hooks-js/refs": "error",
-	"react-hooks-js/purity": "error",
-	"react-hooks-js/hooks": "error",
-	"react-hooks-js/set-state-in-effect": "error",
-	"react-hooks-js/globals": "error",
-	"react-hooks-js/error-boundaries": "error",
-	"react-hooks-js/preserve-manual-memoization": "error",
-	"react-hooks-js/unsupported-syntax": "error",
-	"react-hooks-js/component-hook-factories": "error",
-	"react-hooks-js/static-components": "error",
-	"react-hooks-js/use-memo": "error",
-	"react-hooks-js/void-use-memo": "error",
-	"react-hooks-js/incompatible-library": "error",
-	"react-hooks-js/todo": "error"
+	"react-hooks-js/set-state-in-render": "warn",
+	"react-hooks-js/immutability": "warn",
+	"react-hooks-js/refs": "warn",
+	"react-hooks-js/purity": "warn",
+	"react-hooks-js/hooks": "warn",
+	"react-hooks-js/set-state-in-effect": "warn",
+	"react-hooks-js/globals": "warn",
+	"react-hooks-js/error-boundaries": "warn",
+	"react-hooks-js/preserve-manual-memoization": "warn",
+	"react-hooks-js/unsupported-syntax": "warn",
+	"react-hooks-js/component-hook-factories": "warn",
+	"react-hooks-js/static-components": "warn",
+	"react-hooks-js/use-memo": "warn",
+	"react-hooks-js/void-use-memo": "warn",
+	"react-hooks-js/incompatible-library": "warn",
+	"react-hooks-js/todo": "warn"
+};
+const resolveReactHooksJsPlugin = (hasReactCompiler, customRulesOnly) => {
+	if (!hasReactCompiler || customRulesOnly) return [];
+	try {
+		return [{
+			name: "react-hooks-js",
+			specifier: esmRequire$1.resolve("eslint-plugin-react-hooks")
+		}];
+	} catch {
+		return [];
+	}
+};
+const TANSTACK_QUERY_RULES = {
+	"react-doctor/query-stable-query-client": "warn",
+	"react-doctor/query-no-rest-destructuring": "warn",
+	"react-doctor/query-no-void-query-fn": "warn",
+	"react-doctor/query-no-query-in-effect": "warn",
+	"react-doctor/query-mutation-missing-invalidation": "warn",
+	"react-doctor/query-no-usequery-for-mutation": "warn"
 };
 const BUILTIN_REACT_RULES = {
 	"react/rules-of-hooks": "error",
@@ -1110,7 +1561,113 @@ const BUILTIN_A11Y_RULES = {
 	"jsx-a11y/no-distracting-elements": "error",
 	"jsx-a11y/iframe-has-title": "warn"
 };
-const createOxlintConfig = ({ pluginPath, framework, hasReactCompiler, customRulesOnly = false }) => ({
+const GLOBAL_REACT_DOCTOR_RULES = {
+	"react-doctor/no-derived-state-effect": "warn",
+	"react-doctor/no-fetch-in-effect": "warn",
+	"react-doctor/no-cascading-set-state": "warn",
+	"react-doctor/no-effect-event-handler": "warn",
+	"react-doctor/no-effect-event-in-deps": "error",
+	"react-doctor/no-prop-callback-in-effect": "warn",
+	"react-doctor/no-derived-useState": "warn",
+	"react-doctor/prefer-useReducer": "warn",
+	"react-doctor/rerender-lazy-state-init": "warn",
+	"react-doctor/rerender-functional-setstate": "warn",
+	"react-doctor/rerender-dependencies": "error",
+	"react-doctor/rerender-state-only-in-handlers": "warn",
+	"react-doctor/rerender-defer-reads-hook": "warn",
+	"react-doctor/advanced-event-handler-refs": "warn",
+	"react-doctor/no-giant-component": "warn",
+	"react-doctor/no-render-in-render": "warn",
+	"react-doctor/no-many-boolean-props": "warn",
+	"react-doctor/no-react19-deprecated-apis": "warn",
+	"react-doctor/no-render-prop-children": "warn",
+	"react-doctor/no-nested-component-definition": "error",
+	"react-doctor/react-compiler-destructure-method": "warn",
+	"react-doctor/no-usememo-simple-expression": "warn",
+	"react-doctor/no-layout-property-animation": "error",
+	"react-doctor/rerender-memo-with-default-value": "warn",
+	"react-doctor/rerender-memo-before-early-return": "warn",
+	"react-doctor/rerender-transitions-scroll": "warn",
+	"react-doctor/rerender-derived-state-from-hook": "warn",
+	"react-doctor/async-defer-await": "warn",
+	"react-doctor/async-await-in-loop": "warn",
+	"react-doctor/rendering-animate-svg-wrapper": "warn",
+	"react-doctor/rendering-hoist-jsx": "warn",
+	"react-doctor/rendering-hydration-mismatch-time": "warn",
+	"react-doctor/no-inline-prop-on-memo-component": "warn",
+	"react-doctor/rendering-hydration-no-flicker": "warn",
+	"react-doctor/rendering-script-defer-async": "warn",
+	"react-doctor/rendering-usetransition-loading": "warn",
+	"react-doctor/no-transition-all": "warn",
+	"react-doctor/no-global-css-variable-animation": "error",
+	"react-doctor/no-large-animated-blur": "warn",
+	"react-doctor/no-scale-from-zero": "warn",
+	"react-doctor/no-permanent-will-change": "warn",
+	"react-doctor/no-eval": "error",
+	"react-doctor/no-secrets-in-client-code": "warn",
+	"react-doctor/no-generic-handler-names": "warn",
+	"react-doctor/js-flatmap-filter": "warn",
+	"react-doctor/js-combine-iterations": "warn",
+	"react-doctor/js-tosorted-immutable": "warn",
+	"react-doctor/js-hoist-regexp": "warn",
+	"react-doctor/js-hoist-intl": "warn",
+	"react-doctor/js-cache-property-access": "warn",
+	"react-doctor/js-length-check-first": "warn",
+	"react-doctor/js-min-max-loop": "warn",
+	"react-doctor/js-set-map-lookups": "warn",
+	"react-doctor/js-batch-dom-css": "warn",
+	"react-doctor/js-index-maps": "warn",
+	"react-doctor/js-cache-storage": "warn",
+	"react-doctor/js-early-exit": "warn",
+	"react-doctor/no-barrel-import": "warn",
+	"react-doctor/no-dynamic-import-path": "warn",
+	"react-doctor/no-full-lodash-import": "warn",
+	"react-doctor/no-moment": "warn",
+	"react-doctor/prefer-dynamic-import": "warn",
+	"react-doctor/use-lazy-motion": "warn",
+	"react-doctor/no-undeferred-third-party": "warn",
+	"react-doctor/no-array-index-as-key": "warn",
+	"react-doctor/no-polymorphic-children": "warn",
+	"react-doctor/rendering-conditional-render": "warn",
+	"react-doctor/rendering-svg-precision": "warn",
+	"react-doctor/no-prevent-default": "warn",
+	"react-doctor/no-document-start-view-transition": "warn",
+	"react-doctor/no-flush-sync": "warn",
+	"react-doctor/server-auth-actions": "error",
+	"react-doctor/server-after-nonblocking": "warn",
+	"react-doctor/server-no-mutable-module-state": "error",
+	"react-doctor/server-cache-with-object-literal": "warn",
+	"react-doctor/server-hoist-static-io": "warn",
+	"react-doctor/server-dedup-props": "warn",
+	"react-doctor/server-sequential-independent-await": "warn",
+	"react-doctor/server-fetch-without-revalidate": "warn",
+	"react-doctor/client-passive-event-listeners": "warn",
+	"react-doctor/client-localstorage-no-version": "warn",
+	"react-doctor/no-inline-bounce-easing": "warn",
+	"react-doctor/no-z-index-9999": "warn",
+	"react-doctor/no-inline-exhaustive-style": "warn",
+	"react-doctor/no-side-tab-border": "warn",
+	"react-doctor/no-pure-black-background": "warn",
+	"react-doctor/no-gradient-text": "warn",
+	"react-doctor/no-dark-mode-glow": "warn",
+	"react-doctor/no-justified-text": "warn",
+	"react-doctor/no-tiny-text": "warn",
+	"react-doctor/no-wide-letter-spacing": "warn",
+	"react-doctor/no-gray-on-colored-background": "warn",
+	"react-doctor/no-layout-transition-inline": "warn",
+	"react-doctor/no-disabled-zoom": "error",
+	"react-doctor/no-outline-none": "warn",
+	"react-doctor/no-long-transition-duration": "warn",
+	"react-doctor/async-parallel": "warn"
+};
+const ALL_REACT_DOCTOR_RULE_KEYS = new Set([
+	...Object.keys(GLOBAL_REACT_DOCTOR_RULES),
+	...Object.keys(NEXTJS_RULES),
+	...Object.keys(REACT_NATIVE_RULES),
+	...Object.keys(TANSTACK_START_RULES),
+	...Object.keys(TANSTACK_QUERY_RULES)
+]);
+const createOxlintConfig = ({ pluginPath, framework, hasReactCompiler, hasTanStackQuery, customRulesOnly = false }) => ({
 	categories: {
 		correctness: "off",
 		suspicious: "off",
@@ -1120,87 +1677,23 @@ const createOxlintConfig = ({ pluginPath, framework, hasReactCompiler, customRul
 		style: "off",
 		nursery: "off"
 	},
-	plugins: [
-		"react",
-		"jsx-a11y",
-		...hasReactCompiler ? [] : ["react-perf"]
-	],
-	jsPlugins: [...hasReactCompiler && !customRulesOnly ? [{
-		name: "react-hooks-js",
-		specifier: esmRequire$1.resolve("eslint-plugin-react-hooks")
-	}] : [], pluginPath],
+	plugins: customRulesOnly ? [] : ["react", "jsx-a11y"],
+	jsPlugins: [...resolveReactHooksJsPlugin(hasReactCompiler, customRulesOnly), pluginPath],
 	rules: {
 		...customRulesOnly ? {} : BUILTIN_REACT_RULES,
 		...customRulesOnly ? {} : BUILTIN_A11Y_RULES,
 		...hasReactCompiler && !customRulesOnly ? REACT_COMPILER_RULES : {},
-		"react-doctor/no-derived-state-effect": "error",
-		"react-doctor/no-fetch-in-effect": "error",
-		"react-doctor/no-cascading-set-state": "warn",
-		"react-doctor/no-effect-event-handler": "warn",
-		"react-doctor/no-derived-useState": "warn",
-		"react-doctor/prefer-useReducer": "warn",
-		"react-doctor/rerender-lazy-state-init": "warn",
-		"react-doctor/rerender-functional-setstate": "warn",
-		"react-doctor/rerender-dependencies": "error",
-		"react-doctor/no-giant-component": "warn",
-		"react-doctor/no-render-in-render": "warn",
-		"react-doctor/no-nested-component-definition": "error",
-		"react-doctor/no-usememo-simple-expression": "warn",
-		"react-doctor/no-layout-property-animation": "error",
-		"react-doctor/rerender-memo-with-default-value": "warn",
-		"react-doctor/rendering-animate-svg-wrapper": "warn",
-		"react-doctor/no-inline-prop-on-memo-component": "warn",
-		"react-doctor/rendering-hydration-no-flicker": "warn",
-		"react-doctor/rendering-script-defer-async": "warn",
-		"react-doctor/no-transition-all": "warn",
-		"react-doctor/no-global-css-variable-animation": "error",
-		"react-doctor/no-large-animated-blur": "warn",
-		"react-doctor/no-scale-from-zero": "warn",
-		"react-doctor/no-permanent-will-change": "warn",
-		"react-doctor/no-secrets-in-client-code": "error",
-		"react-doctor/js-flatmap-filter": "warn",
-		"react-doctor/no-barrel-import": "warn",
-		"react-doctor/no-full-lodash-import": "warn",
-		"react-doctor/no-moment": "warn",
-		"react-doctor/prefer-dynamic-import": "warn",
-		"react-doctor/use-lazy-motion": "warn",
-		"react-doctor/no-undeferred-third-party": "warn",
-		"react-doctor/no-array-index-as-key": "warn",
-		"react-doctor/rendering-conditional-render": "warn",
-		"react-doctor/no-prevent-default": "warn",
-		"react-doctor/server-auth-actions": "error",
-		"react-doctor/server-after-nonblocking": "warn",
-		"react-doctor/client-passive-event-listeners": "warn",
-		"react-doctor/query-stable-query-client": "error",
-		"react-doctor/query-no-rest-destructuring": "warn",
-		"react-doctor/query-no-void-query-fn": "warn",
-		"react-doctor/query-no-query-in-effect": "warn",
-		"react-doctor/query-mutation-missing-invalidation": "warn",
-		"react-doctor/query-no-usequery-for-mutation": "warn",
-		"react-doctor/no-inline-bounce-easing": "warn",
-		"react-doctor/no-z-index-9999": "warn",
-		"react-doctor/no-inline-exhaustive-style": "warn",
-		"react-doctor/no-side-tab-border": "warn",
-		"react-doctor/no-pure-black-background": "warn",
-		"react-doctor/no-gradient-text": "warn",
-		"react-doctor/no-dark-mode-glow": "warn",
-		"react-doctor/no-justified-text": "warn",
-		"react-doctor/no-tiny-text": "warn",
-		"react-doctor/no-wide-letter-spacing": "warn",
-		"react-doctor/no-gray-on-colored-background": "warn",
-		"react-doctor/no-layout-transition-inline": "warn",
-		"react-doctor/no-disabled-zoom": "error",
-		"react-doctor/no-outline-none": "warn",
-		"react-doctor/no-long-transition-duration": "warn",
-		"react-doctor/async-parallel": "warn",
+		...GLOBAL_REACT_DOCTOR_RULES,
 		...framework === "nextjs" ? NEXTJS_RULES : {},
 		...framework === "expo" || framework === "react-native" ? REACT_NATIVE_RULES : {},
-		...framework === "tanstack-start" ? TANSTACK_START_RULES : {}
+		...framework === "tanstack-start" ? TANSTACK_START_RULES : {},
+		...hasTanStackQuery ? TANSTACK_QUERY_RULES : {}
 	}
 });
 //#endregion
 //#region src/utils/neutralize-disable-directives.ts
-const findFilesWithDisableDirectives = (rootDirectory, includePaths) => {
+const DISABLE_DIRECTIVE_PATTERN = /(eslint|oxlint)-disable/;
+const findFilesWithDisableDirectivesViaGit = (rootDirectory, includePaths) => {
 	const grepArgs = [
 		"grep",
 		"-l",
@@ -1214,14 +1707,65 @@ const findFilesWithDisableDirectives = (rootDirectory, includePaths) => {
 		encoding: "utf-8",
 		maxBuffer: GIT_LS_FILES_MAX_BUFFER_BYTES
 	});
-	if (result.error || result.status === null) return [];
-	if (result.status !== 0 && result.stdout.trim().length === 0) return [];
+	if (result.error || result.status === null) return null;
+	if (result.status === 128) return null;
 	return result.stdout.split("\n").filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath));
 };
+const findFilesWithDisableDirectivesViaFilesystem = (rootDirectory, includePaths) => {
+	const matches = [];
+	const checkFile = (relativePath) => {
+		if (!SOURCE_FILE_PATTERN.test(relativePath)) return;
+		const absolutePath = path.join(rootDirectory, relativePath);
+		let content;
+		try {
+			content = fs.readFileSync(absolutePath, "utf-8");
+		} catch {
+			return;
+		}
+		if (DISABLE_DIRECTIVE_PATTERN.test(content)) matches.push(relativePath);
+	};
+	if (includePaths && includePaths.length > 0) {
+		for (const candidate of includePaths) checkFile(candidate);
+		return matches;
+	}
+	const stack = [rootDirectory];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current === void 0) continue;
+		let entries;
+		try {
+			entries = fs.readdirSync(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				if (entry.name.startsWith(".") || IGNORED_DIRECTORIES.has(entry.name)) continue;
+				stack.push(path.join(current, entry.name));
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			const absolute = path.join(current, entry.name);
+			checkFile(path.relative(rootDirectory, absolute));
+		}
+	}
+	return matches;
+};
+const findFilesWithDisableDirectives = (rootDirectory, includePaths) => findFilesWithDisableDirectivesViaGit(rootDirectory, includePaths) ?? findFilesWithDisableDirectivesViaFilesystem(rootDirectory, includePaths);
 const neutralizeContent = (content) => content.replaceAll("eslint-disable", "eslint_disable").replaceAll("oxlint-disable", "oxlint_disable");
 const neutralizeDisableDirectives = (rootDirectory, includePaths) => {
 	const filePaths = findFilesWithDisableDirectives(rootDirectory, includePaths);
 	const originalContents = /* @__PURE__ */ new Map();
+	let isRestored = false;
+	const restore = () => {
+		if (isRestored) return;
+		isRestored = true;
+		for (const [absolutePath, originalContent] of originalContents) try {
+			fs.writeFileSync(absolutePath, originalContent);
+		} catch {}
+	};
+	const onExit = () => restore();
+	process.once("exit", onExit);
 	for (const relativePath of filePaths) {
 		const absolutePath = path.join(rootDirectory, relativePath);
 		let originalContent;
@@ -1237,7 +1781,8 @@ const neutralizeDisableDirectives = (rootDirectory, includePaths) => {
 		}
 	}
 	return () => {
-		for (const [absolutePath, originalContent] of originalContents) fs.writeFileSync(absolutePath, originalContent);
+		restore();
+		process.removeListener("exit", onExit);
 	};
 };
 //#endregion
@@ -1247,30 +1792,48 @@ const PLUGIN_CATEGORY_MAP = {
 	react: "Correctness",
 	"react-hooks": "Correctness",
 	"react-hooks-js": "React Compiler",
-	"react-perf": "Performance",
-	"jsx-a11y": "Accessibility"
+	"react-doctor": "Other",
+	"jsx-a11y": "Accessibility",
+	knip: "Dead Code"
 };
 const RULE_CATEGORY_MAP = {
 	"react-doctor/no-derived-state-effect": "State & Effects",
 	"react-doctor/no-fetch-in-effect": "State & Effects",
 	"react-doctor/no-cascading-set-state": "State & Effects",
 	"react-doctor/no-effect-event-handler": "State & Effects",
+	"react-doctor/no-effect-event-in-deps": "State & Effects",
+	"react-doctor/no-prop-callback-in-effect": "State & Effects",
 	"react-doctor/no-derived-useState": "State & Effects",
 	"react-doctor/prefer-useReducer": "State & Effects",
 	"react-doctor/rerender-lazy-state-init": "Performance",
 	"react-doctor/rerender-functional-setstate": "Performance",
 	"react-doctor/rerender-dependencies": "State & Effects",
+	"react-doctor/rerender-state-only-in-handlers": "Performance",
+	"react-doctor/rerender-defer-reads-hook": "Performance",
+	"react-doctor/advanced-event-handler-refs": "Performance",
 	"react-doctor/no-generic-handler-names": "Architecture",
 	"react-doctor/no-giant-component": "Architecture",
+	"react-doctor/no-many-boolean-props": "Architecture",
+	"react-doctor/no-react19-deprecated-apis": "Architecture",
+	"react-doctor/no-render-prop-children": "Architecture",
 	"react-doctor/no-render-in-render": "Architecture",
 	"react-doctor/no-nested-component-definition": "Correctness",
+	"react-doctor/react-compiler-destructure-method": "Architecture",
 	"react-doctor/no-usememo-simple-expression": "Performance",
 	"react-doctor/no-layout-property-animation": "Performance",
 	"react-doctor/rerender-memo-with-default-value": "Performance",
+	"react-doctor/rerender-memo-before-early-return": "Performance",
+	"react-doctor/rerender-transitions-scroll": "Performance",
+	"react-doctor/rerender-derived-state-from-hook": "Performance",
+	"react-doctor/async-defer-await": "Performance",
+	"react-doctor/async-await-in-loop": "Performance",
 	"react-doctor/rendering-animate-svg-wrapper": "Performance",
+	"react-doctor/rendering-hoist-jsx": "Performance",
+	"react-doctor/rendering-hydration-mismatch-time": "Correctness",
 	"react-doctor/rendering-usetransition-loading": "Performance",
 	"react-doctor/rendering-hydration-no-flicker": "Performance",
 	"react-doctor/rendering-script-defer-async": "Performance",
+	"react-doctor/no-inline-prop-on-memo-component": "Performance",
 	"react-doctor/no-transition-all": "Performance",
 	"react-doctor/no-global-css-variable-animation": "Performance",
 	"react-doctor/no-large-animated-blur": "Performance",
@@ -1278,14 +1841,19 @@ const RULE_CATEGORY_MAP = {
 	"react-doctor/no-permanent-will-change": "Performance",
 	"react-doctor/no-secrets-in-client-code": "Security",
 	"react-doctor/no-barrel-import": "Bundle Size",
+	"react-doctor/no-dynamic-import-path": "Bundle Size",
 	"react-doctor/no-full-lodash-import": "Bundle Size",
 	"react-doctor/no-moment": "Bundle Size",
 	"react-doctor/prefer-dynamic-import": "Bundle Size",
 	"react-doctor/use-lazy-motion": "Bundle Size",
 	"react-doctor/no-undeferred-third-party": "Bundle Size",
 	"react-doctor/no-array-index-as-key": "Correctness",
+	"react-doctor/no-polymorphic-children": "Architecture",
 	"react-doctor/rendering-conditional-render": "Correctness",
+	"react-doctor/rendering-svg-precision": "Performance",
 	"react-doctor/no-prevent-default": "Correctness",
+	"react-doctor/no-document-start-view-transition": "Correctness",
+	"react-doctor/no-flush-sync": "Performance",
 	"react-doctor/nextjs-no-img-element": "Next.js",
 	"react-doctor/nextjs-async-client-component": "Next.js",
 	"react-doctor/nextjs-no-a-element": "Next.js",
@@ -1304,7 +1872,14 @@ const RULE_CATEGORY_MAP = {
 	"react-doctor/nextjs-no-side-effect-in-get-handler": "Security",
 	"react-doctor/server-auth-actions": "Server",
 	"react-doctor/server-after-nonblocking": "Server",
+	"react-doctor/server-no-mutable-module-state": "Server",
+	"react-doctor/server-cache-with-object-literal": "Server",
+	"react-doctor/server-hoist-static-io": "Server",
+	"react-doctor/server-dedup-props": "Server",
+	"react-doctor/server-sequential-independent-await": "Server",
+	"react-doctor/server-fetch-without-revalidate": "Server",
 	"react-doctor/client-passive-event-listeners": "Performance",
+	"react-doctor/client-localstorage-no-version": "Correctness",
 	"react-doctor/query-stable-query-client": "TanStack Query",
 	"react-doctor/query-no-rest-destructuring": "TanStack Query",
 	"react-doctor/query-no-void-query-fn": "TanStack Query",
@@ -1327,6 +1902,19 @@ const RULE_CATEGORY_MAP = {
 	"react-doctor/no-outline-none": "Accessibility",
 	"react-doctor/no-long-transition-duration": "Performance",
 	"react-doctor/js-flatmap-filter": "Performance",
+	"react-doctor/js-combine-iterations": "Performance",
+	"react-doctor/js-tosorted-immutable": "Performance",
+	"react-doctor/js-hoist-regexp": "Performance",
+	"react-doctor/js-hoist-intl": "Performance",
+	"react-doctor/js-cache-property-access": "Performance",
+	"react-doctor/js-length-check-first": "Performance",
+	"react-doctor/js-min-max-loop": "Performance",
+	"react-doctor/js-set-map-lookups": "Performance",
+	"react-doctor/js-batch-dom-css": "Performance",
+	"react-doctor/js-index-maps": "Performance",
+	"react-doctor/js-cache-storage": "Performance",
+	"react-doctor/js-early-exit": "Performance",
+	"react-doctor/no-eval": "Security",
 	"react-doctor/async-parallel": "Performance",
 	"react-doctor/rn-no-raw-text": "React Native",
 	"react-doctor/rn-no-deprecated-modules": "React Native",
@@ -1336,6 +1924,22 @@ const RULE_CATEGORY_MAP = {
 	"react-doctor/rn-no-legacy-shadow-styles": "React Native",
 	"react-doctor/rn-prefer-reanimated": "React Native",
 	"react-doctor/rn-no-single-element-style-array": "React Native",
+	"react-doctor/rn-prefer-pressable": "React Native",
+	"react-doctor/rn-prefer-expo-image": "React Native",
+	"react-doctor/rn-no-non-native-navigator": "React Native",
+	"react-doctor/rn-no-scroll-state": "React Native",
+	"react-doctor/rn-no-scrollview-mapped-list": "React Native",
+	"react-doctor/rn-no-inline-object-in-list-item": "React Native",
+	"react-doctor/rn-animate-layout-property": "React Native",
+	"react-doctor/rn-prefer-content-inset-adjustment": "React Native",
+	"react-doctor/rn-pressable-shared-value-mutation": "React Native",
+	"react-doctor/rn-list-data-mapped": "React Native",
+	"react-doctor/rn-list-callback-per-row": "React Native",
+	"react-doctor/rn-list-recyclable-without-types": "React Native",
+	"react-doctor/rn-animation-reaction-as-derived": "React Native",
+	"react-doctor/rn-bottom-sheet-prefer-native": "React Native",
+	"react-doctor/rn-scrollview-dynamic-padding": "React Native",
+	"react-doctor/rn-style-prefer-boxshadow": "React Native",
 	"react-doctor/tanstack-start-route-property-order": "TanStack Start",
 	"react-doctor/tanstack-start-no-direct-fetch-in-loader": "TanStack Start",
 	"react-doctor/tanstack-start-server-fn-validate-input": "TanStack Start",
@@ -1361,17 +1965,44 @@ const RULE_HELP_MAP = {
 	"rerender-lazy-state-init": "Wrap in an arrow function so it only runs once: `useState(() => expensiveComputation())`",
 	"rerender-functional-setstate": "Use the callback form: `setState(prev => prev + 1)` to always read the latest value",
 	"rerender-dependencies": "Extract to a useMemo, useRef, or module-level constant so the reference is stable",
+	"no-effect-event-in-deps": "Call the useEffectEvent callback inside the effect body without listing it; its identity is intentionally unstable",
+	"no-prop-callback-in-effect": "Lift the shared state into a Provider so both sides read the same source — no useEffect-driven sync needed",
 	"no-generic-handler-names": "Rename to describe the action: e.g. `handleSubmit` → `saveUserProfile`, `handleClick` → `toggleSidebar`",
 	"no-giant-component": "Extract logical sections into focused components: `<UserHeader />`, `<UserActions />`, etc.",
+	"no-many-boolean-props": "Split into compound components or named variants: `<Button.Primary />`, `<DialogConfirm />` instead of stacking `isPrimary`, `isConfirm` flags",
+	"no-react19-deprecated-apis": "Pass `ref` as a regular prop on function components — `forwardRef` is no longer needed in React 19+. Replace `useContext(X)` with `use(X)` for branch-aware context reads.",
+	"no-render-prop-children": "Replace `renderXxx` props with compound subcomponents (e.g. `<Modal.Header>`) or `children` so the parent doesn't dictate every customization point",
 	"no-render-in-render": "Extract to a named component: `const ListItem = ({ item }) => <div>{item.name}</div>`",
 	"no-nested-component-definition": "Move to a separate file or to module scope above the parent component",
 	"no-usememo-simple-expression": "Remove useMemo — property access, math, and ternaries are already cheap without memoization",
 	"no-layout-property-animation": "Use `transform: translateX()` or `scale()` instead — they run on the compositor and skip layout/paint",
 	"rerender-memo-with-default-value": "Move to module scope: `const EMPTY_ITEMS: Item[] = []` then use as the default value",
 	"rendering-animate-svg-wrapper": "Wrap the SVG: `<motion.div animate={...}><svg>...</svg></motion.div>`",
+	"rendering-hoist-jsx": "Move the static JSX to module scope: `const ICON = <svg>...</svg>` outside the component so it isn't recreated each render",
+	"rerender-memo-before-early-return": "Extract the JSX into a memoized child component so the parent's early return short-circuits before the child renders",
+	"rerender-transitions-scroll": "Wrap the setState in startTransition (mark as non-urgent), use useDeferredValue, or stash in a ref + rAF throttle so scroll/pointer events don't trigger a re-render per fire",
+	"rerender-state-only-in-handlers": "Replace useState with useRef when the value is only mutated and never read in render — `ref.current = ...` updates without re-rendering the component",
+	"rerender-defer-reads-hook": "Read the URL state inside the handler (e.g. `new URL(window.location.href).searchParams`) so the component doesn't subscribe and re-render on every URL change",
+	"rerender-derived-state-from-hook": "Use a threshold/media-query hook (e.g. `useMediaQuery(\"(max-width: 767px)\")`) — the component re-renders only when the threshold flips, not every pixel",
+	"advanced-event-handler-refs": "Store the handler in a ref and have the listener read `handlerRef.current()` — the subscription stays put while the latest handler is always called",
+	"async-defer-await": "Move the `await` after the synchronous early-return guard so the skip path stays fast",
+	"async-await-in-loop": "Collect the items and use `await Promise.all(items.map(...))` to run independent operations concurrently",
+	"react-compiler-destructure-method": "Destructure the method up front: `const { push } = useRouter()` then call `push(...)` directly — clearer dependency graph and easier for React Compiler to memoize",
+	"client-localstorage-no-version": "Bake a version into the storage key (e.g. \"myKey:v1\"); a future schema change can ignore old data instead of crashing on it",
+	"server-sequential-independent-await": "Wrap independent awaits in `Promise.all([...])` so they race instead of waterfalling — second call doesn't depend on the first",
+	"server-fetch-without-revalidate": "Pass `{ next: { revalidate: <seconds> } }` (or `cache: \"no-store\"` / `next: { tags: [...] }`) so stale cached data doesn't silently persist",
+	"rn-list-callback-per-row": "Hoist the handler with useCallback at list scope and pass the row id as a primitive prop, so the row's memo() shallow-compare actually hits",
+	"rn-list-recyclable-without-types": "Add `getItemType={item => item.kind}` so FlashList keeps separate recycle pools per item type — heterogeneous rows shouldn't share recycled cells",
+	"rn-style-prefer-boxshadow": "Use the cross-platform CSS `boxShadow` string (RN v7+): `boxShadow: \"0 2px 8px rgba(0,0,0,0.1)\"` instead of platform-specific shadow*/elevation keys",
+	"rendering-hydration-mismatch-time": "Wrap dynamic time/random values in useEffect+useState (client-only) or add suppressHydrationWarning to the parent if intentional",
+	"no-polymorphic-children": "Expose explicit subcomponents (`<Button.Text>`, `<Button.Icon>`) so consumers don't need to switch on `typeof children`",
+	"rendering-svg-precision": "Truncate path/points/transform decimals to 1–2 digits — sub-pixel precision adds bytes with no visible difference",
+	"no-document-start-view-transition": "Render a <ViewTransition> component and update inside startTransition / useDeferredValue — React calls startViewTransition for you",
+	"no-flush-sync": "Use startTransition for non-urgent updates — flushSync forces a sync flush that skips View Transitions and concurrent rendering",
 	"rendering-usetransition-loading": "Replace with `const [isPending, startTransition] = useTransition()` — avoids a re-render for the loading state",
 	"rendering-hydration-no-flicker": "Use `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)` or add `suppressHydrationWarning` to the element",
 	"rendering-script-defer-async": "Add `defer` for DOM-dependent scripts or `async` for independent ones (analytics). In Next.js, use `<Script strategy=\"afterInteractive\" />` instead",
+	"no-inline-prop-on-memo-component": "Hoist the inline `() => ...` / `[]` / `{}` to a stable reference (useMemo, useCallback, or module scope) so the memoized child doesn't re-render every parent render",
 	"no-transition-all": "List specific properties: `transition: \"opacity 200ms, transform 200ms\"` — or in Tailwind use `transition-colors`, `transition-opacity`, or `transition-transform`",
 	"no-global-css-variable-animation": "Set the variable on the nearest element instead of a parent, or use `@property` with `inherits: false` to prevent cascade. Better yet, use targeted `element.style.transform` updates",
 	"no-large-animated-blur": "Keep blur radius under 10px, or apply blur to a smaller element. Large blurs multiply GPU memory usage with layer size",
@@ -1379,6 +2010,7 @@ const RULE_HELP_MAP = {
 	"no-permanent-will-change": "Add will-change on animation start (`onMouseEnter`) and remove on end (`onAnimationEnd`). Permanent promotion wastes GPU memory and can degrade performance",
 	"no-secrets-in-client-code": "Move to server-side `process.env.SECRET_NAME`. Only `NEXT_PUBLIC_*` vars are safe for the client (and should not contain secrets)",
 	"no-barrel-import": "Import from the direct path: `import { Button } from './components/Button'` instead of `./components`",
+	"no-dynamic-import-path": "Use a string-literal path: `import('./feature/heavy.js')` so the bundler can split this chunk",
 	"no-full-lodash-import": "Import the specific function: `import debounce from 'lodash/debounce'` — saves ~70kb",
 	"no-moment": "Replace with `import { format } from 'date-fns'` (tree-shakeable) or `import dayjs from 'dayjs'` (2kb)",
 	"prefer-dynamic-import": "Use `const Component = dynamic(() => import('library'), { ssr: false })` from next/dynamic or React.lazy()",
@@ -1420,7 +2052,11 @@ const RULE_HELP_MAP = {
 	"nextjs-no-side-effect-in-get-handler": "Move the side effect to a POST handler and use a <form> or fetch with method POST — GET requests can be triggered by prefetching and are vulnerable to CSRF",
 	"server-auth-actions": "Add `const session = await auth()` at the top and throw/redirect if unauthorized before any data access",
 	"server-after-nonblocking": "`import { after } from 'next/server'` then wrap: `after(() => analytics.track(...))` — response isn't blocked",
-	"client-passive-event-listeners": "Add `{ passive: true }` as the third argument: `addEventListener('scroll', handler, { passive: true })`",
+	"server-no-mutable-module-state": "Move per-request data into the action body, headers/cookies, or a request-scope (React.cache, AsyncLocalStorage). Module-scope `let`/`var` is shared across requests.",
+	"server-cache-with-object-literal": "Pass primitives to React.cache()-wrapped functions — argument identity (not deep equality) is the dedup key, so a fresh `{}` per render bypasses the cache",
+	"server-hoist-static-io": "Hoist the read to module scope: `const FONT_DATA = await fetch(new URL('./fonts/Inter.ttf', import.meta.url)).then(r => r.arrayBuffer())` runs once at module load",
+	"server-dedup-props": "Pass the source array once and derive the projection on the client — passing both doubles RSC serialization bytes",
+	"client-passive-event-listeners": "Add `{ passive: true }` as the third argument: `addEventListener('scroll', handler, { passive: true })`. Only do this if the handler does NOT call `event.preventDefault()` — passive listeners silently ignore `preventDefault()`, which breaks features like pull-to-refresh suppression, custom gestures, and nested-scroll containment.",
 	"query-stable-query-client": "Move `new QueryClient()` to module scope or wrap in `useState(() => new QueryClient())` — recreating it on every render resets the entire cache",
 	"query-no-rest-destructuring": "Destructure only the fields you need: `const { data, isLoading } = useQuery(...)` — rest destructuring subscribes to all fields and causes extra re-renders",
 	"query-no-void-query-fn": "queryFn must return a value for the cache. Use the `enabled` option to conditionally disable the query instead of returning undefined",
@@ -1428,6 +2064,19 @@ const RULE_HELP_MAP = {
 	"query-mutation-missing-invalidation": "Add `onSuccess: () => queryClient.invalidateQueries({ queryKey: ['...'] })` so cached data stays in sync after the mutation",
 	"query-no-usequery-for-mutation": "Use `useMutation()` for POST/PUT/DELETE — it provides onSuccess/onError callbacks, doesn't auto-refetch, and correctly models write operations",
 	"js-flatmap-filter": "Use `.flatMap(item => condition ? [value] : [])` — transforms and filters in a single pass instead of creating an intermediate array",
+	"js-hoist-intl": "Hoist `new Intl.NumberFormat(...)` to module scope or wrap in `useMemo` — Intl constructors allocate dozens of objects per locale lookup",
+	"js-cache-property-access": "Hoist the deep member access into a const at the top of the loop body: `const { x, y } = obj.deeply.nested`",
+	"js-length-check-first": "Short-circuit with `a.length === b.length && a.every((x, i) => x === b[i])` — unequal-length arrays exit immediately",
+	"js-combine-iterations": "Combine `.map().filter()` (or similar chains) into a single pass with `.reduce()` or a `for...of` loop to avoid iterating the array twice",
+	"js-tosorted-immutable": "Use `array.toSorted()` (ES2023) instead of `[...array].sort()` for immutable sorting without the spread allocation",
+	"js-hoist-regexp": "Hoist `new RegExp(...)` (or large regex literals) to a module-level constant so it isn't recompiled on every loop iteration",
+	"js-min-max-loop": "Use `Math.min(...array)` / `Math.max(...array)` instead of sorting just to read the first or last element",
+	"js-set-map-lookups": "Use a `Set` or `Map` for repeated membership tests / keyed lookups — `Array.includes`/`find` is O(n) per call",
+	"js-batch-dom-css": "Batch DOM/CSS reads and writes — interleaving them inside a loop causes layout thrashing. Read first, then write",
+	"js-index-maps": "Build an index `Map` once outside the loop instead of `array.find(...)` inside it",
+	"js-cache-storage": "Cache repeated `localStorage`/`sessionStorage` reads in a local variable — each access serializes/deserializes",
+	"js-early-exit": "Add an early `return` / `continue` to flatten deep nesting and short-circuit when the predicate is already known",
+	"no-eval": "Use `JSON.parse` for serialized data, `Function(...)` (still careful) for trusted templates, or refactor to avoid dynamic code execution",
 	"async-parallel": "Use `const [a, b] = await Promise.all([fetchA(), fetchB()])` to run independent operations concurrently",
 	"rn-no-raw-text": "Wrap text in a `<Text>` component: `<Text>{value}</Text>` — raw strings outside `<Text>` crash on React Native",
 	"rn-no-deprecated-modules": "Import from the community package instead — deprecated modules were removed from the react-native core",
@@ -1437,6 +2086,19 @@ const RULE_HELP_MAP = {
 	"rn-no-legacy-shadow-styles": "Use `boxShadow` for cross-platform shadows on the new architecture instead of platform-specific shadow properties",
 	"rn-prefer-reanimated": "Use `import Animated from 'react-native-reanimated'` — animations run on the UI thread instead of the JS thread",
 	"rn-no-single-element-style-array": "Use `style={value}` instead of `style={[value]}` — single-element arrays add unnecessary allocation",
+	"rn-prefer-pressable": "Use `<Pressable>` from react-native (or react-native-gesture-handler) instead of legacy Touchable* components",
+	"rn-prefer-expo-image": "Use `<Image>` from `expo-image` instead of `react-native` — same prop API, plus disk + memory caching, placeholders, and crossfades",
+	"rn-no-non-native-navigator": "Use `@react-navigation/native-stack` (or `native-tabs` in v7+) for platform-native transitions and gestures",
+	"rn-no-scroll-state": "Track scroll position with a Reanimated shared value (`useAnimatedScrollHandler`) or a ref — `setState` on every scroll event causes re-render storms",
+	"rn-no-scrollview-mapped-list": "Use FlashList, LegendList, or FlatList — `<ScrollView>{items.map(...)}</ScrollView>` mounts every row in memory",
+	"rn-no-inline-object-in-list-item": "Hoist style/object props outside renderItem (StyleSheet.create, useMemo at list scope, or pass primitives) so memo() row components stop bailing",
+	"rn-animate-layout-property": "Animate `transform: [{ translateX/Y }, { scale }]` and `opacity` instead of layout props — layout runs on the JS thread; transform/opacity run on the GPU compositor",
+	"rn-prefer-content-inset-adjustment": "Drop the SafeAreaView wrapper and set `contentInsetAdjustmentBehavior=\"automatic\"` on the ScrollView for native safe-area handling",
+	"rn-pressable-shared-value-mutation": "Wrap in <GestureDetector gesture={Gesture.Tap()...}> so the press animation runs on the UI thread instead of bouncing across the JS bridge",
+	"rn-list-data-mapped": "Wrap the projection in `useMemo(() => items.map(...), [items])` so the list's `data` prop has a stable reference across parent renders",
+	"rn-animation-reaction-as-derived": "Replace useAnimatedReaction with `useDerivedValue(() => ..., [deps])` — shorter, native dependency tracking, no side-effect implication",
+	"rn-bottom-sheet-prefer-native": "Use `<Modal presentationStyle=\"formSheet\">` (RN v7+) for native gesture handling and snap points",
+	"rn-scrollview-dynamic-padding": "Use `contentInset={{ bottom: dynamicValue }}` — the OS applies it as an offset without reflowing the scroll content",
 	"tanstack-start-route-property-order": "Follow the order: params/validateSearch → loaderDeps → context → beforeLoad → loader → head. See https://tanstack.com/router/latest/docs/eslint/create-route-property-order",
 	"tanstack-start-no-direct-fetch-in-loader": "Use `createServerFn()` from @tanstack/react-start — provides type-safe RPC, input validation, and proper server/client code splitting",
 	"tanstack-start-server-fn-validate-input": "Add `.inputValidator(schema)` before `.handler()` — data crosses a network boundary and must be validated at runtime",
@@ -1491,35 +2153,61 @@ const resolvePluginPath = () => {
 const resolveDiagnosticCategory = (plugin, rule) => {
 	return RULE_CATEGORY_MAP[`${plugin}/${rule}`] ?? PLUGIN_CATEGORY_MAP[plugin] ?? "Other";
 };
-const estimateArgsLength = (args) => args.reduce((total, argument) => total + argument.length + 1, 0);
-const batchIncludePaths = (baseArgs, includePaths) => {
-	const baseArgsLength = estimateArgsLength(baseArgs);
-	const batches = [];
-	let currentBatch = [];
-	let currentBatchLength = baseArgsLength;
-	for (const filePath of includePaths) {
-		const entryLength = filePath.length + 1;
-		const exceedsArgLength = currentBatch.length > 0 && currentBatchLength + entryLength > 24e3;
-		const exceedsFileCount = currentBatch.length >= 500;
-		if (exceedsArgLength || exceedsFileCount) {
-			batches.push(currentBatch);
-			currentBatch = [];
-			currentBatchLength = baseArgsLength;
-		}
-		currentBatch.push(filePath);
-		currentBatchLength += entryLength;
+const SANITIZED_ENV = (() => {
+	const sanitized = {};
+	for (const [name, value] of Object.entries(process.env)) {
+		if (name === "NODE_OPTIONS" || name === "NODE_DEBUG") continue;
+		if (name.startsWith("npm_config_")) continue;
+		sanitized[name] = value;
 	}
-	if (currentBatch.length > 0) batches.push(currentBatch);
-	return batches;
-};
+	return sanitized;
+})();
+const OXLINT_SPAWN_TIMEOUT_MS = 5 * 6e4;
 const spawnOxlint = (args, rootDirectory, nodeBinaryPath) => new Promise((resolve, reject) => {
-	const child = spawn(nodeBinaryPath, args, { cwd: rootDirectory });
+	const child = spawn(nodeBinaryPath, args, {
+		cwd: rootDirectory,
+		env: SANITIZED_ENV
+	});
+	const timeoutHandle = setTimeout(() => {
+		child.kill("SIGKILL");
+		reject(/* @__PURE__ */ new Error(`oxlint did not return within ${OXLINT_SPAWN_TIMEOUT_MS / 1e3}s — please report`));
+	}, OXLINT_SPAWN_TIMEOUT_MS);
+	timeoutHandle.unref?.();
 	const stdoutBuffers = [];
 	const stderrBuffers = [];
-	child.stdout.on("data", (buffer) => stdoutBuffers.push(buffer));
-	child.stderr.on("data", (buffer) => stderrBuffers.push(buffer));
-	child.on("error", (error) => reject(/* @__PURE__ */ new Error(`Failed to run oxlint: ${error.message}`)));
-	child.on("close", (code, signal) => {
+	let stdoutByteCount = 0;
+	let stderrByteCount = 0;
+	let didKillForSize = false;
+	const killIfTooLarge = (incomingBytes, isStdout) => {
+		if (isStdout) stdoutByteCount += incomingBytes;
+		else stderrByteCount += incomingBytes;
+		if (stdoutByteCount + stderrByteCount > 52428800 && !didKillForSize) {
+			didKillForSize = true;
+			child.kill("SIGKILL");
+			return true;
+		}
+		return false;
+	};
+	child.stdout.on("data", (buffer) => {
+		if (didKillForSize) return;
+		stdoutBuffers.push(buffer);
+		killIfTooLarge(buffer.length, true);
+	});
+	child.stderr.on("data", (buffer) => {
+		if (didKillForSize) return;
+		stderrBuffers.push(buffer);
+		killIfTooLarge(buffer.length, false);
+	});
+	child.on("error", (error) => {
+		clearTimeout(timeoutHandle);
+		reject(/* @__PURE__ */ new Error(`Failed to run oxlint: ${error.message}`));
+	});
+	child.on("close", (_code, signal) => {
+		clearTimeout(timeoutHandle);
+		if (didKillForSize) {
+			reject(/* @__PURE__ */ new Error(`oxlint output exceeded ${PROXY_OUTPUT_MAX_BYTES} bytes — scan a smaller subset with --diff or --staged`));
+			return;
+		}
 		if (signal) {
 			const stderrOutput = Buffer.concat(stderrBuffers).toString("utf-8").trim();
 			const hint = signal === "SIGABRT" ? " (out of memory — try scanning fewer files with --diff)" : "";
@@ -1538,15 +2226,23 @@ const spawnOxlint = (args, rootDirectory, nodeBinaryPath) => new Promise((resolv
 		resolve(output);
 	});
 });
+const isOxlintOutput = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return Array.isArray(candidate.diagnostics);
+};
 const parseOxlintOutput = (stdout) => {
 	if (!stdout) return [];
-	let output;
+	const jsonStart = stdout.indexOf("{");
+	const sanitizedStdout = jsonStart > 0 ? stdout.slice(jsonStart) : stdout;
+	let parsed;
 	try {
-		output = JSON.parse(stdout);
+		parsed = JSON.parse(sanitizedStdout);
 	} catch {
 		throw new Error(`Failed to parse oxlint output: ${stdout.slice(0, 200)}`);
 	}
-	return output.diagnostics.filter((diagnostic) => diagnostic.code && JSX_FILE_PATTERN.test(diagnostic.filename)).map((diagnostic) => {
+	if (!isOxlintOutput(parsed)) throw new Error(`Unexpected oxlint output shape: ${stdout.slice(0, 200)}`);
+	return parsed.diagnostics.filter((diagnostic) => diagnostic.code && JSX_FILE_PATTERN.test(diagnostic.filename)).map((diagnostic) => {
 		const { plugin, rule } = parseRuleCode(diagnostic.code);
 		const primaryLabel = diagnostic.labels[0];
 		const cleaned = cleanDiagnosticMessage(diagnostic.message, diagnostic.help, plugin, rule);
@@ -1563,18 +2259,48 @@ const parseOxlintOutput = (stdout) => {
 		};
 	});
 };
-const runOxlint = async (rootDirectory, hasTypeScript, framework, hasReactCompiler, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false) => {
+const TSCONFIG_FILENAMES = ["tsconfig.json", "tsconfig.base.json"];
+const resolveTsConfigRelativePath = (rootDirectory) => {
+	for (const filename of TSCONFIG_FILENAMES) if (fs.existsSync(path.join(rootDirectory, filename))) return `./${filename}`;
+	return null;
+};
+let didValidateRuleRegistration = false;
+const validateRuleRegistration = () => {
+	if (didValidateRuleRegistration) return;
+	didValidateRuleRegistration = true;
+	const missingHelp = [];
+	const missingCategory = [];
+	for (const fullKey of ALL_REACT_DOCTOR_RULE_KEYS) {
+		const ruleName = fullKey.replace(/^react-doctor\//, "");
+		if (!(fullKey in RULE_CATEGORY_MAP)) missingCategory.push(fullKey);
+		if (!(ruleName in RULE_HELP_MAP)) missingHelp.push(fullKey);
+	}
+	if (missingCategory.length > 0 || missingHelp.length > 0) {
+		const detail = [missingCategory.length > 0 ? `Missing RULE_CATEGORY_MAP entries: ${missingCategory.join(", ")}` : null, missingHelp.length > 0 ? `Missing RULE_HELP_MAP entries: ${missingHelp.join(", ")}` : null].filter((entry) => entry !== null).join("; ");
+		console.warn(`[react-doctor] rule-registration drift: ${detail}`);
+	}
+};
+const runOxlint = async (options) => {
+	const { rootDirectory, hasTypeScript, framework, hasReactCompiler, hasTanStackQuery, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true } = options;
+	validateRuleRegistration();
 	if (includePaths !== void 0 && includePaths.length === 0) return [];
-	const configPath = path.join(os.tmpdir(), `react-doctor-oxlintrc-${process.pid}.json`);
+	const configDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "react-doctor-oxlintrc-"));
+	const configPath = path.join(configDirectory, "oxlintrc.json");
 	const config = createOxlintConfig({
 		pluginPath: resolvePluginPath(),
 		framework,
 		hasReactCompiler,
+		hasTanStackQuery,
 		customRulesOnly
 	});
-	const restoreDisableDirectives = neutralizeDisableDirectives(rootDirectory, includePaths);
+	const restoreDisableDirectives = respectInlineDisables ? () => {} : neutralizeDisableDirectives(rootDirectory, includePaths);
 	try {
-		fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+		const fileHandle = fs.openSync(configPath, "wx", 384);
+		try {
+			fs.writeFileSync(fileHandle, JSON.stringify(config));
+		} finally {
+			fs.closeSync(fileHandle);
+		}
 		const baseArgs = [
 			resolveOxlintBinary(),
 			"-c",
@@ -1582,7 +2308,16 @@ const runOxlint = async (rootDirectory, hasTypeScript, framework, hasReactCompil
 			"--format",
 			"json"
 		];
-		if (hasTypeScript) baseArgs.push("--tsconfig", "./tsconfig.json");
+		if (hasTypeScript) {
+			const tsconfigRelativePath = resolveTsConfigRelativePath(rootDirectory);
+			if (tsconfigRelativePath) baseArgs.push("--tsconfig", tsconfigRelativePath);
+		}
+		const combinedPatterns = collectIgnorePatterns(rootDirectory);
+		if (combinedPatterns.length > 0) {
+			const combinedIgnorePath = path.join(configDirectory, "combined.ignore");
+			fs.writeFileSync(combinedIgnorePath, `${combinedPatterns.join("\n")}\n`);
+			baseArgs.push("--ignore-path", combinedIgnorePath);
+		}
 		const fileBatches = includePaths !== void 0 ? batchIncludePaths(baseArgs, includePaths) : [["."]];
 		const allDiagnostics = [];
 		for (const batch of fileBatches) {
@@ -1592,71 +2327,111 @@ const runOxlint = async (rootDirectory, hasTypeScript, framework, hasReactCompil
 		return allDiagnostics;
 	} finally {
 		restoreDisableDirectives();
-		if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
+		fs.rmSync(configDirectory, {
+			recursive: true,
+			force: true
+		});
 	}
 };
 //#endregion
 //#region src/utils/get-diff-files.ts
+const runGit = (cwd, args) => {
+	const result = spawnSync("git", args, {
+		cwd,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		encoding: "utf-8"
+	});
+	if (result.error || result.status !== 0) return null;
+	return result.stdout.toString().trim();
+};
 const getCurrentBranch = (directory) => {
-	try {
-		const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-			cwd: directory,
-			stdio: "pipe"
-		}).toString().trim();
-		return branch === "HEAD" ? null : branch;
-	} catch {
-		return null;
-	}
+	const branch = runGit(directory, [
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	]);
+	if (!branch) return null;
+	return branch === "HEAD" ? null : branch;
 };
 const detectDefaultBranch = (directory) => {
-	try {
-		return execSync("git symbolic-ref refs/remotes/origin/HEAD", {
-			cwd: directory,
-			stdio: "pipe"
-		}).toString().trim().replace("refs/remotes/origin/", "");
-	} catch {
-		for (const candidate of DEFAULT_BRANCH_CANDIDATES) try {
-			execSync(`git rev-parse --verify ${candidate}`, {
-				cwd: directory,
-				stdio: "pipe"
-			});
-			return candidate;
-		} catch {}
-		return null;
+	const reference = runGit(directory, ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+	if (reference) return reference.replace("refs/remotes/origin/", "");
+	const output = runGit(directory, [
+		"for-each-ref",
+		"--format=%(refname:short)",
+		...DEFAULT_BRANCH_CANDIDATES.map((candidate) => `refs/heads/${candidate}`)
+	]);
+	if (output) {
+		const firstLine = output.split("\n")[0]?.trim();
+		if (firstLine) return firstLine;
 	}
+	return null;
+};
+const branchExists = (directory, branch) => {
+	const result = spawnSync("git", [
+		"rev-parse",
+		"--verify",
+		branch
+	], {
+		cwd: directory,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	return !result.error && result.status === 0;
+};
+const runGitNullSeparated = (cwd, args) => {
+	const result = spawnSync("git", args, {
+		cwd,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		encoding: "utf-8"
+	});
+	if (result.error || result.status !== 0) return null;
+	return result.stdout.toString().split("\0").filter((filePath) => filePath.length > 0);
 };
 const getChangedFilesSinceBranch = (directory, baseBranch) => {
-	try {
-		const output = execSync(`git diff --name-only --diff-filter=ACMR --relative ${execSync(`git merge-base ${baseBranch} HEAD`, {
-			cwd: directory,
-			stdio: "pipe"
-		}).toString().trim()}`, {
-			cwd: directory,
-			stdio: "pipe"
-		}).toString().trim();
-		if (!output) return [];
-		return output.split("\n").filter(Boolean);
-	} catch {
-		return [];
-	}
+	const mergeBase = runGit(directory, [
+		"merge-base",
+		baseBranch,
+		"HEAD"
+	]);
+	if (mergeBase === null) return null;
+	return runGitNullSeparated(directory, [
+		"diff",
+		"-z",
+		"--name-only",
+		"--diff-filter=ACMR",
+		"--relative",
+		mergeBase
+	]);
 };
 const getUncommittedChangedFiles = (directory) => {
-	try {
-		const output = execSync("git diff --name-only --diff-filter=ACMR --relative HEAD", {
-			cwd: directory,
-			stdio: "pipe"
-		}).toString().trim();
-		if (!output) return [];
-		return output.split("\n").filter(Boolean);
-	} catch {
-		return [];
-	}
+	return runGitNullSeparated(directory, [
+		"diff",
+		"-z",
+		"--name-only",
+		"--diff-filter=ACMR",
+		"--relative",
+		"HEAD"
+	]) ?? [];
 };
 const getDiffInfo = (directory, explicitBaseBranch) => {
+	if (explicitBaseBranch !== void 0 && explicitBaseBranch.trim().length === 0) throw new Error("Diff base branch cannot be empty.");
 	const currentBranch = getCurrentBranch(directory);
 	if (!currentBranch) return null;
 	const baseBranch = explicitBaseBranch ?? detectDefaultBranch(directory);
 	if (!baseBranch) return null;
+	if (explicitBaseBranch && !branchExists(directory, explicitBaseBranch)) throw new Error(`Diff base branch "${explicitBaseBranch}" does not exist (run \`git fetch\` to update remote refs).`);
 	if (currentBranch === baseBranch) {
 		const uncommittedFiles = getUncommittedChangedFiles(directory);
 		if (uncommittedFiles.length === 0) return null;
@@ -1667,15 +2442,40 @@ const getDiffInfo = (directory, explicitBaseBranch) => {
 			isCurrentChanges: true
 		};
 	}
+	const changedFiles = getChangedFilesSinceBranch(directory, baseBranch);
+	if (changedFiles === null) return null;
 	return {
 		currentBranch,
 		baseBranch,
-		changedFiles: getChangedFilesSinceBranch(directory, baseBranch)
+		changedFiles
 	};
 };
 const filterSourceFiles = (filePaths) => filePaths.filter((filePath) => SOURCE_FILE_PATTERN.test(filePath));
 //#endregion
 //#region src/index.ts
+const clearCaches = () => {
+	clearProjectCache();
+	clearConfigCache();
+	clearPackageJsonCache();
+	clearIgnorePatternsCache();
+};
+const toJsonReport = (result, options) => buildJsonReport({
+	version: options.version,
+	directory: options.directory ?? result.project.rootDirectory,
+	mode: options.mode ?? "full",
+	diff: null,
+	scans: [{
+		directory: result.project.rootDirectory,
+		result: {
+			diagnostics: result.diagnostics,
+			score: result.score,
+			skippedChecks: [],
+			project: result.project,
+			elapsedMilliseconds: result.elapsedMilliseconds
+		}
+	}],
+	totalElapsedMilliseconds: result.elapsedMilliseconds
+});
 const diagnose = async (directory, options = {}) => {
 	const resolvedDirectory = path.resolve(directory);
 	const userConfig = loadConfig(resolvedDirectory);
@@ -1690,7 +2490,16 @@ const diagnose = async (directory, options = {}) => {
 		calculateDiagnosticsScore: calculateScore,
 		getExtraDiagnostics: () => isDiffMode ? [] : checkReducedMotion(resolvedDirectory),
 		createRunners: ({ resolvedDirectory: projectRoot, projectInfo, userConfig: config }) => ({
-			runLint: () => runOxlint(projectRoot, projectInfo.hasTypeScript, projectInfo.framework, projectInfo.hasReactCompiler, lintIncludePaths, void 0, config?.customRulesOnly ?? false),
+			runLint: () => runOxlint({
+				rootDirectory: projectRoot,
+				hasTypeScript: projectInfo.hasTypeScript,
+				framework: projectInfo.framework,
+				hasReactCompiler: projectInfo.hasReactCompiler,
+				hasTanStackQuery: projectInfo.hasTanStackQuery,
+				includePaths: lintIncludePaths,
+				customRulesOnly: config?.customRulesOnly ?? false,
+				respectInlineDisables: options.respectInlineDisables ?? config?.respectInlineDisables ?? true
+			}),
 			runDeadCode: () => runKnip(projectRoot)
 		})
 	}, {
@@ -1699,6 +2508,6 @@ const diagnose = async (directory, options = {}) => {
 	});
 };
 //#endregion
-export { diagnose, filterSourceFiles, getDiffInfo };
+export { buildJsonReport, buildJsonReportError, clearCaches, diagnose, filterSourceFiles, getDiffInfo, summarizeDiagnostics, toJsonReport };
 
 //# sourceMappingURL=index.js.map