react-doctor 0.2.0-beta.1 → 0.2.0-beta.3

package/dist/index.js

@@ -0,0 +1,3073 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import reactDoctorPlugin, { ALL_REACT_DOCTOR_RULE_KEYS, FRAMEWORK_SPECIFIC_RULE_KEYS, MOTION_LIBRARY_PACKAGES } from "oxlint-plugin-react-doctor";
+import os from "node:os";
+import * as ts from "typescript";
+//#region ../project-info/dist/index.js
+var ReactDoctorError = class extends Error {
+	name = "ReactDoctorError";
+	constructor(message, options) {
+		super(message, options);
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+var ProjectNotFoundError = class extends ReactDoctorError {
+	name = "ProjectNotFoundError";
+	directory;
+	constructor(directory, options) {
+		super(`No React project found in ${directory}. Expected a package.json at the directory root or a nested package.json with a React dependency.`, options);
+		this.directory = directory;
+	}
+};
+var NoReactDependencyError = class extends ReactDoctorError {
+	name = "NoReactDependencyError";
+	directory;
+	constructor(directory, options) {
+		super(`No React dependency found in ${directory}/package.json. Add "react" to dependencies (or peerDependencies) and re-run.`, options);
+		this.directory = directory;
+	}
+};
+var PackageJsonNotFoundError = class extends ReactDoctorError {
+	name = "PackageJsonNotFoundError";
+	directory;
+	constructor(directory, options) {
+		super(`No package.json found in ${directory}`, options);
+		this.directory = directory;
+	}
+};
+var AmbiguousProjectError = class extends ReactDoctorError {
+	name = "AmbiguousProjectError";
+	directory;
+	candidates;
+	constructor(directory, candidates, options) {
+		super(`Multiple React projects found under ${directory} (${candidates.length} candidates): ${candidates.join(", ")}. Re-run diagnose() with one of those subdirectories, or iterate them yourself.`, options);
+		this.directory = directory;
+		this.candidates = candidates;
+	}
+};
+const isReactDoctorError = (value) => value instanceof ReactDoctorError;
+const isFile = (filePath) => {
+	try {
+		return fs.statSync(filePath).isFile();
+	} catch {
+		return false;
+	}
+};
+const SOURCE_FILE_PATTERN = /\.(tsx?|jsx?)$/;
+const GIT_LS_FILES_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+const IGNORED_DIRECTORIES = new Set([
+	".git",
+	".next",
+	".nuxt",
+	".output",
+	".svelte-kit",
+	".turbo",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out",
+	"storybook-static"
+]);
+const countSourceFilesViaFilesystem = (rootDirectory) => {
+	let count = 0;
+	const stack = [rootDirectory];
+	while (stack.length > 0) {
+		const currentDirectory = stack.pop();
+		const entries = fs.readdirSync(currentDirectory, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				if (!entry.name.startsWith(".") && !IGNORED_DIRECTORIES.has(entry.name)) stack.push(path.join(currentDirectory, entry.name));
+				continue;
+			}
+			if (entry.isFile() && SOURCE_FILE_PATTERN.test(entry.name)) count++;
+		}
+	}
+	return count;
+};
+const countSourceFilesViaGit = (rootDirectory) => {
+	const result = spawnSync("git", [
+		"ls-files",
+		"-z",
+		"--cached",
+		"--others",
+		"--exclude-standard"
+	], {
+		cwd: rootDirectory,
+		encoding: "utf-8",
+		maxBuffer: GIT_LS_FILES_MAX_BUFFER_BYTES
+	});
+	if (result.error || result.status !== 0) return null;
+	return result.stdout.split("\0").filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath)).length;
+};
+const countSourceFiles = (rootDirectory) => countSourceFilesViaGit(rootDirectory) ?? countSourceFilesViaFilesystem(rootDirectory);
+const cachedPackageJsons = /* @__PURE__ */ new Map();
+const clearPackageJsonCache = () => {
+	cachedPackageJsons.clear();
+};
+const readPackageJsonUncached = (packageJsonPath) => {
+	try {
+		return JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+	} catch (error) {
+		if (error instanceof SyntaxError) return {};
+		if (error instanceof Error && "code" in error) {
+			const { code } = error;
+			if (code === "EISDIR" || code === "EACCES") return {};
+		}
+		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;
+};
+const isMonorepoRoot = (directory) => {
+	if (isFile(path.join(directory, "pnpm-workspace.yaml"))) return true;
+	if (isFile(path.join(directory, "nx.json"))) return true;
+	const packageJsonPath = path.join(directory, "package.json");
+	if (!isFile(packageJsonPath)) return false;
+	const packageJson = readPackageJson(packageJsonPath);
+	return Array.isArray(packageJson.workspaces) || Boolean(packageJson.workspaces?.packages);
+};
+const findMonorepoRoot = (startDirectory) => {
+	let currentDirectory = path.dirname(startDirectory);
+	while (currentDirectory !== path.dirname(currentDirectory)) {
+		if (isMonorepoRoot(currentDirectory)) return currentDirectory;
+		currentDirectory = path.dirname(currentDirectory);
+	}
+	return null;
+};
+const REACT_COMPILER_PACKAGES = new Set([
+	"babel-plugin-react-compiler",
+	"react-compiler-runtime",
+	"eslint-plugin-react-compiler"
+]);
+const NEXT_CONFIG_FILENAMES = [
+	"next.config.js",
+	"next.config.mjs",
+	"next.config.ts",
+	"next.config.cjs"
+];
+const BABEL_CONFIG_FILENAMES = [
+	".babelrc",
+	".babelrc.json",
+	"babel.config.js",
+	"babel.config.json",
+	"babel.config.cjs",
+	"babel.config.mjs"
+];
+const VITE_CONFIG_FILENAMES = [
+	"vite.config.js",
+	"vite.config.ts",
+	"vite.config.mjs",
+	"vite.config.mts",
+	"vite.config.cjs",
+	"vite.config.cts",
+	"vitest.config.ts",
+	"vitest.config.js"
+];
+const EXPO_APP_CONFIG_FILENAMES = [
+	"app.json",
+	"app.config.js",
+	"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 hasCompilerPackage = (packageJson) => {
+	const allDependencies = {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	return Object.keys(allDependencies).some((packageName) => REACT_COMPILER_PACKAGES.has(packageName));
+};
+const hasCompilerInConfigFile = (filePath) => {
+	if (!isFile(filePath)) return false;
+	const content = fs.readFileSync(filePath, "utf-8");
+	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$2 = (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$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$2(ancestorDirectory)) return false;
+		ancestorDirectory = path.dirname(ancestorDirectory);
+	}
+	return false;
+};
+const FRAMEWORK_PACKAGES = {
+	next: "nextjs",
+	"@tanstack/react-start": "tanstack-start",
+	vite: "vite",
+	"react-scripts": "cra",
+	"@remix-run/react": "remix",
+	gatsby: "gatsby",
+	expo: "expo",
+	"react-native": "react-native"
+};
+const detectFramework = (dependencies) => {
+	for (const [packageName, frameworkName] of Object.entries(FRAMEWORK_PACKAGES)) if (dependencies[packageName]) return frameworkName;
+	return "unknown";
+};
+const UPPER_BOUND_COMPARATOR = /<\s*=?\s*\d+(?:\.\d+){0,2}(?:-[^\s,|]+)?/g;
+const HAS_UPPER_BOUND_COMPARATOR = /<\s*=?\s*\d+(?:\.\d+){0,2}(?:-[^\s,|]+)?/;
+const OR_SEPARATOR = /\s*\|\|\s*/;
+const UNRESOLVABLE_PROTOCOL_VERSION = /^(?:file|git|github|https?|link|patch|portal|workspace|npm):/i;
+const DIST_TAG_VERSION = /^[a-z][a-z0-9._-]*$/i;
+const WILDCARD_VERSION = /^[*xX](?:\.[*xX])*$/;
+const NON_LOWER_BOUND_COMPARATOR = /(?:^|[\s,|])(?:>(?!=)|!={0,2})\s*\d/;
+const LOWER_BOUND_MAJOR = /(?:^|[\s,|])(?:>=\s*|[~^=v]\s*)?(\d+)(?=$|[\s,|.*xX-])/g;
+const NPM_ALIAS_VERSION = /^npm:(?:@[^/]+\/[^@]+|[^@]+)@(.+)$/i;
+const normalizeDependencyVersion = (version) => {
+	const trimmed = version.trim();
+	if (trimmed.length === 0) return null;
+	const normalizedVersion = trimmed.match(NPM_ALIAS_VERSION)?.[1]?.trim() ?? trimmed;
+	if (UNRESOLVABLE_PROTOCOL_VERSION.test(normalizedVersion)) return null;
+	if (DIST_TAG_VERSION.test(normalizedVersion) && !/^v\d/i.test(normalizedVersion)) return null;
+	if (WILDCARD_VERSION.test(normalizedVersion)) return null;
+	return normalizedVersion;
+};
+const splitDependencyVersionBranches = (version) => version.split(OR_SEPARATOR).filter(Boolean);
+const hasUpperBoundComparator = (version) => HAS_UPPER_BOUND_COMPARATOR.test(version);
+const getBranchLowestMajor = (branch) => {
+	if (NON_LOWER_BOUND_COMPARATOR.test(branch)) return null;
+	const lowerBoundComparators = branch.replace(UPPER_BOUND_COMPARATOR, " ").trim();
+	if (lowerBoundComparators.length === 0) return null;
+	let branchLowestMajor = null;
+	for (const match of lowerBoundComparators.matchAll(LOWER_BOUND_MAJOR)) {
+		const major = Number.parseInt(match[1], 10);
+		if (!Number.isFinite(major) || major <= 0) continue;
+		if (branchLowestMajor === null || major < branchLowestMajor) branchLowestMajor = major;
+	}
+	return branchLowestMajor;
+};
+const getLowestDependencyMajor = (version) => {
+	const normalizedVersion = normalizeDependencyVersion(version);
+	if (normalizedVersion === null) return null;
+	let lowestMajor = null;
+	for (const branch of splitDependencyVersionBranches(normalizedVersion)) {
+		const normalizedBranch = normalizeDependencyVersion(branch);
+		if (normalizedBranch === null) return null;
+		const branchLowestMajor = getBranchLowestMajor(normalizedBranch);
+		if (branchLowestMajor === null && hasUpperBoundComparator(normalizedBranch)) return null;
+		if (branchLowestMajor !== null && (lowestMajor === null || branchLowestMajor < lowestMajor)) lowestMajor = branchLowestMajor;
+	}
+	return lowestMajor;
+};
+const isConcreteDependencyVersion = (version) => {
+	const normalizedVersion = normalizeDependencyVersion(version);
+	return normalizedVersion !== null && /\d/.test(normalizedVersion);
+};
+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;
+};
+const isCatalogReference = (version) => version.startsWith("catalog:");
+const extractCatalogName = (version) => {
+	if (!isCatalogReference(version)) return null;
+	const name = version.slice(8).trim();
+	return name.length > 0 ? name : null;
+};
+const resolveVersionFromCatalog = (catalog, packageName) => {
+	const version = catalog[packageName];
+	if (typeof version === "string" && !isCatalogReference(version)) return version;
+	return null;
+};
+const parsePnpmWorkspaceCatalogs = (rootDirectory) => {
+	const workspacePath = path.join(rootDirectory, "pnpm-workspace.yaml");
+	if (!isFile(workspacePath)) return {
+		defaultCatalog: {},
+		namedCatalogs: {}
+	};
+	const content = fs.readFileSync(workspacePath, "utf-8");
+	const defaultCatalog = {};
+	const namedCatalogs = {};
+	let currentSection = "none";
+	let currentCatalogName = "";
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
+		const indentLevel = line.search(/\S/);
+		if (indentLevel === 0 && trimmed === "catalog:") {
+			currentSection = "catalog";
+			continue;
+		}
+		if (indentLevel === 0 && trimmed === "catalogs:") {
+			currentSection = "catalogs";
+			continue;
+		}
+		if (indentLevel === 0) {
+			currentSection = "none";
+			continue;
+		}
+		if (currentSection === "catalog" && indentLevel > 0) {
+			const colonIndex = trimmed.indexOf(":");
+			if (colonIndex > 0) {
+				const key = trimmed.slice(0, colonIndex).trim().replace(/["']/g, "");
+				const value = trimmed.slice(colonIndex + 1).trim().replace(/["']/g, "");
+				if (key && value) defaultCatalog[key] = value;
+			}
+			continue;
+		}
+		if (currentSection === "catalogs" && indentLevel > 0) {
+			if (trimmed.endsWith(":") && !trimmed.includes(" ")) {
+				currentCatalogName = trimmed.slice(0, -1).replace(/["']/g, "");
+				currentSection = "named-catalog";
+				namedCatalogs[currentCatalogName] = {};
+				continue;
+			}
+		}
+		if (currentSection === "named-catalog" && indentLevel > 0) {
+			if (indentLevel <= 2 && trimmed.endsWith(":") && !trimmed.includes(" ")) {
+				currentCatalogName = trimmed.slice(0, -1).replace(/["']/g, "");
+				namedCatalogs[currentCatalogName] = {};
+				continue;
+			}
+			const colonIndex = trimmed.indexOf(":");
+			if (colonIndex > 0 && currentCatalogName) {
+				const key = trimmed.slice(0, colonIndex).trim().replace(/["']/g, "");
+				const value = trimmed.slice(colonIndex + 1).trim().replace(/["']/g, "");
+				if (key && value) namedCatalogs[currentCatalogName][key] = value;
+			}
+		}
+	}
+	return {
+		defaultCatalog,
+		namedCatalogs
+	};
+};
+const resolveCatalogVersionFromCollection = (catalogs, packageName, options) => {
+	const { catalogReference, shouldSearchUnreferencedNamedCatalogs } = options;
+	if (catalogReference) {
+		const namedCatalog = catalogs.namedCatalogs[catalogReference];
+		if (namedCatalog?.[packageName]) return namedCatalog[packageName];
+	}
+	if (catalogs.defaultCatalog[packageName]) return catalogs.defaultCatalog[packageName];
+	if (!shouldSearchUnreferencedNamedCatalogs) return null;
+	for (const namedCatalog of Object.values(catalogs.namedCatalogs)) if (namedCatalog[packageName]) return namedCatalog[packageName];
+	return null;
+};
+const resolveCatalogVersion = (packageJson, packageName, rootDirectory, explicitCatalogReference) => {
+	const rawVersion = {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	}[packageName];
+	const hasExplicitCatalogReference = explicitCatalogReference !== void 0;
+	const catalogName = hasExplicitCatalogReference ? explicitCatalogReference : rawVersion ? extractCatalogName(rawVersion) : null;
+	const shouldSearchUnreferencedNamedCatalogs = !hasExplicitCatalogReference && catalogName === null;
+	if (isPlainObject(packageJson.catalog)) {
+		const version = resolveVersionFromCatalog(packageJson.catalog, packageName);
+		if (version) return version;
+	}
+	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;
+		}
+		if (shouldSearchUnreferencedNamedCatalogs) {
+			for (const catalogEntries of Object.values(packageJson.catalogs)) if (isPlainObject(catalogEntries)) {
+				const version = resolveVersionFromCatalog(catalogEntries, packageName);
+				if (version) return version;
+			}
+		}
+	}
+	const workspaces = packageJson.workspaces;
+	if (workspaces && !Array.isArray(workspaces)) {
+		if (isPlainObject(workspaces.catalog)) {
+			const version = resolveVersionFromCatalog(workspaces.catalog, packageName);
+			if (version) return version;
+		}
+		if (isPlainObject(workspaces.catalogs)) {
+			const namedCatalog = catalogName ? workspaces.catalogs[catalogName] : void 0;
+			if (namedCatalog && isPlainObject(namedCatalog)) {
+				const version = resolveVersionFromCatalog(namedCatalog, packageName);
+				if (version) return version;
+			}
+			if (shouldSearchUnreferencedNamedCatalogs) {
+				for (const catalogEntries of Object.values(workspaces.catalogs)) if (isPlainObject(catalogEntries)) {
+					const version = resolveVersionFromCatalog(catalogEntries, packageName);
+					if (version) return version;
+				}
+			}
+		}
+	}
+	if (rootDirectory) {
+		const pnpmVersion = resolveCatalogVersionFromCollection(parsePnpmWorkspaceCatalogs(rootDirectory), packageName, {
+			catalogReference: catalogName,
+			shouldSearchUnreferencedNamedCatalogs
+		});
+		if (pnpmVersion) return pnpmVersion;
+	}
+	return null;
+};
+const EMPTY_DEPENDENCY_INFO = {
+	reactVersion: null,
+	tailwindVersion: null,
+	framework: "unknown"
+};
+const pickConcreteVersion = (packageJson, packageName, sections) => {
+	for (const section of sections) {
+		const version = packageJson[section]?.[packageName];
+		if (version === void 0) continue;
+		if (isCatalogReference(version)) return null;
+		if (isConcreteDependencyVersion(version)) return version;
+	}
+	return null;
+};
+const extractDependencyInfo = (packageJson) => {
+	const allDependencies = {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	return {
+		reactVersion: pickConcreteVersion(packageJson, "react", [
+			"dependencies",
+			"peerDependencies",
+			"devDependencies"
+		]),
+		tailwindVersion: pickConcreteVersion(packageJson, "tailwindcss", [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies"
+		]),
+		framework: detectFramework(allDependencies)
+	};
+};
+const getDependencyDeclaration = ({ packageJson, packageName, sections }) => {
+	for (const section of sections) {
+		const version = packageJson[section]?.[packageName];
+		if (version === void 0) continue;
+		return {
+			catalogReference: extractCatalogName(version) ?? null,
+			hasDeclaration: true,
+			version
+		};
+	}
+	return {
+		catalogReference: null,
+		hasDeclaration: false,
+		version: null
+	};
+};
+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 parsePnpmWorkspacePatterns = (rootDirectory) => {
+	const workspacePath = path.join(rootDirectory, "pnpm-workspace.yaml");
+	if (!isFile(workspacePath)) return [];
+	const content = fs.readFileSync(workspacePath, "utf-8");
+	const patterns = [];
+	let isInsidePackagesBlock = false;
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed === "packages:") {
+			isInsidePackagesBlock = true;
+			continue;
+		}
+		if (isInsidePackagesBlock && trimmed.startsWith("-")) patterns.push(trimmed.replace(/^-\s*/, "").replace(/["']/g, ""));
+		else if (isInsidePackagesBlock && trimmed.length > 0 && !trimmed.startsWith("#")) isInsidePackagesBlock = false;
+	}
+	return patterns;
+};
+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 parseReactMajor = (reactVersion) => {
+	if (typeof reactVersion !== "string") return null;
+	return getLowestDependencyMajor(reactVersion);
+};
+const resolveWorkspaceDirectories = (rootDirectory, pattern) => {
+	const cleanPattern = pattern.replace(/["']/g, "").replace(/\/\*\*$/, "/*");
+	if (!cleanPattern.includes("*")) {
+		const directoryPath = path.join(rootDirectory, cleanPattern);
+		if (fs.existsSync(directoryPath) && isFile(path.join(directoryPath, "package.json"))) return [directoryPath];
+		return [];
+	}
+	const wildcardIndex = cleanPattern.indexOf("*");
+	const baseDirectory = path.join(rootDirectory, cleanPattern.slice(0, wildcardIndex));
+	const suffixAfterWildcard = cleanPattern.slice(wildcardIndex + 1);
+	if (!fs.existsSync(baseDirectory) || !fs.statSync(baseDirectory).isDirectory()) return [];
+	const resolved = [];
+	for (const entry of fs.readdirSync(baseDirectory)) {
+		const entryPath = path.join(baseDirectory, entry, suffixAfterWildcard);
+		if (fs.existsSync(entryPath) && fs.statSync(entryPath).isDirectory() && isFile(path.join(entryPath, "package.json"))) resolved.push(entryPath);
+	}
+	return resolved;
+};
+const resolveWorkspaceDependencyVersion = ({ concreteVersion, packageName, rootDirectory, rootPackageJson, sections, workspaceDirectory, workspacePackageJson }) => {
+	const dependencyDeclaration = getDependencyDeclaration({
+		packageJson: workspacePackageJson,
+		packageName,
+		sections
+	});
+	if (!dependencyDeclaration.hasDeclaration) return null;
+	return concreteVersion ?? resolveCatalogVersion(workspacePackageJson, packageName, workspaceDirectory, dependencyDeclaration.catalogReference) ?? resolveCatalogVersion(rootPackageJson, packageName, rootDirectory, dependencyDeclaration.catalogReference);
+};
+const shouldReplaceReactVersion = (currentVersion, nextVersion) => {
+	if (!currentVersion) return true;
+	const currentMajor = parseReactMajor(currentVersion);
+	const nextMajor = parseReactMajor(nextVersion);
+	if (currentMajor === null) return nextMajor !== null;
+	if (nextMajor === null) return false;
+	return nextMajor < currentMajor;
+};
+const findReactInWorkspaces = (rootDirectory, packageJson) => {
+	const patterns = getWorkspacePatterns(rootDirectory, packageJson);
+	const result = { ...EMPTY_DEPENDENCY_INFO };
+	for (const pattern of patterns) {
+		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
+		for (const workspaceDirectory of directories) {
+			const workspacePackageJson = readPackageJson(path.join(workspaceDirectory, "package.json"));
+			const info = extractDependencyInfo(workspacePackageJson);
+			const reactVersion = resolveWorkspaceDependencyVersion({
+				concreteVersion: info.reactVersion,
+				packageName: "react",
+				rootDirectory,
+				rootPackageJson: packageJson,
+				sections: [
+					"dependencies",
+					"peerDependencies",
+					"devDependencies"
+				],
+				workspaceDirectory,
+				workspacePackageJson
+			});
+			const tailwindVersion = resolveWorkspaceDependencyVersion({
+				concreteVersion: info.tailwindVersion,
+				packageName: "tailwindcss",
+				rootDirectory,
+				rootPackageJson: packageJson,
+				sections: [
+					"dependencies",
+					"devDependencies",
+					"peerDependencies"
+				],
+				workspaceDirectory,
+				workspacePackageJson
+			});
+			if (reactVersion && shouldReplaceReactVersion(result.reactVersion, reactVersion)) result.reactVersion = reactVersion;
+			if (tailwindVersion && !result.tailwindVersion) result.tailwindVersion = tailwindVersion;
+			if (info.framework !== "unknown" && result.framework === "unknown") result.framework = info.framework;
+			const resultReactMajor = parseReactMajor(result.reactVersion);
+			if (result.reactVersion && result.tailwindVersion && result.framework !== "unknown" && resultReactMajor !== null && resultReactMajor <= 17) return result;
+		}
+	}
+	return result;
+};
+const REACT_DEPENDENCY_NAMES = new Set([
+	"react",
+	"react-native",
+	"next"
+]);
+const hasReactDependency = (packageJson) => {
+	const allDependencies = {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	return Object.keys(allDependencies).some((packageName) => REACT_DEPENDENCY_NAMES.has(packageName));
+};
+const findDependencyInfoFromMonorepoRoot = (directory) => {
+	const monorepoRoot = findMonorepoRoot(directory);
+	if (!monorepoRoot) return EMPTY_DEPENDENCY_INFO;
+	const monorepoPackageJsonPath = path.join(monorepoRoot, "package.json");
+	if (!isFile(monorepoPackageJsonPath)) return EMPTY_DEPENDENCY_INFO;
+	const rootPackageJson = readPackageJson(monorepoPackageJsonPath);
+	const rootInfo = extractDependencyInfo(rootPackageJson);
+	const leafPackageJsonPath = path.join(directory, "package.json");
+	const leafPackageJson = isFile(leafPackageJsonPath) ? readPackageJson(leafPackageJsonPath) : null;
+	const leafReactDeclaration = leafPackageJson ? getDependencyDeclaration({
+		packageJson: leafPackageJson,
+		packageName: "react",
+		sections: [
+			"dependencies",
+			"peerDependencies",
+			"devDependencies"
+		]
+	}) : null;
+	const leafTailwindDeclaration = leafPackageJson ? getDependencyDeclaration({
+		packageJson: leafPackageJson,
+		packageName: "tailwindcss",
+		sections: [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies"
+		]
+	}) : null;
+	const shouldUseReactFallback = leafPackageJson ? hasReactDependency(leafPackageJson) : true;
+	const shouldUseTailwindFallback = leafTailwindDeclaration?.hasDeclaration ?? true;
+	const reactCatalogVersion = shouldUseReactFallback ? resolveCatalogVersion(rootPackageJson, "react", monorepoRoot, leafReactDeclaration?.catalogReference) : null;
+	const tailwindCatalogVersion = shouldUseTailwindFallback ? resolveCatalogVersion(rootPackageJson, "tailwindcss", monorepoRoot, leafTailwindDeclaration?.catalogReference) : null;
+	const workspaceInfo = findReactInWorkspaces(monorepoRoot, rootPackageJson);
+	return {
+		reactVersion: shouldUseReactFallback ? reactCatalogVersion ?? rootInfo.reactVersion ?? workspaceInfo.reactVersion : null,
+		tailwindVersion: shouldUseTailwindFallback ? tailwindCatalogVersion ?? rootInfo.tailwindVersion ?? workspaceInfo.tailwindVersion : null,
+		framework: rootInfo.framework !== "unknown" ? rootInfo.framework : workspaceInfo.framework
+	};
+};
+const TANSTACK_QUERY_PACKAGES = new Set([
+	"@tanstack/react-query",
+	"@tanstack/query-core",
+	"react-query"
+]);
+const hasTanStackQuery = (packageJson) => {
+	const allDependencies = {
+		...packageJson.peerDependencies,
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	return Object.keys(allDependencies).some((packageName) => TANSTACK_QUERY_PACKAGES.has(packageName));
+};
+const hasUpperBoundOnlyPeerRange = (range) => {
+	if (typeof range !== "string") return false;
+	const normalizedRange = normalizeDependencyVersion(range);
+	if (normalizedRange === null) return false;
+	return splitDependencyVersionBranches(normalizedRange).some((branch) => {
+		const normalizedBranch = normalizeDependencyVersion(branch);
+		return normalizedBranch !== null && getBranchLowestMajor(normalizedBranch) === null && hasUpperBoundComparator(normalizedBranch);
+	});
+};
+const peerRangeMinMajor = (range) => {
+	if (typeof range !== "string") return null;
+	return getLowestDependencyMajor(range);
+};
+const resolveEffectiveReactMajor = (reactVersion, packageJson) => {
+	const installedReactMajor = parseReactMajor(reactVersion);
+	const peerReactRange = packageJson.peerDependencies?.react;
+	if (typeof peerReactRange !== "string") return installedReactMajor;
+	const peerFloor = peerRangeMinMajor(peerReactRange);
+	if (peerFloor === null) return hasUpperBoundOnlyPeerRange(peerReactRange) ? null : installedReactMajor;
+	return installedReactMajor !== null ? Math.min(installedReactMajor, peerFloor) : peerFloor;
+};
+const listWorkspacePackages = (rootDirectory) => {
+	const packageJsonPath = path.join(rootDirectory, "package.json");
+	if (!isFile(packageJsonPath)) return [];
+	const packageJson = readPackageJson(packageJsonPath);
+	const patterns = getWorkspacePatterns(rootDirectory, packageJson);
+	if (patterns.length === 0) return [];
+	const packages = [];
+	const seenDirectories = /* @__PURE__ */ new Set();
+	const pushIfNew = (workspacePackage) => {
+		if (seenDirectories.has(workspacePackage.directory)) return;
+		seenDirectories.add(workspacePackage.directory);
+		packages.push(workspacePackage);
+	};
+	if (hasReactDependency(packageJson)) pushIfNew({
+		name: packageJson.name ?? path.basename(rootDirectory),
+		directory: rootDirectory
+	});
+	for (const pattern of patterns) {
+		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
+		for (const workspaceDirectory of directories) {
+			const workspacePackageJson = readPackageJson(path.join(workspaceDirectory, "package.json"));
+			if (!hasReactDependency(workspacePackageJson)) continue;
+			pushIfNew({
+				name: workspacePackageJson.name ?? path.basename(workspaceDirectory),
+				directory: workspaceDirectory
+			});
+		}
+	}
+	return packages;
+};
+const toReactWorkspacePackages = (directories) => {
+	const packages = [];
+	for (const directory of directories) {
+		const packageJsonPath = path.join(directory, "package.json");
+		if (!isFile(packageJsonPath)) continue;
+		const packageJson = readPackageJson(packageJsonPath);
+		if (!hasReactDependency(packageJson)) continue;
+		const name = packageJson.name ?? path.basename(directory);
+		packages.push({
+			name,
+			directory
+		});
+	}
+	return packages;
+};
+const listManifestWorkspacePackages = (rootDirectory) => {
+	if (isFile(path.join(rootDirectory, "package.json"))) return listWorkspacePackages(rootDirectory);
+	const patterns = parsePnpmWorkspacePatterns(rootDirectory);
+	const nxPatterns = patterns.length > 0 ? [] : getNxWorkspaceDirectories(rootDirectory);
+	return toReactWorkspacePackages((patterns.length > 0 ? patterns : nxPatterns).flatMap((pattern) => resolveWorkspaceDirectories(rootDirectory, pattern)));
+};
+const discoverReactSubprojectsByFilesystem = (rootDirectory) => {
+	const packages = [];
+	const pendingDirectories = [rootDirectory];
+	while (pendingDirectories.length > 0) {
+		const currentDirectory = pendingDirectories.pop();
+		if (!currentDirectory) continue;
+		const packageJsonPath = path.join(currentDirectory, "package.json");
+		if (isFile(packageJsonPath)) {
+			const packageJson = readPackageJson(packageJsonPath);
+			if (hasReactDependency(packageJson)) {
+				const name = packageJson.name ?? path.basename(currentDirectory);
+				packages.push({
+					name,
+					directory: currentDirectory
+				});
+			}
+		}
+		const entries = fs.readdirSync(currentDirectory, { withFileTypes: true }).toSorted((firstEntry, secondEntry) => firstEntry.name.localeCompare(secondEntry.name));
+		for (const entry of entries) {
+			if (!entry.isDirectory() || entry.name.startsWith(".") || IGNORED_DIRECTORIES.has(entry.name)) continue;
+			pendingDirectories.push(path.join(currentDirectory, entry.name));
+		}
+	}
+	return packages;
+};
+const discoverReactSubprojects = (rootDirectory) => {
+	if (!fs.existsSync(rootDirectory) || !fs.statSync(rootDirectory).isDirectory()) return [];
+	const manifestPackages = listManifestWorkspacePackages(rootDirectory);
+	if (manifestPackages.length > 0) return manifestPackages;
+	return discoverReactSubprojectsByFilesystem(rootDirectory);
+};
+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 PackageJsonNotFoundError(directory);
+	const packageJson = readPackageJson(packageJsonPath);
+	let { reactVersion, tailwindVersion, framework } = extractDependencyInfo(packageJson);
+	const reactDeclaration = getDependencyDeclaration({
+		packageJson,
+		packageName: "react",
+		sections: [
+			"dependencies",
+			"peerDependencies",
+			"devDependencies"
+		]
+	});
+	const tailwindDeclaration = getDependencyDeclaration({
+		packageJson,
+		packageName: "tailwindcss",
+		sections: [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies"
+		]
+	});
+	if (!reactVersion && reactDeclaration.hasDeclaration) reactVersion = resolveCatalogVersion(packageJson, "react", directory, reactDeclaration.catalogReference);
+	if (!tailwindVersion && tailwindDeclaration.hasDeclaration) tailwindVersion = resolveCatalogVersion(packageJson, "tailwindcss", directory, tailwindDeclaration.catalogReference);
+	if (!reactVersion || !tailwindVersion) {
+		const monorepoRoot = findMonorepoRoot(directory);
+		if (monorepoRoot) {
+			const monorepoPackageJsonPath = path.join(monorepoRoot, "package.json");
+			if (isFile(monorepoPackageJsonPath)) {
+				const rootPackageJson = readPackageJson(monorepoPackageJsonPath);
+				if (!reactVersion && reactDeclaration.hasDeclaration) reactVersion = resolveCatalogVersion(rootPackageJson, "react", monorepoRoot, reactDeclaration.catalogReference);
+				if (!tailwindVersion && tailwindDeclaration.hasDeclaration) tailwindVersion = resolveCatalogVersion(rootPackageJson, "tailwindcss", monorepoRoot, tailwindDeclaration.catalogReference);
+			}
+		}
+	}
+	if (!reactVersion || framework === "unknown") {
+		const workspaceInfo = findReactInWorkspaces(directory, packageJson);
+		if (!reactVersion && workspaceInfo.reactVersion) reactVersion = workspaceInfo.reactVersion;
+		if (!tailwindVersion && workspaceInfo.tailwindVersion) tailwindVersion = workspaceInfo.tailwindVersion;
+		if (framework === "unknown" && workspaceInfo.framework !== "unknown") framework = workspaceInfo.framework;
+	}
+	if ((!reactVersion || framework === "unknown") && !isMonorepoRoot(directory)) {
+		const monorepoInfo = findDependencyInfoFromMonorepoRoot(directory);
+		if (!reactVersion) reactVersion = monorepoInfo.reactVersion;
+		if (!tailwindVersion) tailwindVersion = monorepoInfo.tailwindVersion;
+		if (framework === "unknown") framework = monorepoInfo.framework;
+	}
+	if (!reactVersion && reactDeclaration.version && !isCatalogReference(reactDeclaration.version)) reactVersion = reactDeclaration.version;
+	if (!tailwindVersion && tailwindDeclaration.version && !isCatalogReference(tailwindDeclaration.version)) tailwindVersion = tailwindDeclaration.version;
+	const projectName = packageJson.name ?? path.basename(directory);
+	const hasTypeScript = fs.existsSync(path.join(directory, "tsconfig.json"));
+	const sourceFileCount = countSourceFiles(directory);
+	const projectInfo = {
+		rootDirectory: directory,
+		projectName,
+		reactVersion,
+		reactMajorVersion: resolveEffectiveReactMajor(reactVersion, packageJson),
+		tailwindVersion,
+		framework,
+		hasTypeScript,
+		hasReactCompiler: detectReactCompiler(directory, packageJson),
+		hasTanStackQuery: hasTanStackQuery(packageJson),
+		sourceFileCount
+	};
+	cachedProjectInfos.set(directory, projectInfo);
+	return projectInfo;
+};
+const parseTailwindMajorMinor = (tailwindVersion) => {
+	if (typeof tailwindVersion !== "string") return null;
+	const trimmed = tailwindVersion.trim();
+	if (trimmed.length === 0) return null;
+	const majorMinorMatch = trimmed.match(/(\d+)\.(\d+)/);
+	if (majorMinorMatch) {
+		const major = Number.parseInt(majorMinorMatch[1], 10);
+		const minor = Number.parseInt(majorMinorMatch[2], 10);
+		if (!Number.isFinite(major) || major <= 0) return null;
+		if (!Number.isFinite(minor) || minor < 0) return null;
+		return {
+			major,
+			minor
+		};
+	}
+	const majorOnlyMatch = trimmed.match(/(\d+)/);
+	if (!majorOnlyMatch) return null;
+	const major = Number.parseInt(majorOnlyMatch[1], 10);
+	if (!Number.isFinite(major) || major <= 0) return null;
+	return {
+		major,
+		minor: 0
+	};
+};
+const isTailwindAtLeast = (detected, required) => {
+	if (detected === null) return true;
+	if (detected.major !== required.major) return detected.major > required.major;
+	return detected.minor >= required.minor;
+};
+//#endregion
+//#region ../core/dist/index.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+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);
+};
+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 warnConfigField$1 = (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$1(`ignore.overrides[${index}] must be an object with { files, rules }; ignoring this entry.`);
+		return null;
+	}
+	if (!isStringArray(entry.files)) {
+		warnConfigField$1(`ignore.overrides[${index}].files must be an array of strings; ignoring this entry.`);
+		return null;
+	}
+	if (entry.rules !== void 0 && !isStringArray(entry.rules)) {
+		warnConfigField$1(`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$1(`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)));
+};
+const JSX_FILE_PATTERN = /\.(tsx|jsx)$/;
+const SCORE_API_URL = "https://www.react.doctor/api/score";
+const FETCH_TIMEOUT_MS = 1e4;
+const DEFAULT_BRANCH_CANDIDATES = ["main", "master"];
+const ADOPTABLE_LINT_CONFIG_FILENAMES = [".oxlintrc.json", ".eslintrc.json"];
+const OXLINT_OUTPUT_MAX_BYTES = 50 * 1024 * 1024;
+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 >= 100;
+		if (exceedsArgLength || exceedsFileCount) {
+			batches.push(currentBatch);
+			currentBatch = [];
+			currentBatchLength = baseArgsLength;
+		}
+		currentBatch.push(filePath);
+		currentBatchLength += entryLength;
+	}
+	if (currentBatch.length > 0) batches.push(currentBatch);
+	return batches;
+};
+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);
+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
+	};
+};
+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
+	};
+};
+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,
+		...result.skippedCheckReasons ? { skippedCheckReasons: result.skippedCheckReasons } : {},
+		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
+	};
+};
+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 calculateScore = async (diagnostics) => {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+	try {
+		const response = await fetch(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}`);
+			return null;
+		}
+		return parseScoreResult(await response.json());
+	} catch (error) {
+		console.warn(`[react-doctor] Score API unreachable (${describeFailure(error)})`);
+		return null;
+	} finally {
+		clearTimeout(timeoutId);
+	}
+};
+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));
+};
+const REDUCED_MOTION_GREP_PATTERN = "prefers-reduced-motion|useReducedMotion|MotionConfig|reducedMotion";
+const REDUCED_MOTION_FILE_GLOBS = [
+	"*.ts",
+	"*.tsx",
+	"*.js",
+	"*.jsx",
+	"*.css",
+	"*.scss"
+];
+const MISSING_REDUCED_MOTION_DIAGNOSTIC = {
+	filePath: "package.json",
+	plugin: "react-doctor",
+	rule: "require-reduced-motion",
+	severity: "error",
+	message: "Project uses a motion library but has no prefers-reduced-motion handling — required for accessibility (WCAG 2.3.3)",
+	help: "Add `useReducedMotion()` from your animation library, or a `@media (prefers-reduced-motion: reduce)` CSS query",
+	line: 0,
+	column: 0,
+	category: "Accessibility"
+};
+const checkReducedMotion = (rootDirectory) => {
+	const packageJsonPath = path.join(rootDirectory, "package.json");
+	if (!isFile(packageJsonPath)) return [];
+	let hasMotionLibrary = false;
+	try {
+		const packageJson = readPackageJson(packageJsonPath);
+		const allDependencies = {
+			...packageJson.dependencies,
+			...packageJson.devDependencies
+		};
+		hasMotionLibrary = Object.keys(allDependencies).some((packageName) => MOTION_LIBRARY_PACKAGES.has(packageName));
+	} catch {
+		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];
+};
+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 {
+		content = fs.readFileSync(filePath, "utf-8");
+	} catch {
+		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;
+};
+var import_picocolors = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+})))(), 1);
+const highlighter = {
+	error: import_picocolors.default.red,
+	warn: import_picocolors.default.yellow,
+	info: import_picocolors.default.cyan,
+	success: import_picocolors.default.green,
+	dim: import_picocolors.default.dim,
+	gray: import_picocolors.default.gray,
+	bold: import_picocolors.default.bold
+};
+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("");
+	}
+};
+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;
+};
+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;
+};
+const createNodeReadFileLinesSync = (rootDirectory) => {
+	return (filePath) => {
+		const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(rootDirectory, filePath);
+		try {
+			return fs.readFileSync(absolutePath, "utf-8").split("\n");
+		} catch {
+			return null;
+		}
+	};
+};
+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;
+};
+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;
+};
+const DISABLE_NEXT_LINE_PATTERN = /(?:\/\/|\/\*)\s*react-doctor-disable-next-line\b(?:\s+([^\r\n]*?))?\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;
+};
+const stripDescriptionTail = (ruleList) => {
+	const descriptionMatch = ruleList.match(/(?:^|\s)--\s/);
+	if (!descriptionMatch || descriptionMatch.index === void 0) return ruleList;
+	return ruleList.slice(0, descriptionMatch.index);
+};
+const isRuleListedInComment = (ruleList, ruleId) => {
+	const trimmed = ruleList?.trim();
+	if (!trimmed) return true;
+	const ruleSection = stripDescriptionTail(trimmed).trim();
+	if (!ruleSection) return true;
+	return ruleSection.split(/[,\s]+/).some((token) => token.trim() === ruleId);
+};
+const DISABLE_LINE_PATTERN = /(?:\/\/|\/\*)\s*react-doctor-disable-line\b(?:\s+([^\r\n]*?))?\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)
+	};
+};
+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));
+};
+const OPENING_TAG_PATTERN = /<([A-Z][\w.]*)/;
+const JSX_CHILD_OPEN_PATTERN = /<[A-Za-z]/;
+const escapeRegExpSpecials = (rawText) => rawText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+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 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 findOpenerAtOrAbove = (lines, upperBoundLineIndex) => {
+	for (let lineIndex = upperBoundLineIndex; lineIndex >= 0; lineIndex--) {
+		const match = lines[lineIndex].match(OPENING_TAG_PATTERN);
+		if (!match) continue;
+		const fullName = match[1];
+		return {
+			fullName,
+			leafName: fullName.includes(".") ? fullName.split(".").at(-1) ?? fullName : fullName,
+			lineIndex
+		};
+	}
+	return null;
+};
+const resolveJsxRange = (lines, opener) => {
+	const closingPattern = new RegExp(`</(?:${escapeRegExpSpecials(opener.fullName)}|${escapeRegExpSpecials(opener.leafName)})\\s*>`);
+	let closerLineIndex = -1;
+	let closerColumn = -1;
+	for (let lineIndex = opener.lineIndex; lineIndex < lines.length; lineIndex++) {
+		const match = closingPattern.exec(lines[lineIndex]);
+		if (!match) continue;
+		closerLineIndex = lineIndex;
+		closerColumn = match.index;
+		break;
+	}
+	if (closerLineIndex < 0) return null;
+	const openerLine = lines[opener.lineIndex];
+	const tagStartIndex = openerLine.indexOf(`<${opener.fullName}`);
+	if (tagStartIndex < 0) return null;
+	const openerEndIndex = openerLine.indexOf(">", tagStartIndex);
+	let bodyText;
+	if (opener.lineIndex === closerLineIndex) {
+		if (openerEndIndex < 0 || openerEndIndex >= closerColumn) return null;
+		bodyText = openerLine.slice(openerEndIndex + 1, closerColumn);
+	} else {
+		const segments = [];
+		if (openerEndIndex >= 0) segments.push(openerLine.slice(openerEndIndex + 1));
+		for (let lineIndex = opener.lineIndex + 1; lineIndex < closerLineIndex; lineIndex++) segments.push(lines[lineIndex]);
+		segments.push(lines[closerLineIndex].slice(0, closerColumn));
+		bodyText = segments.join("\n");
+	}
+	return {
+		closerLineIndex,
+		closerColumn,
+		bodyText
+	};
+};
+const isInsideStringOnlyWrapper = (lines, diagnosticLine, diagnosticColumn, wrapperNames) => {
+	const diagnosticLineIndex = diagnosticLine - 1;
+	const diagnosticColumnIndex = Math.max(0, diagnosticColumn - 1);
+	let upperBoundLineIndex = diagnosticLineIndex;
+	while (upperBoundLineIndex >= 0) {
+		const opener = findOpenerAtOrAbove(lines, upperBoundLineIndex);
+		if (!opener) return false;
+		const range = resolveJsxRange(lines, opener);
+		if (range === null) {
+			upperBoundLineIndex = opener.lineIndex - 1;
+			continue;
+		}
+		if (range.closerLineIndex < diagnosticLineIndex || range.closerLineIndex === diagnosticLineIndex && range.closerColumn <= diagnosticColumnIndex) {
+			upperBoundLineIndex = opener.lineIndex - 1;
+			continue;
+		}
+		if (!wrapperNames.has(opener.fullName) && !wrapperNames.has(opener.leafName)) return false;
+		return !JSX_CHILD_OPEN_PATTERN.test(range.bodyText);
+	}
+	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 rawTextWrapperComponentNames = new Set(Array.isArray(config.rawTextWrapperComponents) ? config.rawTextWrapperComponents.filter((name) => typeof name === "string") : []);
+	const hasRawTextWrappers = rawTextWrapperComponentNames.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 || hasRawTextWrappers) && diagnostic.rule === "rn-no-raw-text" && diagnostic.line > 0) {
+			const lines = getFileLines(diagnostic.filePath);
+			if (lines) {
+				if (hasTextComponents && isInsideTextComponent(lines, diagnostic.line, textComponentNames)) return false;
+				if (hasRawTextWrappers && isInsideStringOnlyWrapper(lines, diagnostic.line, diagnostic.column, rawTextWrapperComponentNames)) return false;
+			}
+		}
+		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];
+	});
+};
+const TEST_FILE_PATH_PATTERN = /(?:^|\/)(?:__tests__|__test__|tests|test|__mocks__|cypress|e2e|playwright)\/|\.(?:test|spec|stories|story|fixture|fixtures)\.(?:[cm]?[jt]sx?)$/;
+const isTestFilePath = (relativePath) => {
+	if (relativePath.length === 0) return false;
+	const forwardSlashed = relativePath.replaceAll("\\", "/");
+	return TEST_FILE_PATH_PATTERN.test(forwardSlashed);
+};
+const testFileResultCache = /* @__PURE__ */ new Map();
+const clearAutoSuppressionCaches = () => {
+	testFileResultCache.clear();
+};
+const shouldAutoSuppress = (diagnostic) => {
+	const filePath = diagnostic.filePath;
+	if ((diagnostic.plugin === "react-doctor" ? reactDoctorPlugin.rules[diagnostic.rule] : null)?.tags?.includes("test-noise")) {
+		let isTest = testFileResultCache.get(filePath);
+		if (isTest === void 0) {
+			isTest = isTestFilePath(filePath);
+			testFileResultCache.set(filePath, isTest);
+		}
+		if (isTest) return true;
+	}
+	return false;
+};
+const mergeAndFilterDiagnostics = (mergedDiagnostics, directory, userConfig, readFileLinesSync, options = {}) => {
+	const autoFiltered = mergedDiagnostics.filter((diagnostic) => !shouldAutoSuppress(diagnostic));
+	const filtered = userConfig ? filterIgnoredDiagnostics(autoFiltered, userConfig, directory, readFileLinesSync) : autoFiltered;
+	if (options.respectInlineDisables === false) return filtered;
+	return filterInlineSuppressions(filtered, directory, readFileLinesSync);
+};
+const combineDiagnostics = (input) => {
+	const { lintDiagnostics, directory, isDiffMode, userConfig, readFileLinesSync = createNodeReadFileLinesSync(directory), includeEnvironmentChecks = true, respectInlineDisables } = input;
+	const extraDiagnostics = isDiffMode || !includeEnvironmentChecks ? [] : checkReducedMotion(directory);
+	return mergeAndFilterDiagnostics([...lintDiagnostics, ...extraDiagnostics], directory, userConfig, readFileLinesSync, { respectInlineDisables });
+};
+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$1 = (directory) => fs.existsSync(path.join(directory, ".git")) || isMonorepoRoot(directory);
+const detectUserLintConfigPaths = (rootDirectory) => {
+	const directLintConfig = findFirstLintConfigInDirectory(rootDirectory);
+	if (directLintConfig) return [directLintConfig];
+	if (isProjectBoundary$1(rootDirectory)) return [];
+	let ancestorDirectory = path.dirname(rootDirectory);
+	while (ancestorDirectory !== path.dirname(ancestorDirectory)) {
+		const ancestorLintConfig = findFirstLintConfigInDirectory(ancestorDirectory);
+		if (ancestorLintConfig) return [ancestorLintConfig];
+		if (isProjectBoundary$1(ancestorDirectory)) return [];
+		ancestorDirectory = path.dirname(ancestorDirectory);
+	}
+	return [];
+};
+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) => {
+	const branch = runGit(directory, [
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	]);
+	if (!branch) return null;
+	return branch === "HEAD" ? null : branch;
+};
+const detectDefaultBranch = (directory) => {
+	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) => {
+	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) => {
+	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;
+		return {
+			currentBranch,
+			baseBranch,
+			changedFiles: uncommittedFiles,
+			isCurrentChanges: true
+		};
+	}
+	const changedFiles = getChangedFilesSinceBranch(directory, baseBranch);
+	if (changedFiles === null) return null;
+	return {
+		currentBranch,
+		baseBranch,
+		changedFiles
+	};
+};
+const filterSourceFiles = (filePaths) => filePaths.filter((filePath) => SOURCE_FILE_PATTERN.test(filePath));
+const computeJsxIncludePaths = (includePaths) => includePaths.length > 0 ? includePaths.filter((filePath) => JSX_FILE_PATTERN.test(filePath)) : void 0;
+const BOOLEAN_FIELD_NAMES = [
+	"lint",
+	"verbose",
+	"customRulesOnly",
+	"share",
+	"respectInlineDisables",
+	"adoptExistingLintConfig",
+	"offline"
+];
+const STRING_FIELD_NAMES = ["rootDir"];
+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 validateString = (fieldName, value) => {
+	if (typeof value === "string") return value;
+	warnConfigField(`config field "${fieldName}" must be a string (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;
+	}
+	for (const fieldName of STRING_FIELD_NAMES) {
+		const original = config[fieldName];
+		if (original === void 0) continue;
+		const validatedString = validateString(fieldName, original);
+		if (validatedString === void 0) delete validated[fieldName];
+		else validated[fieldName] = validatedString;
+	}
+	return validated;
+};
+const CONFIG_FILENAME = "react-doctor.config.json";
+const PACKAGE_JSON_CONFIG_KEY = "reactDoctor";
+const loadConfigFromDirectory = (directory) => {
+	const configFilePath = path.join(directory, CONFIG_FILENAME);
+	if (isFile(configFilePath)) try {
+		const fileContent = fs.readFileSync(configFilePath, "utf-8");
+		const parsed = JSON.parse(fileContent);
+		if (isPlainObject(parsed)) return {
+			config: validateConfigTypes(parsed),
+			sourceDirectory: directory
+		};
+		logger.warn(`${CONFIG_FILENAME} must be a JSON object, ignoring.`);
+	} catch (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 packageJson = JSON.parse(fileContent);
+		if (isPlainObject(packageJson)) {
+			const embeddedConfig = packageJson[PACKAGE_JSON_CONFIG_KEY];
+			if (isPlainObject(embeddedConfig)) return {
+				config: validateConfigTypes(embeddedConfig),
+				sourceDirectory: directory
+			};
+		}
+	} 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 loadConfigWithSource = (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;
+	}
+	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;
+		}
+		ancestorDirectory = path.dirname(ancestorDirectory);
+	}
+	cachedConfigs.set(rootDirectory, null);
+	return null;
+};
+const DISABLE_DIRECTIVE_PATTERN = /(eslint|oxlint)-disable/;
+const findFilesWithDisableDirectivesViaGit = (rootDirectory, includePaths) => {
+	const grepArgs = [
+		"grep",
+		"-l",
+		"--untracked",
+		"-E",
+		"(eslint|oxlint)-disable"
+	];
+	if (includePaths && includePaths.length > 0) grepArgs.push("--", ...includePaths);
+	const result = spawnSync("git", grepArgs, {
+		cwd: rootDirectory,
+		encoding: "utf-8",
+		maxBuffer: GIT_LS_FILES_MAX_BUFFER_BYTES
+	});
+	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 (error) {
+			process.stderr.write(`[react-doctor] Failed to restore inline disable directives in ${absolutePath}: ${error instanceof Error ? error.message : String(error)}\n[react-doctor] Run: git checkout -- ${absolutePath}\n`);
+		}
+	};
+	const onExit = () => restore();
+	process.once("exit", onExit);
+	for (const relativePath of filePaths) {
+		const absolutePath = path.join(rootDirectory, relativePath);
+		let originalContent;
+		try {
+			originalContent = fs.readFileSync(absolutePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const neutralizedContent = neutralizeContent(originalContent);
+		if (neutralizedContent !== originalContent) {
+			originalContents.set(absolutePath, originalContent);
+			fs.writeFileSync(absolutePath, neutralizedContent);
+		}
+	}
+	return () => {
+		restore();
+		process.removeListener("exit", onExit);
+	};
+};
+const resolveConfigRootDir = (config, configSourceDirectory) => {
+	if (!config || !configSourceDirectory) return null;
+	const rawRootDir = config.rootDir;
+	if (typeof rawRootDir !== "string") return null;
+	const trimmedRootDir = rawRootDir.trim();
+	if (trimmedRootDir.length === 0) return null;
+	const resolvedRootDir = path.isAbsolute(trimmedRootDir) ? trimmedRootDir : path.resolve(configSourceDirectory, trimmedRootDir);
+	if (resolvedRootDir === configSourceDirectory) return null;
+	if (!fs.existsSync(resolvedRootDir) || !fs.statSync(resolvedRootDir).isDirectory()) {
+		logger.warn(`react-doctor config "rootDir" points to "${rawRootDir}" (resolved to ${resolvedRootDir}), which is not a directory. Ignoring.`);
+		return null;
+	}
+	return resolvedRootDir;
+};
+const resolveDiagnoseTarget = (directory) => {
+	if (isFile(path.join(directory, "package.json"))) return directory;
+	const reactSubprojects = discoverReactSubprojects(directory);
+	if (reactSubprojects.length === 0) return null;
+	if (reactSubprojects.length === 1) return reactSubprojects[0].directory;
+	throw new AmbiguousProjectError(directory, reactSubprojects.map((subproject) => path.relative(directory, subproject.directory)).toSorted());
+};
+const listSourceFilesViaGit = (rootDirectory) => {
+	const result = spawnSync("git", [
+		"ls-files",
+		"-z",
+		"--cached",
+		"--others",
+		"--exclude-standard"
+	], {
+		cwd: rootDirectory,
+		encoding: "utf-8",
+		maxBuffer: GIT_LS_FILES_MAX_BUFFER_BYTES
+	});
+	if (result.error || result.status !== 0) return null;
+	return result.stdout.split("\0").filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath));
+};
+const listSourceFilesViaFilesystem = (rootDirectory) => {
+	const filePaths = [];
+	const stack = [rootDirectory];
+	while (stack.length > 0) {
+		const currentDirectory = stack.pop();
+		const entries = fs.readdirSync(currentDirectory, { withFileTypes: true });
+		for (const entry of entries) {
+			const absolutePath = path.join(currentDirectory, entry.name);
+			if (entry.isDirectory()) {
+				if (!entry.name.startsWith(".") && !IGNORED_DIRECTORIES.has(entry.name)) stack.push(absolutePath);
+				continue;
+			}
+			if (entry.isFile() && SOURCE_FILE_PATTERN.test(entry.name)) filePaths.push(path.relative(rootDirectory, absolutePath).replace(/\\/g, "/"));
+		}
+	}
+	return filePaths;
+};
+const listSourceFiles = (rootDirectory) => listSourceFilesViaGit(rootDirectory) ?? listSourceFilesViaFilesystem(rootDirectory);
+const resolveLintIncludePaths = (rootDirectory, userConfig) => {
+	if (!Array.isArray(userConfig?.ignore?.files) || userConfig.ignore.files.length === 0) return;
+	const ignoredPatterns = compileIgnoredFilePatterns(userConfig);
+	return listSourceFiles(rootDirectory).filter((filePath) => {
+		if (!JSX_FILE_PATTERN.test(filePath)) return false;
+		return !isFileIgnoredByPatterns(filePath, rootDirectory, ignoredPatterns);
+	});
+};
+const dedupeDiagnostics = (diagnostics) => {
+	const seenKeys = /* @__PURE__ */ new Set();
+	const uniqueDiagnostics = [];
+	for (const diagnostic of diagnostics) {
+		const key = `${diagnostic.filePath}\u0000${diagnostic.line}\u0000${diagnostic.column}\u0000${diagnostic.plugin}\u0000${diagnostic.rule}\u0000${diagnostic.severity}\u0000${diagnostic.message}`;
+		if (seenKeys.has(key)) continue;
+		seenKeys.add(key);
+		uniqueDiagnostics.push(diagnostic);
+	}
+	return uniqueDiagnostics;
+};
+const buildCapabilities = (project) => {
+	const capabilities = /* @__PURE__ */ new Set();
+	capabilities.add(project.framework);
+	if (project.framework === "expo" || project.framework === "react-native") capabilities.add("react-native");
+	const reactMajor = project.reactMajorVersion;
+	if (reactMajor !== null) for (let major = 17; major <= reactMajor; major++) capabilities.add(`react:${major}`);
+	if (project.tailwindVersion !== null) {
+		capabilities.add("tailwind");
+		if (isTailwindAtLeast(parseTailwindMajorMinor(project.tailwindVersion), {
+			major: 3,
+			minor: 4
+		})) capabilities.add("tailwind:3.4");
+	}
+	if (project.hasReactCompiler) capabilities.add("react-compiler");
+	if (project.hasTanStackQuery) capabilities.add("tanstack-query");
+	if (project.hasTypeScript) capabilities.add("typescript");
+	return capabilities;
+};
+const shouldEnableRule = (requires, tags, capabilities, ignoredTags) => {
+	if (requires) {
+		for (const capability of requires) if (!capabilities.has(capability)) return false;
+	}
+	if (tags) {
+		for (const tag of tags) if (ignoredTags.has(tag)) return false;
+	}
+	return true;
+};
+const esmRequire$1 = createRequire(import.meta.url);
+const readPluginRuleNames = (pluginSpecifier) => {
+	try {
+		const pluginModule = esmRequire$1(pluginSpecifier);
+		const rules = pluginModule.rules ?? pluginModule.default?.rules;
+		if (rules === void 0) return /* @__PURE__ */ new Set();
+		return new Set(Object.keys(rules));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+};
+const resolveReactHooksJsPlugin = (hasReactCompiler, customRulesOnly) => {
+	if (!hasReactCompiler || customRulesOnly) return null;
+	let pluginSpecifier;
+	try {
+		pluginSpecifier = esmRequire$1.resolve("eslint-plugin-react-hooks");
+	} catch {
+		return null;
+	}
+	return {
+		entry: {
+			name: "react-hooks-js",
+			specifier: pluginSpecifier
+		},
+		availableRuleNames: readPluginRuleNames(pluginSpecifier)
+	};
+};
+const YOU_MIGHT_NOT_NEED_EFFECT_NAMESPACE = "effect";
+const resolveYouMightNotNeedEffectPlugin = (customRulesOnly) => {
+	if (customRulesOnly) return null;
+	let pluginSpecifier;
+	try {
+		pluginSpecifier = esmRequire$1.resolve("eslint-plugin-react-you-might-not-need-an-effect");
+	} catch {
+		return null;
+	}
+	return {
+		entry: {
+			name: YOU_MIGHT_NOT_NEED_EFFECT_NAMESPACE,
+			specifier: pluginSpecifier
+		},
+		availableRuleNames: readPluginRuleNames(pluginSpecifier)
+	};
+};
+const filterRulesToAvailable = (rules, pluginNamespace, availableRuleNames) => {
+	if (availableRuleNames.size === 0) return rules;
+	const ruleKeyPrefix = `${pluginNamespace}/`;
+	const filtered = {};
+	for (const [ruleKey, severity] of Object.entries(rules)) {
+		if (!ruleKey.startsWith(ruleKeyPrefix)) {
+			filtered[ruleKey] = severity;
+			continue;
+		}
+		const ruleName = ruleKey.slice(ruleKeyPrefix.length);
+		if (availableRuleNames.has(ruleName)) filtered[ruleKey] = severity;
+	}
+	return filtered;
+};
+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"
+};
+const YOU_MIGHT_NOT_NEED_EFFECT_RULES = {
+	"effect/no-derived-state": "warn",
+	"effect/no-chain-state-updates": "warn",
+	"effect/no-event-handler": "warn",
+	"effect/no-adjust-state-on-prop-change": "warn",
+	"effect/no-reset-all-state-on-prop-change": "warn",
+	"effect/no-pass-live-state-to-parent": "warn",
+	"effect/no-pass-data-to-parent": "warn",
+	"effect/no-initialize-state": "warn"
+};
+const BUILTIN_REACT_RULES = {
+	"react/rules-of-hooks": "error",
+	"react/no-direct-mutation-state": "error",
+	"react/jsx-no-duplicate-props": "error",
+	"react/jsx-key": "error",
+	"react/no-children-prop": "warn",
+	"react/no-danger": "warn",
+	"react/jsx-no-script-url": "error",
+	"react/no-render-return-value": "warn",
+	"react/no-string-refs": "warn",
+	"react/no-is-mounted": "warn",
+	"react/require-render-return": "error",
+	"react/no-unknown-property": "warn"
+};
+const BUILTIN_A11Y_RULES = {
+	"jsx-a11y/alt-text": "error",
+	"jsx-a11y/anchor-is-valid": "warn",
+	"jsx-a11y/click-events-have-key-events": "warn",
+	"jsx-a11y/no-static-element-interactions": "warn",
+	"jsx-a11y/role-has-required-aria-props": "error",
+	"jsx-a11y/no-autofocus": "warn",
+	"jsx-a11y/heading-has-content": "warn",
+	"jsx-a11y/html-has-lang": "warn",
+	"jsx-a11y/no-redundant-roles": "warn",
+	"jsx-a11y/scope": "warn",
+	"jsx-a11y/tabindex-no-positive": "warn",
+	"jsx-a11y/label-has-associated-control": "warn",
+	"jsx-a11y/no-distracting-elements": "error",
+	"jsx-a11y/iframe-has-title": "warn"
+};
+const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, extendsPaths = [], ignoredTags = /* @__PURE__ */ new Set() }) => {
+	const reactHooksJsPlugin = resolveReactHooksJsPlugin(project.hasReactCompiler, customRulesOnly);
+	const reactCompilerRules = reactHooksJsPlugin ? filterRulesToAvailable(REACT_COMPILER_RULES, "react-hooks-js", reactHooksJsPlugin.availableRuleNames) : {};
+	const youMightNotNeedEffectPlugin = resolveYouMightNotNeedEffectPlugin(customRulesOnly);
+	const youMightNotNeedEffectRules = youMightNotNeedEffectPlugin ? filterRulesToAvailable(YOU_MIGHT_NOT_NEED_EFFECT_RULES, YOU_MIGHT_NOT_NEED_EFFECT_NAMESPACE, youMightNotNeedEffectPlugin.availableRuleNames) : {};
+	const jsPlugins = [];
+	if (reactHooksJsPlugin) jsPlugins.push(reactHooksJsPlugin.entry);
+	if (youMightNotNeedEffectPlugin) jsPlugins.push(youMightNotNeedEffectPlugin.entry);
+	const capabilities = buildCapabilities(project);
+	const enabledReactDoctorRules = {};
+	for (const [ruleId, rule] of Object.entries(reactDoctorPlugin.rules)) {
+		const fullKey = `react-doctor/${ruleId}`;
+		if (rule.framework !== "global" && !rule.requires) continue;
+		if (!shouldEnableRule(rule.requires, rule.tags, capabilities, ignoredTags)) continue;
+		enabledReactDoctorRules[fullKey] = rule.severity;
+	}
+	return {
+		...extendsPaths.length > 0 ? { extends: extendsPaths } : {},
+		categories: {
+			correctness: "off",
+			suspicious: "off",
+			pedantic: "off",
+			perf: "off",
+			restriction: "off",
+			style: "off",
+			nursery: "off"
+		},
+		plugins: customRulesOnly ? [] : ["react", "jsx-a11y"],
+		jsPlugins: [...jsPlugins, pluginPath],
+		rules: {
+			...customRulesOnly ? {} : BUILTIN_REACT_RULES,
+			...customRulesOnly ? {} : BUILTIN_A11Y_RULES,
+			...reactCompilerRules,
+			...youMightNotNeedEffectRules,
+			...enabledReactDoctorRules
+		}
+	};
+};
+const REACT_MODULE_SOURCE = "react";
+const REQUIRE_IDENTIFIER = "require";
+const USE_IDENTIFIER = "use";
+const LOCAL_BINDING_RESOLUTION = {
+	isReactUseBinding: false,
+	isReactNamespaceBinding: false
+};
+const REACT_NAMESPACE_BINDING_RESOLUTION = {
+	isReactUseBinding: false,
+	isReactNamespaceBinding: true
+};
+const REACT_USE_BINDING_RESOLUTION = {
+	isReactUseBinding: true,
+	isReactNamespaceBinding: false
+};
+const getScriptKind = (filename) => {
+	if (filename.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (filename.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (filename.endsWith(".ts")) return ts.ScriptKind.TS;
+	return ts.ScriptKind.JS;
+};
+const getUtf16Offset = (sourceText, utf8Offset) => Buffer.from(sourceText).subarray(0, utf8Offset).toString("utf8").length;
+const unwrapExpression = (expression) => {
+	let currentExpression = expression;
+	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
+	return currentExpression;
+};
+const getStaticPropertyName = (node) => {
+	if (!node) return null;
+	if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node)) return node.text;
+	if (ts.isComputedPropertyName(node)) {
+		const expression = unwrapExpression(node.expression);
+		if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) return expression.text;
+	}
+	return null;
+};
+const findBindingIdentifier = (bindingName, identifierName) => {
+	if (ts.isIdentifier(bindingName)) return bindingName.text === identifierName ? bindingName : null;
+	for (const element of bindingName.elements) {
+		if (ts.isOmittedExpression(element)) continue;
+		const nestedIdentifier = findBindingIdentifier(element.name, identifierName);
+		if (nestedIdentifier) return nestedIdentifier;
+	}
+	return null;
+};
+const bindingNameHasIdentifier = (bindingName, identifierName) => {
+	if (ts.isIdentifier(bindingName)) return bindingName.text === identifierName;
+	return bindingName.elements.some((element) => {
+		if (ts.isOmittedExpression(element)) return false;
+		return bindingNameHasIdentifier(element.name, identifierName);
+	});
+};
+const getDirectBindingIdentifier = (bindingName) => ts.isIdentifier(bindingName) ? bindingName : null;
+const isReactUseObjectBindingElement = (bindingElement) => {
+	const bindingIdentifier = getDirectBindingIdentifier(bindingElement.name);
+	if (!bindingIdentifier) return false;
+	if (!bindingElement.propertyName) return bindingIdentifier.text === USE_IDENTIFIER;
+	return getStaticPropertyName(bindingElement.propertyName) === USE_IDENTIFIER;
+};
+const isReactRequireCall = (expression) => {
+	const unwrappedExpression = unwrapExpression(expression);
+	return ts.isCallExpression(unwrappedExpression) && ts.isIdentifier(unwrappedExpression.expression) && unwrappedExpression.expression.text === REQUIRE_IDENTIFIER && unwrappedExpression.arguments.length === 1 && ts.isStringLiteral(unwrappedExpression.arguments[0]) && unwrappedExpression.arguments[0].text === REACT_MODULE_SOURCE;
+};
+const getModuleSource = (node) => {
+	let currentNode = node;
+	while (currentNode) {
+		if (ts.isImportDeclaration(currentNode) && ts.isStringLiteral(currentNode.moduleSpecifier)) return currentNode.moduleSpecifier.text;
+		currentNode = currentNode.parent;
+	}
+	return null;
+};
+const getImportedName = (importSpecifier) => importSpecifier.propertyName?.text ?? importSpecifier.name.text;
+const collectReactObjectBindingNames = (bindingPattern, useImportNames) => {
+	for (const bindingElement of bindingPattern.elements) {
+		const bindingIdentifier = getDirectBindingIdentifier(bindingElement.name);
+		if (bindingIdentifier && isReactUseObjectBindingElement(bindingElement)) useImportNames.add(bindingIdentifier.text);
+	}
+};
+const isReactObjectBindingName = (bindingPattern, identifierName) => bindingPattern.elements.some((bindingElement) => {
+	if (getDirectBindingIdentifier(bindingElement.name)?.text !== identifierName) return false;
+	return isReactUseObjectBindingElement(bindingElement);
+});
+const isReactRequireBindingDeclaration = (node, identifierName) => {
+	if (!ts.isVariableDeclaration(node)) return false;
+	if (!node.initializer) return false;
+	if (!isReactRequireCall(node.initializer)) return false;
+	if (ts.isIdentifier(node.name)) return node.name.text === identifierName;
+	return ts.isObjectBindingPattern(node.name) && isReactObjectBindingName(node.name, identifierName);
+};
+const collectReactImportBindings = (sourceFile) => {
+	const namespaceNames = /* @__PURE__ */ new Set();
+	const useImportNames = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (ts.isImportDeclaration(statement)) {
+			if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+			if (statement.moduleSpecifier.text !== REACT_MODULE_SOURCE) continue;
+			const importClause = statement.importClause;
+			if (!importClause) continue;
+			if (importClause.name) namespaceNames.add(importClause.name.text);
+			const namedBindings = importClause.namedBindings;
+			if (!namedBindings) continue;
+			if (ts.isNamespaceImport(namedBindings)) {
+				namespaceNames.add(namedBindings.name.text);
+				continue;
+			}
+			for (const importSpecifier of namedBindings.elements) if (getImportedName(importSpecifier) === USE_IDENTIFIER) useImportNames.add(importSpecifier.name.text);
+			continue;
+		}
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) {
+			if (!declaration.initializer) continue;
+			if (!isReactRequireCall(declaration.initializer)) continue;
+			if (ts.isIdentifier(declaration.name)) {
+				namespaceNames.add(declaration.name.text);
+				continue;
+			}
+			if (ts.isObjectBindingPattern(declaration.name)) collectReactObjectBindingNames(declaration.name, useImportNames);
+		}
+	}
+	return {
+		namespaceNames,
+		useImportNames
+	};
+};
+const findBindingElement = (identifier) => {
+	let currentNode = identifier.parent;
+	while (currentNode) {
+		if (ts.isBindingElement(currentNode)) return currentNode;
+		if (ts.isVariableDeclaration(currentNode) || ts.isParameter(currentNode)) return null;
+		currentNode = currentNode.parent;
+	}
+	return null;
+};
+const declarationBindsIdentifier = (node, identifierName) => {
+	if (ts.isVariableDeclaration(node) || ts.isParameter(node)) return bindingNameHasIdentifier(node.name, identifierName);
+	if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) return node.name?.text === identifierName;
+	return false;
+};
+const isScopeBoundary = (node) => ts.isFunctionLike(node) || ts.isClassLike(node) || ts.isBlock(node) || ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node) || ts.isCatchClause(node) || ts.isSourceFile(node) || ts.isModuleBlock(node);
+const scopeContainsNonImportBinding = (node, scopeNode, identifierName) => {
+	if (isReactRequireBindingDeclaration(node, identifierName)) return false;
+	if (declarationBindsIdentifier(node, identifierName)) return true;
+	if (node !== scopeNode && isScopeBoundary(node)) return false;
+	let didFindBinding = false;
+	ts.forEachChild(node, (child) => {
+		if (didFindBinding) return;
+		didFindBinding = scopeContainsNonImportBinding(child, scopeNode, identifierName);
+	});
+	return didFindBinding;
+};
+const isIdentifierShadowedByLocalBinding = (identifier, sourceFile) => {
+	let currentNode = identifier.parent;
+	while (currentNode) {
+		if (isScopeNode(currentNode)) {
+			if (scopeContainsNonImportBinding(currentNode, currentNode, identifier.text)) return true;
+		}
+		if (currentNode === sourceFile) return false;
+		currentNode = currentNode.parent;
+	}
+	return false;
+};
+const isReactNamespaceExpression = (expression, reactImportBindings, sourceFile, visitedDeclarations) => {
+	const unwrappedExpression = unwrapExpression(expression);
+	if (isReactRequireCall(unwrappedExpression)) return true;
+	if (!ts.isIdentifier(unwrappedExpression)) return false;
+	if (reactImportBindings.namespaceNames.has(unwrappedExpression.text) && !isIdentifierShadowedByLocalBinding(unwrappedExpression, sourceFile)) return true;
+	return resolveIdentifierBinding(unwrappedExpression, reactImportBindings, sourceFile, visitedDeclarations)?.isReactNamespaceBinding ?? false;
+};
+const isReactUseExpression = (expression, reactImportBindings, sourceFile, visitedDeclarations) => {
+	if (!expression) return false;
+	const unwrappedExpression = unwrapExpression(expression);
+	if (ts.isIdentifier(unwrappedExpression)) {
+		if (reactImportBindings.useImportNames.has(unwrappedExpression.text) && !isIdentifierShadowedByLocalBinding(unwrappedExpression, sourceFile)) return true;
+		if (unwrappedExpression.text === USE_IDENTIFIER) return false;
+		return resolveIdentifierBinding(unwrappedExpression, reactImportBindings, sourceFile, visitedDeclarations)?.isReactUseBinding ?? false;
+	}
+	if (ts.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === USE_IDENTIFIER && isReactNamespaceExpression(unwrappedExpression.expression, reactImportBindings, sourceFile, visitedDeclarations)) return true;
+	if (ts.isElementAccessExpression(unwrappedExpression) && ts.isStringLiteral(unwrappedExpression.argumentExpression) && unwrappedExpression.argumentExpression.text === USE_IDENTIFIER) return isReactNamespaceExpression(unwrappedExpression.expression, reactImportBindings, sourceFile, visitedDeclarations);
+	return false;
+};
+const isReactUseObjectBinding = (identifier, variableDeclaration, reactImportBindings, sourceFile, visitedDeclarations) => {
+	const bindingElement = findBindingElement(identifier);
+	if (!bindingElement) return false;
+	if (!ts.isObjectBindingPattern(bindingElement.parent)) return false;
+	if (!variableDeclaration.initializer) return false;
+	if (!isReactNamespaceExpression(variableDeclaration.initializer, reactImportBindings, sourceFile, visitedDeclarations)) return false;
+	return isReactUseObjectBindingElement(bindingElement);
+};
+const getVariableDeclarationResolution = (variableDeclaration, identifierName, reactImportBindings, sourceFile, visitedDeclarations) => {
+	const bindingIdentifier = findBindingIdentifier(variableDeclaration.name, identifierName);
+	if (!bindingIdentifier) return null;
+	if (visitedDeclarations.has(variableDeclaration)) return null;
+	const nestedVisitedDeclarations = new Set(visitedDeclarations);
+	nestedVisitedDeclarations.add(variableDeclaration);
+	return {
+		isReactNamespaceBinding: ts.isIdentifier(variableDeclaration.name) && variableDeclaration.initializer !== void 0 && isReactNamespaceExpression(variableDeclaration.initializer, reactImportBindings, sourceFile, new Set(nestedVisitedDeclarations)),
+		isReactUseBinding: isReactUseExpression(variableDeclaration.initializer, reactImportBindings, sourceFile, new Set(nestedVisitedDeclarations)) || isReactUseObjectBinding(bindingIdentifier, variableDeclaration, reactImportBindings, sourceFile, new Set(nestedVisitedDeclarations))
+	};
+};
+const getImportResolution = (node, identifierName) => {
+	if (ts.isImportSpecifier(node) && node.name.text === identifierName) return getModuleSource(node) === REACT_MODULE_SOURCE && getImportedName(node) === USE_IDENTIFIER ? REACT_USE_BINDING_RESOLUTION : LOCAL_BINDING_RESOLUTION;
+	if (ts.isNamespaceImport(node) && node.name.text === identifierName) return getModuleSource(node) === REACT_MODULE_SOURCE ? REACT_NAMESPACE_BINDING_RESOLUTION : LOCAL_BINDING_RESOLUTION;
+	if (ts.isImportClause(node) && node.name?.text === identifierName) return getModuleSource(node) === REACT_MODULE_SOURCE ? REACT_NAMESPACE_BINDING_RESOLUTION : LOCAL_BINDING_RESOLUTION;
+	return null;
+};
+const getDeclarationResolution = (node, identifierName, reactImportBindings, sourceFile, visitedDeclarations) => {
+	const importResolution = getImportResolution(node, identifierName);
+	if (importResolution) return importResolution;
+	if (ts.isVariableDeclaration(node)) return getVariableDeclarationResolution(node, identifierName, reactImportBindings, sourceFile, visitedDeclarations);
+	if (ts.isParameter(node)) return bindingNameHasIdentifier(node.name, identifierName) ? LOCAL_BINDING_RESOLUTION : null;
+	if (ts.isFunctionDeclaration(node) && node.name?.text === identifierName) return LOCAL_BINDING_RESOLUTION;
+	if (ts.isClassDeclaration(node) && node.name?.text === identifierName) return LOCAL_BINDING_RESOLUTION;
+	return null;
+};
+const isNestedScopeBoundary = (node, scopeNode) => node !== scopeNode && isScopeBoundary(node);
+const findResolutionInSubtree = (node, scopeNode, identifierName, reactImportBindings, sourceFile, visitedDeclarations) => {
+	const declarationResolution = getDeclarationResolution(node, identifierName, reactImportBindings, sourceFile, visitedDeclarations);
+	if (declarationResolution) return declarationResolution;
+	if (isNestedScopeBoundary(node, scopeNode)) return null;
+	let resolution = null;
+	ts.forEachChild(node, (child) => {
+		if (resolution) return;
+		resolution = findResolutionInSubtree(child, scopeNode, identifierName, reactImportBindings, sourceFile, visitedDeclarations);
+	});
+	return resolution;
+};
+const findResolutionInFunctionParameters = (node, identifierName, reactImportBindings) => {
+	if (!ts.isFunctionLike(node)) return null;
+	for (const parameter of node.parameters) {
+		const parameterResolution = getDeclarationResolution(parameter, identifierName, reactImportBindings, parameter.getSourceFile(), /* @__PURE__ */ new Set());
+		if (parameterResolution) return parameterResolution;
+	}
+	return null;
+};
+const findResolutionInScope = (scopeNode, identifierName, reactImportBindings, sourceFile, visitedDeclarations) => {
+	const parameterResolution = findResolutionInFunctionParameters(scopeNode, identifierName, reactImportBindings);
+	if (parameterResolution) return parameterResolution;
+	let resolution = null;
+	ts.forEachChild(scopeNode, (child) => {
+		if (resolution) return;
+		resolution = findResolutionInSubtree(child, scopeNode, identifierName, reactImportBindings, sourceFile, visitedDeclarations);
+	});
+	return resolution;
+};
+const isScopeNode = isScopeBoundary;
+const resolveIdentifierBinding = (identifier, reactImportBindings, sourceFile, visitedDeclarations = /* @__PURE__ */ new Set()) => {
+	let currentNode = identifier.parent;
+	while (currentNode) {
+		if (isScopeNode(currentNode)) {
+			const resolution = findResolutionInScope(currentNode, identifier.text, reactImportBindings, sourceFile, visitedDeclarations);
+			if (resolution) return resolution;
+		}
+		currentNode = currentNode.parent;
+	}
+	return null;
+};
+const isUseCallIdentifier = (node) => node.text === USE_IDENTIFIER && ts.isCallExpression(node.parent) && node.parent.expression === node;
+const findUseCallIdentifier = (sourceFile, useOffset) => {
+	let matchedIdentifier = null;
+	const visit = (node) => {
+		if (matchedIdentifier) return;
+		if (ts.isIdentifier(node) && isUseCallIdentifier(node) && node.getStart(sourceFile) === useOffset) {
+			matchedIdentifier = node;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return matchedIdentifier;
+};
+const resolveUseCallBinding = (sourceText, filename, utf8Offset) => {
+	const sourceFile = ts.createSourceFile(filename, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(filename));
+	const useIdentifier = findUseCallIdentifier(sourceFile, getUtf16Offset(sourceText, utf8Offset));
+	if (!useIdentifier) return null;
+	return resolveIdentifierBinding(useIdentifier, collectReactImportBindings(sourceFile), sourceFile);
+};
+const RULES_OF_HOOKS_CODE = "react-hooks(rules-of-hooks)";
+const REACT_HOOK_USE_MESSAGE_PREFIX = "React Hook \"use\"";
+const shouldSuppressLocalUseHookDiagnostic = (diagnostic, rootDirectory) => {
+	if (diagnostic.code !== RULES_OF_HOOKS_CODE) return false;
+	if (!diagnostic.message.startsWith(REACT_HOOK_USE_MESSAGE_PREFIX)) return false;
+	const primaryLabel = diagnostic.labels[0];
+	if (!primaryLabel) return false;
+	const absolutePath = path.isAbsolute(diagnostic.filename) ? diagnostic.filename : path.join(rootDirectory, diagnostic.filename);
+	let sourceText;
+	try {
+		sourceText = fs.readFileSync(absolutePath, "utf-8");
+	} catch {
+		return false;
+	}
+	const bindingResolution = resolveUseCallBinding(sourceText, absolutePath, primaryLabel.span.offset);
+	return bindingResolution !== null && !bindingResolution.isReactUseBinding;
+};
+const getRuleRecommendation = (ruleName) => reactDoctorPlugin.rules[ruleName]?.recommendation;
+const getRuleCategory = (ruleName) => reactDoctorPlugin.rules[ruleName]?.category;
+const esmRequire = createRequire(import.meta.url);
+const PLUGIN_CATEGORY_MAP = {
+	react: "Correctness",
+	"react-hooks": "Correctness",
+	"react-hooks-js": "React Compiler",
+	"react-doctor": "Other",
+	"jsx-a11y": "Accessibility",
+	effect: "State & Effects",
+	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 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,
+		help: message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || help
+	};
+	return {
+		message: message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || message,
+		help: help || getRuleRecommendation(rule) || ""
+	};
+};
+const parseRuleCode = (code) => {
+	const match = code.match(/^(.+)\((.+)\)$/);
+	if (!match) return {
+		plugin: "unknown",
+		rule: code
+	};
+	return {
+		plugin: match[1].replace(/^eslint-plugin-/, ""),
+		rule: match[2]
+	};
+};
+const resolveOxlintBinary = () => {
+	const oxlintMainPath = esmRequire.resolve("oxlint");
+	const oxlintPackageDirectory = path.resolve(path.dirname(oxlintMainPath), "..");
+	return path.join(oxlintPackageDirectory, "bin", "oxlint");
+};
+const resolvePluginPath = () => esmRequire.resolve("oxlint-plugin-react-doctor");
+const resolveDiagnosticCategory = (plugin, rule) => getRuleCategory(rule) ?? lookupOwnString(PLUGIN_CATEGORY_MAP, plugin) ?? "Other";
+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;
+	}
+	return sanitized;
+})();
+const OXLINT_SPAWN_TIMEOUT_MS = 6e4;
+const spawnOxlint = (args, rootDirectory, nodeBinaryPath) => new Promise((resolve, reject) => {
+	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 = [];
+	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 ${OXLINT_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)" : "";
+			const detail = stderrOutput ? `: ${stderrOutput}` : "";
+			reject(/* @__PURE__ */ new Error(`oxlint was killed by ${signal}${hint}${detail}`));
+			return;
+		}
+		const output = Buffer.concat(stdoutBuffers).toString("utf-8").trim();
+		if (!output) {
+			const stderrOutput = Buffer.concat(stderrBuffers).toString("utf-8").trim();
+			if (stderrOutput) {
+				reject(/* @__PURE__ */ new Error(`Failed to run oxlint: ${stderrOutput}`));
+				return;
+			}
+		}
+		resolve(output);
+	});
+});
+const isSplittableOxlintBatchError = (error) => {
+	if (!(error instanceof Error)) return false;
+	return error.message.includes("did not return within") || error.message.includes("output exceeded") || error.message.includes("out of memory");
+};
+const isOxlintOutput = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return Array.isArray(candidate.diagnostics);
+};
+const parseOxlintOutput = (stdout, rootDirectory) => {
+	if (!stdout) return [];
+	const jsonStart = stdout.indexOf("{");
+	const sanitizedStdout = jsonStart > 0 ? stdout.slice(jsonStart) : stdout;
+	let parsed;
+	try {
+		parsed = JSON.parse(sanitizedStdout);
+	} catch {
+		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 && SOURCE_FILE_PATTERN.test(diagnostic.filename) && !shouldSuppressLocalUseHookDiagnostic(diagnostic, rootDirectory)).map((diagnostic) => {
+		const { plugin, rule } = parseRuleCode(diagnostic.code);
+		const primaryLabel = diagnostic.labels[0];
+		const cleaned = cleanDiagnosticMessage(diagnostic.message, diagnostic.help, plugin, rule);
+		return {
+			filePath: diagnostic.filename,
+			plugin,
+			rule,
+			severity: diagnostic.severity,
+			message: cleaned.message,
+			help: cleaned.help,
+			url: diagnostic.url,
+			line: primaryLabel?.span.line ?? 0,
+			column: primaryLabel?.span.column ?? 0,
+			category: resolveDiagnosticCategory(plugin, rule)
+		};
+	});
+};
+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 = [];
+	const missingMetadata = [];
+	for (const fullKey of ALL_REACT_DOCTOR_RULE_KEYS) {
+		const ruleName = fullKey.replace(/^react-doctor\//, "");
+		if (!getRuleCategory(ruleName)) missingCategory.push(fullKey);
+		if (!getRuleRecommendation(ruleName)) missingHelp.push(fullKey);
+		if (FRAMEWORK_SPECIFIC_RULE_KEYS.has(fullKey) && !reactDoctorPlugin.rules[ruleName]?.requires) missingMetadata.push(fullKey);
+	}
+	if (missingCategory.length > 0 || missingHelp.length > 0 || missingMetadata.length > 0) {
+		const detail = [
+			missingCategory.length > 0 ? `Missing rule categories (add to defineRule call): ${missingCategory.join(", ")}` : null,
+			missingHelp.length > 0 ? `Missing rule recommendations (add to defineRule call): ${missingHelp.join(", ")}` : null,
+			missingMetadata.length > 0 ? `Missing rule \`requires\` capability gate (add to defineRule call): ${missingMetadata.join(", ")}` : null
+		].filter((entry) => entry !== null).join("; ");
+		console.warn(`[react-doctor] rule-registration drift: ${detail}`);
+	}
+};
+const runOxlint = async (options) => {
+	const { rootDirectory, project, includePaths, nodeBinaryPath = process.execPath, customRulesOnly = false, respectInlineDisables = true, adoptExistingLintConfig = true, ignoredTags = /* @__PURE__ */ new Set(), onPartialFailure } = 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,
+		project,
+		customRulesOnly,
+		extendsPaths,
+		ignoredTags
+	});
+	const restoreDisableDirectives = respectInlineDisables ? () => {} : neutralizeDisableDirectives(rootDirectory, includePaths);
+	try {
+		const baseArgs = [
+			resolveOxlintBinary(),
+			"-c",
+			configPath,
+			"--format",
+			"json"
+		];
+		if (project.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 = batchIncludePaths(baseArgs, includePaths !== void 0 ? includePaths : listSourceFiles(rootDirectory));
+		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 = [];
+			const droppedFiles = [];
+			const spawnLintBatch = async (batch) => {
+				const batchArgs = [...baseArgs, ...batch];
+				try {
+					return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath), rootDirectory);
+				} catch (error) {
+					if (!isSplittableOxlintBatchError(error)) throw error;
+					if (batch.length <= 1) {
+						droppedFiles.push(...batch);
+						return [];
+					}
+					const splitIndex = Math.ceil(batch.length / 2);
+					return [...await spawnLintBatch(batch.slice(0, splitIndex)), ...await spawnLintBatch(batch.slice(splitIndex))];
+				}
+			};
+			for (const batch of fileBatches) allDiagnostics.push(...await spawnLintBatch(batch));
+			if (droppedFiles.length > 0 && onPartialFailure) {
+				const previewCount = 3;
+				const previewFiles = droppedFiles.slice(0, previewCount).join(", ");
+				const remainderHint = droppedFiles.length > previewCount ? `, +${droppedFiles.length - previewCount} more` : "";
+				onPartialFailure(`${droppedFiles.length} file(s) exceeded the ${OXLINT_SPAWN_TIMEOUT_MS / 1e3}s per-batch oxlint budget and were skipped (${previewFiles}${remainderHint})`);
+			}
+			return dedupeDiagnostics(allDiagnostics);
+		};
+		writeOxlintConfig(config);
+		try {
+			return await spawnLintBatches();
+		} catch (error) {
+			if (extendsPaths.length === 0) throw error;
+			writeOxlintConfig(createOxlintConfig({
+				pluginPath,
+				project,
+				customRulesOnly,
+				extendsPaths: [],
+				ignoredTags
+			}));
+			return await spawnLintBatches();
+		}
+	} finally {
+		restoreDisableDirectives();
+		fs.rmSync(configDirectory, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+//#endregion
+//#region src/index.ts
+const clearCaches = () => {
+	clearProjectCache();
+	clearConfigCache();
+	clearPackageJsonCache();
+	clearIgnorePatternsCache();
+	clearAutoSuppressionCaches();
+};
+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 EMPTY_DIAGNOSTICS = [];
+const diagnose = async (directory, options = {}) => {
+	const startTime = globalThis.performance.now();
+	const requestedDirectory = path.resolve(directory);
+	const initialLoadedConfig = loadConfigWithSource(requestedDirectory);
+	const directoryAfterRedirect = resolveConfigRootDir(initialLoadedConfig?.config ?? null, initialLoadedConfig?.sourceDirectory ?? null) ?? requestedDirectory;
+	const resolvedDirectory = resolveDiagnoseTarget(directoryAfterRedirect);
+	if (!resolvedDirectory) throw new ProjectNotFoundError(directoryAfterRedirect);
+	const userConfig = initialLoadedConfig?.config ?? loadConfigWithSource(resolvedDirectory)?.config ?? null;
+	const includePaths = options.includePaths ?? [];
+	const isDiffMode = includePaths.length > 0;
+	const projectInfo = discoverProject(resolvedDirectory);
+	if (!projectInfo.reactVersion) throw new NoReactDependencyError(resolvedDirectory);
+	const lintIncludePaths = computeJsxIncludePaths(includePaths) ?? resolveLintIncludePaths(resolvedDirectory, userConfig);
+	const readFileLinesSync = createNodeReadFileLinesSync(resolvedDirectory);
+	const effectiveLint = options.lint ?? userConfig?.lint ?? true;
+	const effectiveRespectInlineDisables = options.respectInlineDisables ?? userConfig?.respectInlineDisables ?? true;
+	const ignoredTags = new Set(userConfig?.ignore?.tags ?? []);
+	const diagnostics = combineDiagnostics({
+		lintDiagnostics: effectiveLint ? await runOxlint({
+			rootDirectory: resolvedDirectory,
+			project: projectInfo,
+			includePaths: lintIncludePaths,
+			customRulesOnly: userConfig?.customRulesOnly ?? false,
+			respectInlineDisables: effectiveRespectInlineDisables,
+			adoptExistingLintConfig: userConfig?.adoptExistingLintConfig ?? true,
+			ignoredTags
+		}).catch((error) => {
+			console.error("Lint failed:", error);
+			return EMPTY_DIAGNOSTICS;
+		}) : EMPTY_DIAGNOSTICS,
+		directory: resolvedDirectory,
+		isDiffMode,
+		userConfig,
+		readFileLinesSync,
+		respectInlineDisables: effectiveRespectInlineDisables
+	});
+	const elapsedMilliseconds = globalThis.performance.now() - startTime;
+	return {
+		diagnostics,
+		score: await calculateScore(diagnostics),
+		project: projectInfo,
+		elapsedMilliseconds
+	};
+};
+//#endregion
+export { AmbiguousProjectError, NoReactDependencyError, PackageJsonNotFoundError, ProjectNotFoundError, ReactDoctorError, buildJsonReport, buildJsonReportError, clearCaches, diagnose, filterSourceFiles, getDiffInfo, isReactDoctorError, summarizeDiagnostics, toJsonReport };
+
+//# sourceMappingURL=index.js.map