react-doctor 0.0.47 → 0.1.0

package/dist/index.js

@@ -26,6 +26,7 @@ const KNIP_CONFIG_LOCATIONS = [
 	"knip.config.ts",
 	"knip.config.js"
 ];
+const ADOPTABLE_LINT_CONFIG_FILENAMES = [".oxlintrc.json", ".eslintrc.json"];
 const IGNORED_DIRECTORIES = new Set([
 	"node_modules",
 	"dist",
@@ -35,197 +36,6 @@ const IGNORED_DIRECTORIES = new Set([
 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;
-const compileGlobPattern = (pattern) => {
-	const normalizedPattern = pattern.replace(/\\/g, "/").replace(/^\//, "");
-	let regexSource = "^";
-	let characterIndex = 0;
-	while (characterIndex < normalizedPattern.length) if (normalizedPattern[characterIndex] === "*" && normalizedPattern[characterIndex + 1] === "*") if (normalizedPattern[characterIndex + 2] === "/") {
-		regexSource += "(?:.+/)?";
-		characterIndex += 3;
-	} else {
-		regexSource += ".*";
-		characterIndex += 2;
-	}
-	else if (normalizedPattern[characterIndex] === "*") {
-		regexSource += "[^/]*";
-		characterIndex++;
-	} else if (normalizedPattern[characterIndex] === "?") {
-		regexSource += "[^/]";
-		characterIndex++;
-	} else {
-		regexSource += normalizedPattern[characterIndex].replace(REGEX_SPECIAL_CHARACTERS, "\\$&");
-		characterIndex++;
-	}
-	regexSource += "$";
-	return new RegExp(regexSource);
-};
-//#endregion
-//#region src/utils/is-ignored-file.ts
-const toRelativePath = (filePath, rootDirectory) => {
-	const normalizedFilePath = filePath.replace(/\\/g, "/");
-	const normalizedRoot = rootDirectory.replace(/\\/g, "/").replace(/\/$/, "") + "/";
-	if (normalizedFilePath.startsWith(normalizedRoot)) return normalizedFilePath.slice(normalizedRoot.length);
-	return normalizedFilePath.replace(/^\.\//, "");
-};
-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);
-	return patterns.some((pattern) => pattern.test(relativePath));
-};
-//#endregion
-//#region src/utils/filter-diagnostics.ts
-const resolveCandidateReadPath = (rootDirectory, filePath) => {
-	const normalizedFile = filePath.replace(/\\/g, "/");
-	if (normalizedFile.startsWith("/") || /^[a-zA-Z]:\//.test(normalizedFile) || /^[a-zA-Z]:\\/.test(filePath)) return filePath;
-	return `${rootDirectory.replace(/\\/g, "/").replace(/\/$/, "")}/${normalizedFile.replace(/^\.\//, "")}`;
-};
-const OPENING_TAG_PATTERN = /<([A-Z][\w.]*)/;
-const DISABLE_NEXT_LINE_PATTERN = /\/\/\s*react-doctor-disable-next-line\b(?:\s+(.+))?/;
-const DISABLE_LINE_PATTERN = /\/\/\s*react-doctor-disable-line\b(?:\s+(.+))?/;
-const createFileLinesCache = (rootDirectory, readFileLinesSync) => {
-	const cache = /* @__PURE__ */ new Map();
-	return (filePath) => {
-		const cached = cache.get(filePath);
-		if (cached !== void 0) return cached;
-		const lines = readFileLinesSync(resolveCandidateReadPath(rootDirectory, filePath));
-		cache.set(filePath, lines);
-		return lines;
-	};
-};
-const isInsideTextComponent = (lines, diagnosticLine, textComponentNames) => {
-	for (let lineIndex = diagnosticLine - 1; lineIndex >= 0; lineIndex--) {
-		const match = lines[lineIndex].match(OPENING_TAG_PATTERN);
-		if (!match) continue;
-		const fullTagName = match[1];
-		const leafTagName = fullTagName.includes(".") ? fullTagName.split(".").at(-1) ?? fullTagName : fullTagName;
-		return textComponentNames.has(fullTagName) || textComponentNames.has(leafTagName);
-	}
-	return false;
-};
-const isRuleSuppressed = (commentRules, ruleId) => {
-	if (!commentRules?.trim()) return true;
-	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.filter((rule) => typeof rule === "string") : []);
-	const ignoredFilePatterns = compileIgnoredFilePatterns(config);
-	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) => {
-		const ruleIdentifier = `${diagnostic.plugin}/${diagnostic.rule}`;
-		if (ignoredRules.has(ruleIdentifier)) return false;
-		if (isFileIgnoredByPatterns(diagnostic.filePath, rootDirectory, ignoredFilePatterns)) return false;
-		if (hasTextComponents && diagnostic.rule === "rn-no-raw-text" && diagnostic.line > 0) {
-			const lines = getFileLines(diagnostic.filePath);
-			if (lines && isInsideTextComponent(lines, diagnostic.line, textComponentNames)) return false;
-		}
-		return true;
-	});
-};
-const filterInlineSuppressions = (diagnostics, rootDirectory, readFileLinesSync) => {
-	const getFileLines = createFileLinesCache(rootDirectory, readFileLinesSync);
-	return diagnostics.filter((diagnostic) => {
-		if (diagnostic.line <= 0) return true;
-		const lines = getFileLines(diagnostic.filePath);
-		if (!lines) return true;
-		const ruleId = `${diagnostic.plugin}/${diagnostic.rule}`;
-		const currentLine = lines[diagnostic.line - 1];
-		if (currentLine) {
-			const lineMatch = currentLine.match(DISABLE_LINE_PATTERN);
-			if (lineMatch && isRuleSuppressed(lineMatch[1], ruleId)) return false;
-		}
-		if (diagnostic.line >= 2) {
-			const previousLine = lines[diagnostic.line - 2];
-			if (previousLine) {
-				const nextLineMatch = previousLine.match(DISABLE_NEXT_LINE_PATTERN);
-				if (nextLineMatch && isRuleSuppressed(nextLineMatch[1], ruleId)) return false;
-			}
-		}
-		return true;
-	});
-};
-//#endregion
-//#region src/utils/merge-and-filter-diagnostics.ts
-const mergeAndFilterDiagnostics = (mergedDiagnostics, directory, userConfig, readFileLinesSync) => {
-	return filterInlineSuppressions(userConfig ? filterIgnoredDiagnostics(mergedDiagnostics, userConfig, directory, readFileLinesSync) : mergedDiagnostics, directory, readFileLinesSync);
-};
-//#endregion
-//#region src/core/build-result.ts
-const buildDiagnoseTimedResult = async (input) => {
-	const diagnostics = mergeAndFilterDiagnostics(input.mergedDiagnostics, input.rootDirectory, input.userConfig, input.readFileLinesSync);
-	const elapsedMilliseconds = globalThis.performance.now() - input.startTime;
-	return {
-		diagnostics,
-		score: input.score !== void 0 ? input.score : await input.calculateDiagnosticsScore(diagnostics),
-		elapsedMilliseconds
-	};
-};
-//#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
-//#region src/core/diagnose-core.ts
-const diagnoseCore = async (deps, options = {}) => {
-	const { includePaths = [] } = options;
-	const isDiffMode = includePaths.length > 0;
-	const startTime = globalThis.performance.now();
-	const resolvedDirectory = deps.rootDirectory;
-	const projectInfo = deps.discoverProjectInfo();
-	const userConfig = deps.loadUserConfig();
-	const effectiveLint = options.lint ?? userConfig?.lint ?? true;
-	const effectiveDeadCode = options.deadCode ?? userConfig?.deadCode ?? true;
-	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,
-		projectInfo,
-		userConfig,
-		lintIncludePaths,
-		isDiffMode
-	});
-	const emptyDiagnostics = [];
-	const lintPromise = effectiveLint ? runLint().catch((error) => {
-		console.error("Lint failed:", error);
-		return emptyDiagnostics;
-	}) : Promise.resolve(emptyDiagnostics);
-	const deadCodePromise = effectiveDeadCode && !isDiffMode ? runDeadCode().catch((error) => {
-		console.error("Dead code analysis failed:", error);
-		return emptyDiagnostics;
-	}) : Promise.resolve(emptyDiagnostics);
-	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: [
-			...lintDiagnostics,
-			...deadCodeDiagnostics,
-			...environmentDiagnostics
-		],
-		rootDirectory: resolvedDirectory,
-		userConfig,
-		readFileLinesSync: deps.readFileLinesSync,
-		startTime,
-		calculateDiagnosticsScore: deps.calculateDiagnosticsScore
-	});
-	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;
@@ -359,7 +169,192 @@ const buildJsonReportError = (input) => {
 	};
 };
 //#endregion
+//#region src/utils/calculate-score-locally.ts
+const getScoreLabel = (score) => {
+	if (score >= 75) return "Great";
+	if (score >= 50) return "Needs work";
+	return "Critical";
+};
+const countUniqueRules = (diagnostics) => {
+	const errorRules = /* @__PURE__ */ new Set();
+	const warningRules = /* @__PURE__ */ new Set();
+	for (const diagnostic of diagnostics) {
+		const ruleKey = `${diagnostic.plugin}/${diagnostic.rule}`;
+		if (diagnostic.severity === "error") errorRules.add(ruleKey);
+		else warningRules.add(ruleKey);
+	}
+	return {
+		errorRuleCount: errorRules.size,
+		warningRuleCount: warningRules.size
+	};
+};
+const scoreFromRuleCounts = (errorRuleCount, warningRuleCount) => {
+	const penalty = errorRuleCount * ERROR_RULE_PENALTY + warningRuleCount * WARNING_RULE_PENALTY;
+	return Math.max(0, Math.round(100 - penalty));
+};
+const calculateScoreLocally = (diagnostics) => {
+	const { errorRuleCount, warningRuleCount } = countUniqueRules(diagnostics);
+	const score = scoreFromRuleCounts(errorRuleCount, warningRuleCount);
+	return {
+		score,
+		label: getScoreLabel(score)
+	};
+};
+//#endregion
+//#region src/utils/try-score-from-api.ts
+const parseScoreResult = (value) => {
+	if (typeof value !== "object" || value === null) return null;
+	if (!("score" in value) || !("label" in value)) return null;
+	const scoreValue = Reflect.get(value, "score");
+	const labelValue = Reflect.get(value, "label");
+	if (typeof scoreValue !== "number" || typeof labelValue !== "string") return null;
+	return {
+		score: scoreValue,
+		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: stripFilePaths(diagnostics) }),
+			signal: controller.signal
+		});
+		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 (error) {
+		console.warn(`[react-doctor] Score API unreachable (${describeFailure(error)}) — using local scoring`);
+		return null;
+	} finally {
+		clearTimeout(timeoutId);
+	}
+};
+//#endregion
+//#region src/utils/proxy-fetch.ts
+const getGlobalProcess = () => {
+	const candidate = globalThis.process;
+	return candidate?.versions?.node ? candidate : void 0;
+};
+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;
+};
+const createProxyDispatcher = async (proxyUrl) => {
+	try {
+		const { ProxyAgent } = await import("undici");
+		return new ProxyAgent(proxyUrl);
+	} catch {
+		return null;
+	}
+};
+const proxyFetch = async (url, init) => {
+	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.ts
+const calculateScore = async (diagnostics) => await tryScoreFromApi(diagnostics, proxyFetch) ?? calculateScoreLocally(diagnostics);
+//#endregion
 //#region src/plugin/constants.ts
+const FETCH_CALLEE_NAMES = new Set([
+	"fetch",
+	"ky",
+	"got",
+	"wretch",
+	"ofetch"
+]);
+const FETCH_MEMBER_OBJECTS = new Set([
+	"axios",
+	"ky",
+	"got",
+	"ofetch",
+	"wretch",
+	"request"
+]);
+const TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES = new Set([
+	"setTimeout",
+	"setInterval",
+	"requestAnimationFrame",
+	"requestIdleCallback",
+	"queueMicrotask"
+]);
+const SUBSCRIPTION_METHOD_NAMES = new Set([
+	"subscribe",
+	"addEventListener",
+	"addListener",
+	"on",
+	"watch",
+	"listen",
+	"sub"
+]);
+new Set([
+	...new Set([
+		"unsubscribe",
+		"removeEventListener",
+		"removeListener",
+		"off",
+		"unwatch",
+		"unlisten",
+		"unsub"
+	]),
+	"cleanup",
+	"dispose",
+	"destroy",
+	"teardown"
+]);
+new Set([
+	...SUBSCRIPTION_METHOD_NAMES,
+	"connect",
+	"disconnect",
+	"open",
+	"close",
+	"fetch",
+	"post",
+	"put",
+	"patch"
+]);
+new Set([
+	...FETCH_MEMBER_OBJECTS,
+	"api",
+	"client",
+	"http",
+	"fetcher"
+]);
+new Set([...FETCH_CALLEE_NAMES, ...TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES]);
+new Set([
+	...FETCH_CALLEE_NAMES,
+	"post",
+	"put",
+	"patch",
+	"navigate",
+	"navigateTo",
+	"showNotification",
+	"toast",
+	"alert",
+	"confirm",
+	"logVisit",
+	"captureEvent"
+]);
 const MOTION_LIBRARY_PACKAGES = new Set(["framer-motion", "motion"]);
 //#endregion
 //#region src/utils/is-file.ts
@@ -915,7 +910,7 @@ 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) => {
+const isProjectBoundary$2 = (directory) => {
 	if (fs.existsSync(path.join(directory, ".git"))) return true;
 	return isMonorepoRoot(directory);
 };
@@ -925,14 +920,14 @@ const detectReactCompiler = (directory, packageJson) => {
 	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;
+	if (isProjectBoundary$2(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;
+		if (isProjectBoundary$2(ancestorDirectory)) return false;
 		ancestorDirectory = path.dirname(ancestorDirectory);
 	}
 	return false;
@@ -986,6 +981,9 @@ const discoverProject = (directory) => {
 	return projectInfo;
 };
 //#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
 //#region src/utils/validate-config-types.ts
 const BOOLEAN_FIELD_NAMES = [
 	"lint",
@@ -993,22 +991,23 @@ const BOOLEAN_FIELD_NAMES = [
 	"verbose",
 	"customRulesOnly",
 	"share",
-	"respectInlineDisables"
+	"respectInlineDisables",
+	"adoptExistingLintConfig"
 ];
-const warnConfigField = (message) => {
+const warnConfigField$1 = (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.`);
+		warnConfigField$1(`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.`);
+		warnConfigField$1(`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.`);
+	warnConfigField$1(`config field "${fieldName}" must be a boolean (got ${typeof value}); ignoring this field.`);
 };
 const validateConfigTypes = (config) => {
 	const validated = { ...config };
@@ -1048,38 +1047,383 @@ const loadConfigFromDirectory = (directory) => {
 	}
 	return null;
 };
-const isProjectBoundary = (directory) => fs.existsSync(path.join(directory, ".git")) || isMonorepoRoot(directory);
-const cachedConfigs = /* @__PURE__ */ new Map();
-const clearConfigCache = () => {
-	cachedConfigs.clear();
+const isProjectBoundary$1 = (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) {
+		cachedConfigs.set(rootDirectory, localConfig);
+		return localConfig;
+	}
+	if (isProjectBoundary$1(rootDirectory)) {
+		cachedConfigs.set(rootDirectory, null);
+		return null;
+	}
+	let ancestorDirectory = path.dirname(rootDirectory);
+	while (ancestorDirectory !== path.dirname(ancestorDirectory)) {
+		const ancestorConfig = loadConfigFromDirectory(ancestorDirectory);
+		if (ancestorConfig) {
+			cachedConfigs.set(rootDirectory, ancestorConfig);
+			return ancestorConfig;
+		}
+		if (isProjectBoundary$1(ancestorDirectory)) {
+			cachedConfigs.set(rootDirectory, null);
+			return null;
+		}
+		ancestorDirectory = path.dirname(ancestorDirectory);
+	}
+	cachedConfigs.set(rootDirectory, null);
+	return null;
+};
+//#endregion
+//#region src/utils/match-glob-pattern.ts
+const REGEX_SPECIAL_CHARACTERS = /[.+^${}()|[\]\\]/g;
+const compileGlobPattern = (pattern) => {
+	const normalizedPattern = pattern.replace(/\\/g, "/").replace(/^\//, "");
+	let regexSource = "^";
+	let characterIndex = 0;
+	while (characterIndex < normalizedPattern.length) if (normalizedPattern[characterIndex] === "*" && normalizedPattern[characterIndex + 1] === "*") if (normalizedPattern[characterIndex + 2] === "/") {
+		regexSource += "(?:.+/)?";
+		characterIndex += 3;
+	} else {
+		regexSource += ".*";
+		characterIndex += 2;
+	}
+	else if (normalizedPattern[characterIndex] === "*") {
+		regexSource += "[^/]*";
+		characterIndex++;
+	} else if (normalizedPattern[characterIndex] === "?") {
+		regexSource += "[^/]";
+		characterIndex++;
+	} else {
+		regexSource += normalizedPattern[characterIndex].replace(REGEX_SPECIAL_CHARACTERS, "\\$&");
+		characterIndex++;
+	}
+	regexSource += "$";
+	return new RegExp(regexSource);
+};
+//#endregion
+//#region src/utils/to-relative-path.ts
+const toRelativePath = (filePath, rootDirectory) => {
+	const normalizedFilePath = filePath.replace(/\\/g, "/");
+	const normalizedRoot = rootDirectory.replace(/\\/g, "/").replace(/\/$/, "") + "/";
+	if (normalizedFilePath.startsWith(normalizedRoot)) return normalizedFilePath.slice(normalizedRoot.length);
+	return normalizedFilePath.replace(/^\.\//, "");
+};
+//#endregion
+//#region src/utils/apply-ignore-overrides.ts
+const warnConfigField = (message) => {
+	process.stderr.write(`[react-doctor] ${message}\n`);
+};
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+const collectStringList = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+const validateOverrideEntry = (entry, index) => {
+	if (!isPlainObject(entry)) {
+		warnConfigField(`ignore.overrides[${index}] must be an object with { files, rules }; ignoring this entry.`);
+		return null;
+	}
+	if (!isStringArray(entry.files)) {
+		warnConfigField(`ignore.overrides[${index}].files must be an array of strings; ignoring this entry.`);
+		return null;
+	}
+	if (entry.rules !== void 0 && !isStringArray(entry.rules)) {
+		warnConfigField(`ignore.overrides[${index}].rules must be an array of "plugin/rule" strings or omitted; treating as missing (override would suppress every rule for the matched files).`);
+		return { files: entry.files };
+	}
+	return entry.rules === void 0 ? { files: entry.files } : {
+		files: entry.files,
+		rules: entry.rules
+	};
+};
+const compileIgnoreOverrides = (userConfig) => {
+	const overrides = userConfig?.ignore?.overrides;
+	if (overrides === void 0) return [];
+	if (!Array.isArray(overrides)) {
+		warnConfigField(`ignore.overrides must be an array of { files, rules } entries; ignoring.`);
+		return [];
+	}
+	return overrides.flatMap((entry, index) => {
+		const validated = validateOverrideEntry(entry, index);
+		if (!validated) return [];
+		const filePatterns = collectStringList(validated.files).map(compileGlobPattern);
+		if (filePatterns.length === 0) return [];
+		return [{
+			filePatterns,
+			ruleIds: new Set(collectStringList(validated.rules))
+		}];
+	});
+};
+const isDiagnosticIgnoredByOverrides = (diagnostic, rootDirectory, overrides) => {
+	if (overrides.length === 0) return false;
+	const relativeFilePath = toRelativePath(diagnostic.filePath, rootDirectory);
+	const ruleIdentifier = `${diagnostic.plugin}/${diagnostic.rule}`;
+	return overrides.some((override) => override.filePatterns.some((pattern) => pattern.test(relativeFilePath)) && (override.ruleIds.size === 0 || override.ruleIds.has(ruleIdentifier)));
+};
+//#endregion
+//#region src/utils/find-jsx-opener-span.ts
+const JSX_OPENER_TAG_PATTERN = /<[A-Za-z][\w.]*/g;
+const JSX_TAG_NAME_FOLLOW = /[A-Za-z]/;
+const isOpenerMatchInsideLineComment = (line, openerCharIndex) => {
+	let stringDelimiter = null;
+	for (let charIndex = 0; charIndex < openerCharIndex; charIndex++) {
+		const character = line[charIndex];
+		if (stringDelimiter !== null) {
+			if (character === "\\") {
+				charIndex++;
+				continue;
+			}
+			if (character === stringDelimiter) stringDelimiter = null;
+			continue;
+		}
+		if (character === "\"" || character === "'" || character === "`") {
+			stringDelimiter = character;
+			continue;
+		}
+		if (character === "/" && line[charIndex + 1] === "/") return true;
+	}
+	return false;
+};
+const findOpenerTagOnLine = (line) => {
+	for (const match of line.matchAll(JSX_OPENER_TAG_PATTERN)) {
+		if (match.index === void 0) continue;
+		if (!isOpenerMatchInsideLineComment(line, match.index)) return { startCharIndex: match.index + match[0].length };
+	}
+	return null;
+};
+const findJsxOpenerSpan = (lines, openerLineIndex) => {
+	const openerLine = lines[openerLineIndex];
+	if (openerLine === void 0) return null;
+	const opener = findOpenerTagOnLine(openerLine);
+	if (!opener) return null;
+	const lookaheadLimit = Math.min(lines.length, openerLineIndex + 32);
+	let braceDepth = 0;
+	let innerAngleDepth = 0;
+	let stringDelimiter = null;
+	for (let lineIndex = openerLineIndex; lineIndex < lookaheadLimit; lineIndex++) {
+		const currentLine = lines[lineIndex];
+		const startCharForLine = lineIndex === openerLineIndex ? opener.startCharIndex : 0;
+		for (let charIndex = startCharForLine; charIndex < currentLine.length; charIndex++) {
+			const character = currentLine[charIndex];
+			if (stringDelimiter !== null) {
+				if (character === "\\") {
+					charIndex++;
+					continue;
+				}
+				if (character === stringDelimiter) stringDelimiter = null;
+				continue;
+			}
+			if (character === "\"" || character === "'" || character === "`") {
+				stringDelimiter = character;
+				continue;
+			}
+			if (character === "{") {
+				braceDepth++;
+				continue;
+			}
+			if (character === "}") {
+				braceDepth--;
+				continue;
+			}
+			if (braceDepth !== 0) continue;
+			if (character === "<") {
+				const followCharacter = currentLine[charIndex + 1];
+				if (followCharacter !== void 0 && JSX_TAG_NAME_FOLLOW.test(followCharacter)) innerAngleDepth++;
+				continue;
+			}
+			if (character !== ">") continue;
+			const previousCharacter = currentLine[charIndex - 1];
+			const nextCharacter = currentLine[charIndex + 1];
+			if (previousCharacter === "=" || nextCharacter === "=") continue;
+			if (innerAngleDepth > 0) {
+				innerAngleDepth--;
+				continue;
+			}
+			return lineIndex;
+		}
+	}
+	return null;
+};
+//#endregion
+//#region src/utils/find-enclosing-jsx-opener.ts
+const findEnclosingMultilineJsxOpenerStart = (lines, diagnosticLineIndex) => {
+	for (let candidateIndex = diagnosticLineIndex - 1; candidateIndex >= 0 && diagnosticLineIndex - candidateIndex <= 32; candidateIndex--) {
+		const openerCloseIndex = findJsxOpenerSpan(lines, candidateIndex);
+		if (openerCloseIndex !== null && openerCloseIndex >= diagnosticLineIndex) return candidateIndex;
+	}
+	return null;
+};
+//#endregion
+//#region src/utils/find-stacked-disable-comments.ts
+const DISABLE_NEXT_LINE_PATTERN = /(?:\/\/|\/\*)\s*react-doctor-disable-next-line\b(?:\s+([\w/\-.,\s]+?))?\s*(?:\*\/)?\s*\}?\s*$/;
+const findStackedDisableCommentsAbove = (lines, anchorIndex) => {
+	const collected = [];
+	let isStillInChain = true;
+	for (let candidateIndex = anchorIndex - 1; candidateIndex >= 0 && anchorIndex - candidateIndex <= 10; candidateIndex--) {
+		const candidateLine = lines[candidateIndex];
+		if (candidateLine === void 0) break;
+		const match = candidateLine.match(DISABLE_NEXT_LINE_PATTERN);
+		if (match) {
+			collected.push({
+				commentLineIndex: candidateIndex,
+				ruleList: match[1],
+				isInChain: isStillInChain
+			});
+			continue;
+		}
+		isStillInChain = false;
+	}
+	return collected;
+};
+//#endregion
+//#region src/utils/is-rule-listed-in-comment.ts
+const isRuleListedInComment = (ruleList, ruleId) => {
+	if (!ruleList?.trim()) return true;
+	return ruleList.split(/[,\s]+/).some((token) => token.trim() === ruleId);
+};
+//#endregion
+//#region src/utils/evaluate-suppression.ts
+const DISABLE_LINE_PATTERN = /(?:\/\/|\/\*)\s*react-doctor-disable-line\b(?:\s+([\w/\-.,\s]+?))?\s*(?:\*\/)?\s*\}?\s*$/;
+const formatLineGap = (gapLineCount) => `${gapLineCount} line${gapLineCount === 1 ? "" : "s"}`;
+const hasChainSuppressor = (comments, ruleId) => comments.some((comment) => comment.isInChain && isRuleListedInComment(comment.ruleList, ruleId));
+const findAdjacentRuleListMismatch = (comments, ruleId) => comments.find((comment) => comment.isInChain && Boolean(comment.ruleList?.trim()) && !isRuleListedInComment(comment.ruleList, ruleId));
+const findOutOfChainMatch = (comments, ruleId) => comments.find((comment) => !comment.isInChain && isRuleListedInComment(comment.ruleList, ruleId));
+const buildAdjacentMismatchHint = (comment, ruleId) => {
+	const ruleListText = comment.ruleList?.trim() ?? "";
+	return `An adjacent react-doctor-disable-next-line at line ${comment.commentLineIndex + 1} lists "${ruleListText}" — ${ruleId} is not in that list. Use the comma form: react-doctor-disable-next-line ${ruleListText}, ${ruleId}`;
+};
+const buildGapHint = (comment, diagnosticLineIndex, ruleId) => {
+	const commentLineNumber = comment.commentLineIndex + 1;
+	const diagnosticLineNumber = diagnosticLineIndex + 1;
+	return `A react-doctor-disable-next-line for ${ruleId} sits at line ${commentLineNumber}, but ${formatLineGap(diagnosticLineNumber - commentLineNumber - 1)} of code separate it from the diagnostic on line ${diagnosticLineNumber}. Move the comment immediately above line ${diagnosticLineNumber}, or extract the surrounding code into a helper so the suppression is adjacent.`;
+};
+const classifyFromComments = (commentsByAnchor, diagnosticLineIndex, ruleId) => {
+	for (const comments of commentsByAnchor) {
+		const adjacentMismatch = findAdjacentRuleListMismatch(comments, ruleId);
+		if (adjacentMismatch) return buildAdjacentMismatchHint(adjacentMismatch, ruleId);
+		const outOfChainMatch = findOutOfChainMatch(comments, ruleId);
+		if (outOfChainMatch) return buildGapHint(outOfChainMatch, diagnosticLineIndex, ruleId);
+	}
+	return null;
+};
+const evaluateSuppression = (lines, diagnosticLineIndex, ruleId) => {
+	const sameLineMatch = lines[diagnosticLineIndex]?.match(DISABLE_LINE_PATTERN);
+	if (sameLineMatch && isRuleListedInComment(sameLineMatch[1], ruleId)) return {
+		isSuppressed: true,
+		nearMissHint: null
+	};
+	const directComments = findStackedDisableCommentsAbove(lines, diagnosticLineIndex);
+	if (hasChainSuppressor(directComments, ruleId)) return {
+		isSuppressed: true,
+		nearMissHint: null
+	};
+	const openerStartIndex = findEnclosingMultilineJsxOpenerStart(lines, diagnosticLineIndex);
+	const openerComments = openerStartIndex !== null && openerStartIndex > 0 ? findStackedDisableCommentsAbove(lines, openerStartIndex) : [];
+	if (hasChainSuppressor(openerComments, ruleId)) return {
+		isSuppressed: true,
+		nearMissHint: null
+	};
+	return {
+		isSuppressed: false,
+		nearMissHint: classifyFromComments([directComments, openerComments], diagnosticLineIndex, ruleId)
+	};
+};
+//#endregion
+//#region src/utils/is-ignored-file.ts
+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);
+	return patterns.some((pattern) => pattern.test(relativePath));
+};
+//#endregion
+//#region src/utils/filter-diagnostics.ts
+const OPENING_TAG_PATTERN = /<([A-Z][\w.]*)/;
+const resolveCandidateReadPath = (rootDirectory, filePath) => {
+	const normalizedFile = filePath.replace(/\\/g, "/");
+	if (normalizedFile.startsWith("/") || /^[a-zA-Z]:\//.test(normalizedFile) || /^[a-zA-Z]:\\/.test(filePath)) return filePath;
+	return `${rootDirectory.replace(/\\/g, "/").replace(/\/$/, "")}/${normalizedFile.replace(/^\.\//, "")}`;
+};
+const createFileLinesCache = (rootDirectory, readFileLinesSync) => {
+	const cache = /* @__PURE__ */ new Map();
+	return (filePath) => {
+		const cached = cache.get(filePath);
+		if (cached !== void 0) return cached;
+		const lines = readFileLinesSync(resolveCandidateReadPath(rootDirectory, filePath));
+		cache.set(filePath, lines);
+		return lines;
+	};
 };
-const loadConfig = (rootDirectory) => {
-	const cached = cachedConfigs.get(rootDirectory);
-	if (cached !== void 0) return cached;
-	const localConfig = loadConfigFromDirectory(rootDirectory);
-	if (localConfig) {
-		cachedConfigs.set(rootDirectory, localConfig);
-		return localConfig;
-	}
-	if (isProjectBoundary(rootDirectory)) {
-		cachedConfigs.set(rootDirectory, null);
-		return null;
+const isInsideTextComponent = (lines, diagnosticLine, textComponentNames) => {
+	for (let lineIndex = diagnosticLine - 1; lineIndex >= 0; lineIndex--) {
+		const match = lines[lineIndex].match(OPENING_TAG_PATTERN);
+		if (!match) continue;
+		const fullTagName = match[1];
+		const leafTagName = fullTagName.includes(".") ? fullTagName.split(".").at(-1) ?? fullTagName : fullTagName;
+		return textComponentNames.has(fullTagName) || textComponentNames.has(leafTagName);
 	}
-	let ancestorDirectory = path.dirname(rootDirectory);
-	while (ancestorDirectory !== path.dirname(ancestorDirectory)) {
-		const ancestorConfig = loadConfigFromDirectory(ancestorDirectory);
-		if (ancestorConfig) {
-			cachedConfigs.set(rootDirectory, ancestorConfig);
-			return ancestorConfig;
-		}
-		if (isProjectBoundary(ancestorDirectory)) {
-			cachedConfigs.set(rootDirectory, null);
-			return null;
+	return false;
+};
+const filterIgnoredDiagnostics = (diagnostics, config, rootDirectory, readFileLinesSync) => {
+	const ignoredRules = new Set(Array.isArray(config.ignore?.rules) ? config.ignore.rules.filter((rule) => typeof rule === "string") : []);
+	const ignoredFilePatterns = compileIgnoredFilePatterns(config);
+	const compiledOverrides = compileIgnoreOverrides(config);
+	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) => {
+		const ruleIdentifier = `${diagnostic.plugin}/${diagnostic.rule}`;
+		if (ignoredRules.has(ruleIdentifier)) return false;
+		if (isFileIgnoredByPatterns(diagnostic.filePath, rootDirectory, ignoredFilePatterns)) return false;
+		if (isDiagnosticIgnoredByOverrides(diagnostic, rootDirectory, compiledOverrides)) return false;
+		if (hasTextComponents && diagnostic.rule === "rn-no-raw-text" && diagnostic.line > 0) {
+			const lines = getFileLines(diagnostic.filePath);
+			if (lines && isInsideTextComponent(lines, diagnostic.line, textComponentNames)) return false;
 		}
-		ancestorDirectory = path.dirname(ancestorDirectory);
-	}
-	cachedConfigs.set(rootDirectory, null);
-	return null;
+		return true;
+	});
+};
+const filterInlineSuppressions = (diagnostics, rootDirectory, readFileLinesSync) => {
+	const getFileLines = createFileLinesCache(rootDirectory, readFileLinesSync);
+	return diagnostics.flatMap((diagnostic) => {
+		if (diagnostic.line <= 0) return [diagnostic];
+		const lines = getFileLines(diagnostic.filePath);
+		if (!lines) return [diagnostic];
+		const ruleIdentifier = `${diagnostic.plugin}/${diagnostic.rule}`;
+		const evaluation = evaluateSuppression(lines, diagnostic.line - 1, ruleIdentifier);
+		if (evaluation.isSuppressed) return [];
+		return evaluation.nearMissHint ? [{
+			...diagnostic,
+			suppressionHint: evaluation.nearMissHint
+		}] : [diagnostic];
+	});
+};
+//#endregion
+//#region src/utils/merge-and-filter-diagnostics.ts
+const mergeAndFilterDiagnostics = (mergedDiagnostics, directory, userConfig, readFileLinesSync, options = {}) => {
+	const filtered = userConfig ? filterIgnoredDiagnostics(mergedDiagnostics, userConfig, directory, readFileLinesSync) : mergedDiagnostics;
+	if (options.respectInlineDisables === false) return filtered;
+	return filterInlineSuppressions(filtered, directory, readFileLinesSync);
+};
+//#endregion
+//#region src/utils/parse-react-major.ts
+const parseReactMajor = (reactVersion) => {
+	if (typeof reactVersion !== "string") return null;
+	const trimmed = reactVersion.trim();
+	if (trimmed.length === 0) return null;
+	const match = trimmed.match(/(\d+)/);
+	if (!match) return null;
+	const major = Number.parseInt(match[1], 10);
+	if (!Number.isFinite(major) || major <= 0) return null;
+	return major;
 };
 //#endregion
 //#region src/utils/read-file-lines-node.ts
@@ -1138,116 +1482,6 @@ const resolveLintIncludePaths = (rootDirectory, userConfig) => {
 	});
 };
 //#endregion
-//#region src/core/calculate-score-locally.ts
-const getScoreLabel = (score) => {
-	if (score >= 75) return "Great";
-	if (score >= 50) return "Needs work";
-	return "Critical";
-};
-const countUniqueRules = (diagnostics) => {
-	const errorRules = /* @__PURE__ */ new Set();
-	const warningRules = /* @__PURE__ */ new Set();
-	for (const diagnostic of diagnostics) {
-		const ruleKey = `${diagnostic.plugin}/${diagnostic.rule}`;
-		if (diagnostic.severity === "error") errorRules.add(ruleKey);
-		else warningRules.add(ruleKey);
-	}
-	return {
-		errorRuleCount: errorRules.size,
-		warningRuleCount: warningRules.size
-	};
-};
-const scoreFromRuleCounts = (errorRuleCount, warningRuleCount) => {
-	const penalty = errorRuleCount * ERROR_RULE_PENALTY + warningRuleCount * WARNING_RULE_PENALTY;
-	return Math.max(0, Math.round(100 - penalty));
-};
-const calculateScoreLocally = (diagnostics) => {
-	const { errorRuleCount, warningRuleCount } = countUniqueRules(diagnostics);
-	const score = scoreFromRuleCounts(errorRuleCount, warningRuleCount);
-	return {
-		score,
-		label: getScoreLabel(score)
-	};
-};
-//#endregion
-//#region src/core/try-score-from-api.ts
-const parseScoreResult = (value) => {
-	if (typeof value !== "object" || value === null) return null;
-	if (!("score" in value) || !("label" in value)) return null;
-	const scoreValue = Reflect.get(value, "score");
-	const labelValue = Reflect.get(value, "label");
-	if (typeof scoreValue !== "number" || typeof labelValue !== "string") return null;
-	return {
-		score: scoreValue,
-		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: stripFilePaths(diagnostics) }),
-			signal: controller.signal
-		});
-		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 (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 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;
-};
-const createProxyDispatcher = async (proxyUrl) => {
-	try {
-		const { ProxyAgent } = await import("undici");
-		return new ProxyAgent(proxyUrl);
-	} catch {
-		return null;
-	}
-};
-const proxyFetch = async (url, init) => {
-	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 = (diagnostics) => calculateScore$1(diagnostics, proxyFetch);
-//#endregion
 //#region src/utils/collect-unused-file-paths.ts
 const collectUnusedFilePaths = (filesIssues) => {
 	if (filesIssues instanceof Set) return [...filesIssues];
@@ -1277,36 +1511,57 @@ const extractFailedPluginName = (error) => {
 //#region src/utils/has-knip-config.ts
 const hasKnipConfig = (directory) => KNIP_CONFIG_LOCATIONS.some((configFilename) => isFile(path.join(directory, configFilename)));
 //#endregion
+//#region src/utils/sanitize-knip-config-patterns.ts
+const isMeaningfulPattern = (value) => typeof value !== "string" || value.trim().length > 0;
+const sanitizeStringArray = (values) => values.filter((entry) => typeof entry === "string" ? entry.trim().length > 0 : true);
+const sanitizeKnipConfigPatterns = (parsedConfig) => {
+	for (const [key, value] of Object.entries(parsedConfig)) {
+		if (typeof value === "string") {
+			if (!isMeaningfulPattern(value)) delete parsedConfig[key];
+			continue;
+		}
+		if (Array.isArray(value)) {
+			if (value.length === 0) continue;
+			const sanitized = sanitizeStringArray(value);
+			if (sanitized.length === value.length) continue;
+			if (sanitized.length === 0) delete parsedConfig[key];
+			else parsedConfig[key] = sanitized;
+			continue;
+		}
+		if (isPlainObject(value)) sanitizeKnipConfigPatterns(value);
+	}
+};
+//#endregion
 //#region src/utils/run-knip.ts
-const KNIP_ISSUE_TYPE_DESCRIPTORS = {
-	files: {
+const KNIP_ISSUE_TYPE_DESCRIPTORS = new Map([
+	["files", {
 		category: "Dead Code",
 		message: "Unused file",
 		severity: "warning"
-	},
-	exports: {
+	}],
+	["exports", {
 		category: "Dead Code",
 		message: "Unused export",
 		severity: "warning"
-	},
-	types: {
+	}],
+	["types", {
 		category: "Dead Code",
 		message: "Unused type",
 		severity: "warning"
-	},
-	duplicates: {
+	}],
+	["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 descriptor = KNIP_ISSUE_TYPE_DESCRIPTORS.get(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),
@@ -1344,7 +1599,7 @@ 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;
+	if (!failedPlugin || !Object.hasOwn(parsedConfig, failedPlugin) || disabledPlugins.has(failedPlugin)) return false;
 	disabledPlugins.add(failedPlugin);
 	parsedConfig[failedPlugin] = false;
 	return true;
@@ -1358,6 +1613,7 @@ const runKnipWithOptions = async (knipCwd, workspaceName) => {
 		...tsConfigFile ? { tsConfigFile } : {}
 	}));
 	const parsedConfig = options.parsedConfig;
+	sanitizeKnipConfigPatterns(parsedConfig);
 	const disabledPlugins = /* @__PURE__ */ new Set();
 	let lastKnipError;
 	for (let attempt = 0; attempt < 6; attempt++) try {
@@ -1389,7 +1645,7 @@ 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;
+	const filesDescriptor = KNIP_ISSUE_TYPE_DESCRIPTORS.get("files") ?? FALLBACK_KNIP_DESCRIPTOR;
 	for (const unusedFilePath of collectUnusedFilePaths(issues.files)) diagnostics.push({
 		filePath: path.relative(rootDirectory, unusedFilePath),
 		plugin: "knip",
@@ -1432,6 +1688,103 @@ const batchIncludePaths = (baseArgs, includePaths) => {
 	return batches;
 };
 //#endregion
+//#region src/utils/can-oxlint-extend-config.ts
+const EXTENDS_LOCAL_PATH_PREFIXES = [
+	"./",
+	"../",
+	"/"
+];
+const isLocalPathExtend = (entry) => {
+	for (const prefix of EXTENDS_LOCAL_PATH_PREFIXES) if (entry.startsWith(prefix)) return true;
+	return false;
+};
+const stripJsoncComments = (raw) => {
+	let result = "";
+	let cursor = 0;
+	let inString = false;
+	let stringQuote = "";
+	while (cursor < raw.length) {
+		const character = raw[cursor];
+		const nextCharacter = raw[cursor + 1];
+		if (inString) {
+			result += character;
+			if (character === "\\" && cursor + 1 < raw.length) {
+				result += nextCharacter;
+				cursor += 2;
+				continue;
+			}
+			if (character === stringQuote) inString = false;
+			cursor += 1;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			inString = true;
+			stringQuote = character;
+			result += character;
+			cursor += 1;
+			continue;
+		}
+		if (character === "/" && nextCharacter === "/") {
+			const lineEndIndex = raw.indexOf("\n", cursor);
+			cursor = lineEndIndex === -1 ? raw.length : lineEndIndex;
+			continue;
+		}
+		if (character === "/" && nextCharacter === "*") {
+			const blockEndIndex = raw.indexOf("*/", cursor + 2);
+			cursor = blockEndIndex === -1 ? raw.length : blockEndIndex + 2;
+			continue;
+		}
+		result += character;
+		cursor += 1;
+	}
+	return result;
+};
+const parseJsonOrJsonc = (raw) => {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return JSON.parse(stripJsoncComments(raw));
+	}
+};
+const canOxlintExtendConfig = (configPath) => {
+	if (!configPath.endsWith(".eslintrc.json")) return true;
+	let parsed;
+	try {
+		parsed = parseJsonOrJsonc(fs.readFileSync(configPath, "utf-8"));
+	} catch {
+		return true;
+	}
+	if (!isPlainObject(parsed)) return true;
+	const extendsValue = parsed.extends;
+	if (extendsValue === void 0 || extendsValue === null) return true;
+	const extendsEntries = Array.isArray(extendsValue) ? extendsValue : [extendsValue];
+	if (extendsEntries.length === 0) return true;
+	return extendsEntries.some((entry) => typeof entry === "string" && isLocalPathExtend(entry));
+};
+//#endregion
+//#region src/utils/detect-user-lint-config.ts
+const findFirstLintConfigInDirectory = (directory) => {
+	for (const filename of ADOPTABLE_LINT_CONFIG_FILENAMES) {
+		const candidatePath = path.join(directory, filename);
+		if (isFile(candidatePath)) return candidatePath;
+	}
+	return null;
+};
+const isProjectBoundary = (directory) => fs.existsSync(path.join(directory, ".git")) || isMonorepoRoot(directory);
+const detectUserLintConfigPaths = (rootDirectory) => {
+	const directLintConfig = findFirstLintConfigInDirectory(rootDirectory);
+	if (directLintConfig) return [directLintConfig];
+	if (isProjectBoundary(rootDirectory)) return [];
+	let ancestorDirectory = path.dirname(rootDirectory);
+	while (ancestorDirectory !== path.dirname(ancestorDirectory)) {
+		const ancestorLintConfig = findFirstLintConfigInDirectory(ancestorDirectory);
+		if (ancestorLintConfig) return [ancestorLintConfig];
+		if (isProjectBoundary(ancestorDirectory)) return [];
+		ancestorDirectory = path.dirname(ancestorDirectory);
+	}
+	return [];
+};
+//#endregion
 //#region src/oxlint-config.ts
 const esmRequire$1 = createRequire(import.meta.url);
 const NEXTJS_RULES = {
@@ -1593,18 +1946,27 @@ const BUILTIN_A11Y_RULES = {
 const GLOBAL_REACT_DOCTOR_RULES = {
 	"react-doctor/no-derived-state-effect": "warn",
 	"react-doctor/no-fetch-in-effect": "warn",
+	"react-doctor/no-mirror-prop-effect": "warn",
+	"react-doctor/no-mutable-in-deps": "error",
 	"react-doctor/no-cascading-set-state": "warn",
+	"react-doctor/no-effect-chain": "warn",
 	"react-doctor/no-effect-event-handler": "warn",
 	"react-doctor/no-effect-event-in-deps": "error",
+	"react-doctor/no-event-trigger-state": "warn",
 	"react-doctor/no-prop-callback-in-effect": "warn",
 	"react-doctor/no-derived-useState": "warn",
+	"react-doctor/no-direct-state-mutation": "warn",
+	"react-doctor/no-set-state-in-render": "warn",
+	"react-doctor/prefer-use-effect-event": "warn",
 	"react-doctor/prefer-useReducer": "warn",
+	"react-doctor/prefer-use-sync-external-store": "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/effect-needs-cleanup": "error",
 	"react-doctor/no-giant-component": "warn",
 	"react-doctor/no-render-in-render": "warn",
 	"react-doctor/no-many-boolean-props": "warn",
@@ -1612,6 +1974,10 @@ const GLOBAL_REACT_DOCTOR_RULES = {
 	"react-doctor/no-render-prop-children": "warn",
 	"react-doctor/no-nested-component-definition": "error",
 	"react-doctor/react-compiler-destructure-method": "warn",
+	"react-doctor/no-legacy-class-lifecycles": "error",
+	"react-doctor/no-legacy-context-api": "error",
+	"react-doctor/no-default-props": "warn",
+	"react-doctor/no-react-dom-deprecated-apis": "warn",
 	"react-doctor/no-usememo-simple-expression": "warn",
 	"react-doctor/no-layout-property-animation": "error",
 	"react-doctor/rerender-memo-with-default-value": "warn",
@@ -1660,6 +2026,7 @@ const GLOBAL_REACT_DOCTOR_RULES = {
 	"react-doctor/rendering-conditional-render": "warn",
 	"react-doctor/rendering-svg-precision": "warn",
 	"react-doctor/no-prevent-default": "warn",
+	"react-doctor/no-uncontrolled-input": "warn",
 	"react-doctor/no-document-start-view-transition": "warn",
 	"react-doctor/no-flush-sync": "warn",
 	"react-doctor/server-auth-actions": "error",
@@ -1687,6 +2054,14 @@ const GLOBAL_REACT_DOCTOR_RULES = {
 	"react-doctor/no-disabled-zoom": "error",
 	"react-doctor/no-outline-none": "warn",
 	"react-doctor/no-long-transition-duration": "warn",
+	"react-doctor/design-no-bold-heading": "warn",
+	"react-doctor/design-no-redundant-padding-axes": "warn",
+	"react-doctor/design-no-redundant-size-axes": "warn",
+	"react-doctor/design-no-space-on-flex-children": "warn",
+	"react-doctor/design-no-em-dash-in-jsx-text": "warn",
+	"react-doctor/design-no-three-period-ellipsis": "warn",
+	"react-doctor/design-no-default-tailwind-palette": "warn",
+	"react-doctor/design-no-vague-button-label": "warn",
 	"react-doctor/async-parallel": "warn"
 };
 const ALL_REACT_DOCTOR_RULE_KEYS = new Set([
@@ -1696,10 +2071,38 @@ const ALL_REACT_DOCTOR_RULE_KEYS = new Set([
 	...Object.keys(TANSTACK_START_RULES),
 	...Object.keys(TANSTACK_QUERY_RULES)
 ]);
-const createOxlintConfig = ({ pluginPath, framework, hasReactCompiler, hasTanStackQuery, customRulesOnly = false }) => {
+const VERSION_GATED_RULE_IDS = new Map([
+	["react-doctor/no-react19-deprecated-apis", {
+		minMajor: 19,
+		mode: "deprecation-warning"
+	}],
+	["react-doctor/no-default-props", {
+		minMajor: 19,
+		mode: "deprecation-warning"
+	}],
+	["react-doctor/no-react-dom-deprecated-apis", {
+		minMajor: 18,
+		mode: "deprecation-warning"
+	}],
+	["react-doctor/prefer-use-effect-event", {
+		minMajor: 19,
+		mode: "prefer-newer-api"
+	}]
+]);
+const filterRulesByReactMajor = (rules, reactMajorVersion) => {
+	return Object.fromEntries(Object.entries(rules).filter(([ruleKey]) => {
+		const gate = VERSION_GATED_RULE_IDS.get(ruleKey);
+		if (gate === void 0) return true;
+		if (gate.mode === "deprecation-warning") return true;
+		if (reactMajorVersion === null) return true;
+		return reactMajorVersion >= gate.minMajor;
+	}));
+};
+const createOxlintConfig = ({ pluginPath, framework, hasReactCompiler, hasTanStackQuery, customRulesOnly = false, reactMajorVersion = null, extendsPaths = [] }) => {
 	const reactHooksJsPlugin = resolveReactHooksJsPlugin(hasReactCompiler, customRulesOnly);
 	const reactCompilerRules = reactHooksJsPlugin ? filterRulesToAvailable(REACT_COMPILER_RULES, "react-hooks-js", reactHooksJsPlugin.availableRuleNames) : {};
 	return {
+		...extendsPaths.length > 0 ? { extends: extendsPaths } : {},
 		categories: {
 			correctness: "off",
 			suspicious: "off",
@@ -1715,7 +2118,7 @@ const createOxlintConfig = ({ pluginPath, framework, hasReactCompiler, hasTanSta
 			...customRulesOnly ? {} : BUILTIN_REACT_RULES,
 			...customRulesOnly ? {} : BUILTIN_A11Y_RULES,
 			...reactCompilerRules,
-			...GLOBAL_REACT_DOCTOR_RULES,
+			...filterRulesByReactMajor(GLOBAL_REACT_DOCTOR_RULES, reactMajorVersion),
 			...framework === "nextjs" ? NEXTJS_RULES : {},
 			...framework === "expo" || framework === "react-native" ? REACT_NATIVE_RULES : {},
 			...framework === "tanstack-start" ? TANSTACK_START_RULES : {},
@@ -1827,23 +2230,43 @@ const PLUGIN_CATEGORY_MAP = {
 	"react-hooks-js": "React Compiler",
 	"react-doctor": "Other",
 	"jsx-a11y": "Accessibility",
-	knip: "Dead Code"
+	knip: "Dead Code",
+	eslint: "Correctness",
+	oxc: "Correctness",
+	typescript: "Correctness",
+	unicorn: "Correctness",
+	import: "Bundle Size",
+	promise: "Correctness",
+	n: "Correctness",
+	node: "Correctness",
+	vitest: "Correctness",
+	jest: "Correctness",
+	nextjs: "Next.js"
 };
 const RULE_CATEGORY_MAP = {
 	"react-doctor/no-derived-state-effect": "State & Effects",
 	"react-doctor/no-fetch-in-effect": "State & Effects",
+	"react-doctor/no-mirror-prop-effect": "State & Effects",
+	"react-doctor/no-mutable-in-deps": "State & Effects",
 	"react-doctor/no-cascading-set-state": "State & Effects",
+	"react-doctor/no-effect-chain": "State & Effects",
 	"react-doctor/no-effect-event-handler": "State & Effects",
 	"react-doctor/no-effect-event-in-deps": "State & Effects",
+	"react-doctor/no-event-trigger-state": "State & Effects",
 	"react-doctor/no-prop-callback-in-effect": "State & Effects",
 	"react-doctor/no-derived-useState": "State & Effects",
+	"react-doctor/no-direct-state-mutation": "State & Effects",
+	"react-doctor/no-set-state-in-render": "State & Effects",
+	"react-doctor/prefer-use-effect-event": "State & Effects",
 	"react-doctor/prefer-useReducer": "State & Effects",
+	"react-doctor/prefer-use-sync-external-store": "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/effect-needs-cleanup": "State & Effects",
 	"react-doctor/no-generic-handler-names": "Architecture",
 	"react-doctor/no-giant-component": "Architecture",
 	"react-doctor/no-many-boolean-props": "Architecture",
@@ -1852,6 +2275,10 @@ const RULE_CATEGORY_MAP = {
 	"react-doctor/no-render-in-render": "Architecture",
 	"react-doctor/no-nested-component-definition": "Correctness",
 	"react-doctor/react-compiler-destructure-method": "Architecture",
+	"react-doctor/no-legacy-class-lifecycles": "Correctness",
+	"react-doctor/no-legacy-context-api": "Correctness",
+	"react-doctor/no-default-props": "Architecture",
+	"react-doctor/no-react-dom-deprecated-apis": "Architecture",
 	"react-doctor/no-usememo-simple-expression": "Performance",
 	"react-doctor/no-layout-property-animation": "Performance",
 	"react-doctor/rerender-memo-with-default-value": "Performance",
@@ -1885,6 +2312,7 @@ const RULE_CATEGORY_MAP = {
 	"react-doctor/rendering-conditional-render": "Correctness",
 	"react-doctor/rendering-svg-precision": "Performance",
 	"react-doctor/no-prevent-default": "Correctness",
+	"react-doctor/no-uncontrolled-input": "Correctness",
 	"react-doctor/no-document-start-view-transition": "Correctness",
 	"react-doctor/no-flush-sync": "Performance",
 	"react-doctor/nextjs-no-img-element": "Next.js",
@@ -1934,6 +2362,14 @@ const RULE_CATEGORY_MAP = {
 	"react-doctor/no-disabled-zoom": "Accessibility",
 	"react-doctor/no-outline-none": "Accessibility",
 	"react-doctor/no-long-transition-duration": "Performance",
+	"react-doctor/design-no-bold-heading": "Architecture",
+	"react-doctor/design-no-redundant-padding-axes": "Architecture",
+	"react-doctor/design-no-redundant-size-axes": "Architecture",
+	"react-doctor/design-no-space-on-flex-children": "Architecture",
+	"react-doctor/design-no-em-dash-in-jsx-text": "Architecture",
+	"react-doctor/design-no-three-period-ellipsis": "Architecture",
+	"react-doctor/design-no-default-tailwind-palette": "Architecture",
+	"react-doctor/design-no-vague-button-label": "Accessibility",
 	"react-doctor/js-flatmap-filter": "Performance",
 	"react-doctor/js-combine-iterations": "Performance",
 	"react-doctor/js-tosorted-immutable": "Performance",
@@ -1991,10 +2427,18 @@ const RULE_CATEGORY_MAP = {
 const RULE_HELP_MAP = {
 	"no-derived-state-effect": "For derived state, compute inline: `const x = fn(dep)`. For state resets on prop change, use a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
 	"no-fetch-in-effect": "Use `useQuery()` from @tanstack/react-query, `useSWR()`, or fetch in a Server Component instead",
+	"no-mirror-prop-effect": "Delete both the `useState` and the `useEffect` and read the prop directly during render. Mirroring a prop into local state forces a stale first render before the effect re-syncs",
+	"no-mutable-in-deps": "Read mutable values (`location.pathname`, `ref.current`) inside the effect body instead of in the deps array, or subscribe with `useSyncExternalStore`. Mutations to these don't trigger re-renders, so listing them in deps doesn't make the effect react to changes",
 	"no-cascading-set-state": "Combine into useReducer: `const [state, dispatch] = useReducer(reducer, initialState)`",
+	"no-effect-chain": "Compute as much as possible during render (e.g. `const isGameOver = round > 5`) and write all related state inside the event handler that originally fires the chain. Each effect link adds an extra render and makes the code rigid as requirements evolve",
 	"no-effect-event-handler": "Move the conditional logic into onClick, onChange, or onSubmit handlers directly",
+	"no-event-trigger-state": "Delete the trigger state (`useState(null)` plus the `useEffect` that watches it) and call the side-effect (`post(...)` / `navigate(...)` / `track(...)`) directly inside the event handler that previously called the setter. State should not exist purely to schedule effect runs",
 	"no-derived-useState": "Remove useState and compute the value inline: `const value = transform(propName)`",
+	"no-direct-state-mutation": "Replace the mutation with a setter call that produces a new reference: `setItems([...items, newItem])`, `setItems(items.filter(x => x !== target))`, `setItems(items.toSorted(...))`. React only re-renders on a new reference, so in-place updates are silently dropped",
+	"no-set-state-in-render": "Move the setter call into a `useEffect`, an event handler, or replace the state with a value computed during render. Calling a setter at render time triggers another render, which calls the setter again — an infinite loop",
+	"prefer-use-effect-event": "Wrap the callback with `useEffectEvent(callback)` (React 19+) and call the resulting binding from inside the sub-handler. The Effect Event captures the latest props/state without being a reactive dep, so the effect doesn't re-subscribe on every parent render. See https://react.dev/reference/react/useEffectEvent",
 	"prefer-useReducer": "Group related state: `const [state, dispatch] = useReducer(reducer, { field1, field2, ... })`",
+	"prefer-use-sync-external-store": "Replace the `useState(getSnapshot())` + `useEffect(() => store.subscribe(() => setSnapshot(getSnapshot())))` pair with `useSyncExternalStore(store.subscribe, getSnapshot)`. The hook handles tearing during concurrent renders and SSR snapshots; the manual subscribe pattern doesn't",
 	"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",
@@ -2003,7 +2447,11 @@ const RULE_HELP_MAP = {
 	"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-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. Only enabled on projects detected as React 19+.",
+	"no-legacy-class-lifecycles": "Move side effects in `componentWillMount` to `componentDidMount`; replace `componentWillReceiveProps` with `componentDidUpdate` (compare prevProps) or the static `getDerivedStateFromProps` for pure state derivation; replace `componentWillUpdate` with `getSnapshotBeforeUpdate` paired with `componentDidUpdate`. The `UNSAFE_` prefix only silences the warning — React 19 removes both forms.",
+	"no-legacy-context-api": "Replace `childContextTypes` + `getChildContext` with `const MyContext = createContext(...)` + `<MyContext.Provider value={...}>`; replace `contextTypes` with `static contextType = MyContext` (single context) or `useContext()` / `use()` from a function component. The provider and every consumer must migrate together — partial migrations leave consumers reading the wrong context.",
+	"no-default-props": "React 19 removes `Component.defaultProps` for function components. Move the defaults into the destructured props parameter: `function Foo({ size = \"md\", variant = \"primary\" })` instead of `Foo.defaultProps = { size: \"md\", variant: \"primary\" }`.",
+	"no-react-dom-deprecated-apis": "Switch the legacy `react-dom` root API (`render` / `hydrate` / `unmountComponentAtNode`) to `createRoot` / `hydrateRoot` / `root.unmount()` from `react-dom/client`. Replace `findDOMNode` with a ref. The whole `react-dom/test-utils` entry point is removed in React 19 — use `act` from `react` and `fireEvent` / `render` from `@testing-library/react`. Only enabled on projects detected as React 18+.",
 	"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",
@@ -2018,6 +2466,7 @@ const RULE_HELP_MAP = {
 	"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",
+	"effect-needs-cleanup": "Return a cleanup function that releases the subscription / timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` / `clearTimeout(id)` for timers, or `return unsubscribe` if the subscribe call already returned one",
 	"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",
@@ -2064,9 +2513,18 @@ const RULE_HELP_MAP = {
 	"no-disabled-zoom": "Remove `user-scalable=no` and `maximum-scale` from the viewport meta tag. If your layout breaks at 200% zoom, fix the layout — don't punish users with disabilities",
 	"no-outline-none": "Use `:focus-visible { outline: 2px solid var(--color-accent); outline-offset: 2px }` to show focus only for keyboard users while hiding it for mouse clicks",
 	"no-long-transition-duration": "Keep UI transitions under 1s — 100-150ms for instant feedback, 200-300ms for state changes, 300-500ms for layout changes. Use longer durations only for page-load hero animations",
+	"design-no-bold-heading": "Use `font-semibold` (600) or `font-medium` (500) on headings — 700+ crushes letter counter shapes at display sizes",
+	"design-no-redundant-padding-axes": "Collapse `px-N py-N` to `p-N` when both axes match. Keep them split only when one axis varies at a breakpoint (`py-2 md:py-3`)",
+	"design-no-redundant-size-axes": "Collapse `w-N h-N` to `size-N` (Tailwind v3.4+) when both axes match",
+	"design-no-space-on-flex-children": "Use `gap-*` on the flex/grid parent. `space-x-*` / `space-y-*` produce phantom gaps when a sibling is conditionally rendered, lose vertical spacing on wrapped lines, and don't mirror in RTL",
+	"design-no-em-dash-in-jsx-text": "Replace em dashes in JSX text with commas, colons, semicolons, periods, or parentheses — em dashes read as model-output filler",
+	"design-no-three-period-ellipsis": "Use the typographic ellipsis \"…\" (or `&hellip;`) instead of three periods — pairs with action-with-followup labels (\"Rename…\", \"Loading…\")",
+	"design-no-default-tailwind-palette": "Replace `indigo-*` / `gray-*` / `slate-*` with project tokens, your brand color, or a less-default neutral (`zinc`, `neutral`, `stone`)",
+	"design-no-vague-button-label": "Name the action: \"Save changes\" instead of \"Continue\", \"Send invite\" instead of \"Submit\", \"Delete account\" instead of \"OK\". The label IS the button's accessible name",
 	"no-array-index-as-key": "Use a stable unique identifier: `key={item.id}` or `key={item.slug}` — index keys break on reorder/filter",
 	"rendering-conditional-render": "Change to `{items.length > 0 && <List />}` or use a ternary: `{items.length ? <List /> : null}`",
 	"no-prevent-default": "Use `<form action={serverAction}>` (works without JS) or `<button>` instead of `<a>` with preventDefault",
+	"no-uncontrolled-input": "Pass an explicit initial value to `useState` (e.g. `useState(\"\")` instead of `useState()`), add `onChange` (or `readOnly` to opt out) when you supply `value`, and drop `defaultValue` on controlled inputs — React ignores it",
 	"nextjs-no-img-element": "`import Image from 'next/image'` — provides automatic WebP/AVIF, lazy loading, and responsive srcset",
 	"nextjs-async-client-component": "Fetch data in a parent Server Component and pass it as props, or use useQuery/useSWR in the client component",
 	"nextjs-no-a-element": "`import Link from 'next/link'` — enables client-side navigation, prefetching, and preserves scroll position",
@@ -2149,6 +2607,7 @@ const RULE_HELP_MAP = {
 };
 const FILEPATH_WITH_LOCATION_PATTERN = /\S+\.\w+:\d+:\d+[\s\S]*$/;
 const REACT_COMPILER_MESSAGE = "React Compiler can't optimize this code";
+const lookupOwnString = (record, key) => Object.hasOwn(record, key) ? record[key] : void 0;
 const cleanDiagnosticMessage = (message, help, plugin, rule) => {
 	if (plugin === "react-hooks-js") return {
 		message: REACT_COMPILER_MESSAGE,
@@ -2156,7 +2615,7 @@ const cleanDiagnosticMessage = (message, help, plugin, rule) => {
 	};
 	return {
 		message: message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || message,
-		help: help || RULE_HELP_MAP[rule] || ""
+		help: help || lookupOwnString(RULE_HELP_MAP, rule) || ""
 	};
 };
 const parseRuleCode = (code) => {
@@ -2184,7 +2643,7 @@ const resolvePluginPath = () => {
 	return pluginPath;
 };
 const resolveDiagnosticCategory = (plugin, rule) => {
-	return RULE_CATEGORY_MAP[`${plugin}/${rule}`] ?? PLUGIN_CATEGORY_MAP[plugin] ?? "Other";
+	return lookupOwnString(RULE_CATEGORY_MAP, `${plugin}/${rule}`) ?? lookupOwnString(PLUGIN_CATEGORY_MAP, plugin) ?? "Other";
 };
 const SANITIZED_ENV = (() => {
 	const sanitized = {};
@@ -2275,7 +2734,7 @@ const parseOxlintOutput = (stdout) => {
 		throw new Error(`Failed to parse oxlint output: ${stdout.slice(0, 200)}`);
 	}
 	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) => {
+	return parsed.diagnostics.filter((diagnostic) => diagnostic.code && SOURCE_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);
@@ -2305,8 +2764,8 @@ const validateRuleRegistration = () => {
 	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 (!Object.hasOwn(RULE_CATEGORY_MAP, fullKey)) missingCategory.push(fullKey);
+		if (!Object.hasOwn(RULE_HELP_MAP, ruleName)) 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("; ");
@@ -2314,26 +2773,24 @@ const validateRuleRegistration = () => {
 	}
 };
 const runOxlint = async (options) => {
-	const { rootDirectory, hasTypeScript, framework, hasReactCompiler, hasTanStackQuery, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true } = options;
+	const { rootDirectory, hasTypeScript, framework, hasReactCompiler, hasTanStackQuery, reactMajorVersion = null, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true } = options;
 	validateRuleRegistration();
 	if (includePaths !== void 0 && includePaths.length === 0) return [];
 	const configDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "react-doctor-oxlintrc-"));
 	const configPath = path.join(configDirectory, "oxlintrc.json");
+	const pluginPath = resolvePluginPath();
+	const extendsPaths = (adoptExistingLintConfig && !customRulesOnly ? detectUserLintConfigPaths(rootDirectory) : []).filter(canOxlintExtendConfig);
 	const config = createOxlintConfig({
-		pluginPath: resolvePluginPath(),
+		pluginPath,
 		framework,
 		hasReactCompiler,
 		hasTanStackQuery,
-		customRulesOnly
+		customRulesOnly,
+		reactMajorVersion,
+		extendsPaths
 	});
 	const restoreDisableDirectives = respectInlineDisables ? () => {} : neutralizeDisableDirectives(rootDirectory, includePaths);
 	try {
-		const fileHandle = fs.openSync(configPath, "wx", 384);
-		try {
-			fs.writeFileSync(fileHandle, JSON.stringify(config));
-		} finally {
-			fs.closeSync(fileHandle);
-		}
 		const baseArgs = [
 			resolveOxlintBinary(),
 			"-c",
@@ -2352,12 +2809,41 @@ const runOxlint = async (options) => {
 			baseArgs.push("--ignore-path", combinedIgnorePath);
 		}
 		const fileBatches = includePaths !== void 0 ? batchIncludePaths(baseArgs, includePaths) : [["."]];
-		const allDiagnostics = [];
-		for (const batch of fileBatches) {
-			const stdout = await spawnOxlint([...baseArgs, ...batch], rootDirectory, nodeBinaryPath);
-			allDiagnostics.push(...parseOxlintOutput(stdout));
+		const writeOxlintConfig = (configToWrite) => {
+			fs.rmSync(configPath, { force: true });
+			const fileHandle = fs.openSync(configPath, "wx", 384);
+			try {
+				fs.writeFileSync(fileHandle, JSON.stringify(configToWrite));
+			} finally {
+				fs.closeSync(fileHandle);
+			}
+		};
+		const spawnLintBatches = async () => {
+			const allDiagnostics = [];
+			for (const batch of fileBatches) {
+				const stdout = await spawnOxlint([...baseArgs, ...batch], rootDirectory, nodeBinaryPath);
+				allDiagnostics.push(...parseOxlintOutput(stdout));
+			}
+			return allDiagnostics;
+		};
+		writeOxlintConfig(config);
+		try {
+			return await spawnLintBatches();
+		} catch (error) {
+			if (extendsPaths.length === 0) throw error;
+			const reason = error instanceof Error ? error.message : String(error);
+			process.stderr.write(`[react-doctor] could not adopt existing lint config (${reason.split("\n")[0]}); retrying without extends. Set "adoptExistingLintConfig": false to silence.\n`);
+			writeOxlintConfig(createOxlintConfig({
+				pluginPath,
+				framework,
+				hasReactCompiler,
+				hasTanStackQuery,
+				customRulesOnly,
+				reactMajorVersion,
+				extendsPaths: []
+			}));
+			return await spawnLintBatches();
 		}
-		return allDiagnostics;
 	} finally {
 		restoreDisableDirectives();
 		fs.rmSync(configDirectory, {
@@ -2509,36 +2995,60 @@ const toJsonReport = (result, options) => buildJsonReport({
 	}],
 	totalElapsedMilliseconds: result.elapsedMilliseconds
 });
+const EMPTY_DIAGNOSTICS = [];
+const settledOrEmpty = (settled, label) => {
+	if (settled.status === "fulfilled") return settled.value;
+	console.error(`${label} rejected:`, settled.reason);
+	return EMPTY_DIAGNOSTICS;
+};
 const diagnose = async (directory, options = {}) => {
+	const startTime = globalThis.performance.now();
 	const resolvedDirectory = path.resolve(directory);
 	const userConfig = loadConfig(resolvedDirectory);
 	const includePaths = options.includePaths ?? [];
 	const isDiffMode = includePaths.length > 0;
+	const projectInfo = discoverProject(resolvedDirectory);
+	if (!projectInfo.reactVersion) throw new Error(buildNoReactDependencyError(resolvedDirectory));
 	const lintIncludePaths = computeJsxIncludePaths(includePaths) ?? resolveLintIncludePaths(resolvedDirectory, userConfig);
-	return diagnoseCore({
+	const readFileLinesSync = createNodeReadFileLinesSync(resolvedDirectory);
+	const effectiveLint = options.lint ?? userConfig?.lint ?? true;
+	const effectiveDeadCode = options.deadCode ?? userConfig?.deadCode ?? true;
+	const effectiveRespectInlineDisables = options.respectInlineDisables ?? userConfig?.respectInlineDisables ?? true;
+	const lintPromise = effectiveLint ? runOxlint({
 		rootDirectory: resolvedDirectory,
-		readFileLinesSync: createNodeReadFileLinesSync(resolvedDirectory),
-		loadUserConfig: () => userConfig,
-		discoverProjectInfo: () => discoverProject(resolvedDirectory),
-		calculateDiagnosticsScore: calculateScore,
-		getExtraDiagnostics: () => isDiffMode ? [] : checkReducedMotion(resolvedDirectory),
-		createRunners: ({ resolvedDirectory: projectRoot, projectInfo, userConfig: config }) => ({
-			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)
-		})
-	}, {
-		...options,
-		lintIncludePaths
-	});
+		hasTypeScript: projectInfo.hasTypeScript,
+		framework: projectInfo.framework,
+		hasReactCompiler: projectInfo.hasReactCompiler,
+		hasTanStackQuery: projectInfo.hasTanStackQuery,
+		reactMajorVersion: parseReactMajor(projectInfo.reactVersion),
+		includePaths: lintIncludePaths,
+		customRulesOnly: userConfig?.customRulesOnly ?? false,
+		respectInlineDisables: effectiveRespectInlineDisables,
+		adoptExistingLintConfig: userConfig?.adoptExistingLintConfig ?? true
+	}).catch((error) => {
+		console.error("Lint failed:", error);
+		return EMPTY_DIAGNOSTICS;
+	}) : Promise.resolve(EMPTY_DIAGNOSTICS);
+	const deadCodePromise = effectiveDeadCode && !isDiffMode ? runKnip(resolvedDirectory).catch((error) => {
+		console.error("Dead code analysis failed:", error);
+		return EMPTY_DIAGNOSTICS;
+	}) : Promise.resolve(EMPTY_DIAGNOSTICS);
+	const [lintSettled, deadCodeSettled] = await Promise.allSettled([lintPromise, deadCodePromise]);
+	const lintDiagnostics = settledOrEmpty(lintSettled, "Lint");
+	const deadCodeDiagnostics = settledOrEmpty(deadCodeSettled, "Dead code");
+	const environmentDiagnostics = isDiffMode ? [] : checkReducedMotion(resolvedDirectory);
+	const diagnostics = mergeAndFilterDiagnostics([
+		...lintDiagnostics,
+		...deadCodeDiagnostics,
+		...environmentDiagnostics
+	], resolvedDirectory, userConfig, readFileLinesSync, { respectInlineDisables: effectiveRespectInlineDisables });
+	const elapsedMilliseconds = globalThis.performance.now() - startTime;
+	return {
+		diagnostics,
+		score: await calculateScore(diagnostics),
+		project: projectInfo,
+		elapsedMilliseconds
+	};
 };
 //#endregion
 export { buildJsonReport, buildJsonReportError, clearCaches, diagnose, filterSourceFiles, getDiffInfo, summarizeDiagnostics, toJsonReport };