react-doctor 0.5.8-dev.7f9e7f4 → 0.5.8-dev.8232e96

package/dist/lsp.js

@@ -6,7 +6,7 @@ import os from "node:os";
 import * as Path from "node:path";
 import path from "node:path";
 import * as NodeChildProcess from "node:child_process";
-import { spawn, spawnSync } from "node:child_process";
+import { execFileSync, spawn, spawnSync } from "node:child_process";
 import * as ts from "typescript";
 import reactDoctorPlugin, { ALL_REACT_DOCTOR_RULE_KEYS, CROSS_FILE_RULE_IDS, FRAMEWORK_SPECIFIC_RULE_KEYS, MOTION_LIBRARY_PACKAGES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, classifySecurityScanFile, shouldReadSecurityScanContent } from "oxlint-plugin-react-doctor";
 import { parseJSON5 } from "confbox";
@@ -6021,7 +6021,7 @@ const composePassthrough = /* @__PURE__ */ dual(2, (left, right) => (input) => {
 * @since 2.0.0
 */
 const Scheduler = /* @__PURE__ */ Reference("effect/Scheduler", { defaultValue: () => new MixedScheduler() });
-const setImmediate = "setImmediate" in globalThis ? (f) => {
+const setImmediate$1 = "setImmediate" in globalThis ? (f) => {
 	const timer = globalThis.setImmediate(f);
 	return () => globalThis.clearImmediate(timer);
 } : (f) => {
@@ -6065,7 +6065,7 @@ var PriorityBuckets = class {
 var MixedScheduler = class {
 	executionMode;
 	setImmediate;
-	constructor(executionMode = "async", setImmediateFn = setImmediate) {
+	constructor(executionMode = "async", setImmediateFn = setImmediate$1) {
 		this.executionMode = executionMode;
 		this.setImmediate = setImmediateFn;
 	}
@@ -6090,7 +6090,7 @@ var MixedSchedulerDispatcher = class {
 	tasks = /* @__PURE__ */ new PriorityBuckets();
 	running = void 0;
 	setImmediate;
-	constructor(setImmediateFn = setImmediate) {
+	constructor(setImmediateFn = setImmediate$1) {
 		this.setImmediate = setImmediateFn;
 	}
 	/**
@@ -19400,6 +19400,15 @@ var JsonReportV1 = class extends Class("JsonReportV1")({
 	ok: Boolean$1,
 	directory: String$1,
 	mode: JsonReportMode,
+	/**
+	* True when a `changed` (compare) run was intended but the base couldn't be
+	* resolved — a shallow CI checkout with no merge base, or a failed base/head
+	* lint. The report then lists every finding in the changed files (mode
+	* downgrades to `diff`, the `baseline` block is dropped, the CI gate is
+	* skipped) rather than only the ones the change introduced. Absent on a
+	* successful `baseline` run (`schemaVersion: 2`) and on non-compare scopes.
+	*/
+	baselineDegraded: optional(Boolean$1),
 	diff: NullOr(JsonReportDiffInfo),
 	projects: ArraySchema(JsonReportProjectEntry),
 	diagnostics: ArraySchema(Diagnostic),
@@ -32816,12 +32825,31 @@ const GENERATED_BUNDLE_FILE_PATTERN = /\.(iife|umd|global|min)\.m?js$/i;
 const MINIFIED_SNIFF_BYTES = 65536;
 const GIT_LS_FILES_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
 const IGNORED_DIRECTORIES = new Set([
+	".angular",
+	".astro",
+	".cache",
+	".contentlayer",
+	".direnv",
+	".docusaurus",
+	".expo",
+	".firebase",
 	".git",
+	".gradle",
+	".hg",
 	".next",
 	".nuxt",
+	".nx",
 	".output",
+	".parcel-cache",
+	".serverless",
 	".svelte-kit",
+	".svn",
+	".terraform",
 	".turbo",
+	".venv",
+	".vercel",
+	".wrangler",
+	".yarn",
 	"build",
 	"coverage",
 	"dist",
@@ -32829,6 +32857,142 @@ const IGNORED_DIRECTORIES = new Set([
 	"out",
 	"storybook-static"
 ]);
+const JSX_FILE_PATTERN = /\.(tsx|jsx)$/;
+const MILLISECONDS_PER_SECOND = 1e3;
+const SCORE_API_URL = "https://www.react.doctor/api/score";
+const FETCH_TIMEOUT_MS = 1e4;
+const GITHUB_VIEWER_PERMISSION_TIMEOUT_MS = 2e3;
+const SPAWN_ARGS_MAX_LENGTH_CHARS = 24e3;
+const SPAWN_ARGS_MAX_LENGTH_CHARS_POSIX = 15e5;
+const SPAWN_ARGS_MAX_LENGTH_CHARS_DARWIN = 8e5;
+const NODE_VERSION_PROBE_TIMEOUT_MS = 5e3;
+const PER_WORKER_MEM_BUDGET_BYTES = 1024 * 1024 * 1024;
+const DEFAULT_BRANCH_CANDIDATES = ["main", "master"];
+const ADOPTABLE_LINT_CONFIG_FILENAMES = [".oxlintrc.json", ".eslintrc.json"];
+const GIT_SHOW_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+const ES_TARGET_YEAR_BY_NAME = {
+	es3: 1999,
+	es5: 2009,
+	es6: 2015,
+	es2015: 2015,
+	es2016: 2016,
+	es2017: 2017,
+	es2018: 2018,
+	es2019: 2019,
+	es2020: 2020,
+	es2021: 2021,
+	es2022: 2022,
+	es2023: 2023,
+	es2024: 2024,
+	es2025: 2025,
+	esnext: 9999
+};
+/**
+* tsconfig filenames probed when resolving a project's TypeScript
+* compiler options — the root config first, then a monorepo base config.
+*/
+const TSCONFIG_FILENAMES = ["tsconfig.json", "tsconfig.base.json"];
+/**
+* Project-config files that `StagedFiles.materialize` copies into
+* the temp directory alongside staged sources so oxlint resolves
+* `tsconfig` / `package.json` / lint configs the same way it would
+* in the working tree. Hoisted out of the staged-files helper so
+* the constant lives next to the rest of the IO budget knobs.
+*/
+const STAGED_FILES_PROJECT_CONFIG_FILENAMES = [
+	"tsconfig.json",
+	"tsconfig.base.json",
+	"package.json",
+	"doctor.config.ts",
+	"doctor.config.mts",
+	"doctor.config.cts",
+	"doctor.config.js",
+	"doctor.config.mjs",
+	"doctor.config.cjs",
+	"doctor.config.json",
+	"doctor.config.jsonc",
+	"oxlint.json",
+	".oxlintrc.json"
+];
+const CONFIG_FINGERPRINT_FILENAMES = [
+	"doctor.config.ts",
+	"doctor.config.mts",
+	"doctor.config.cts",
+	"doctor.config.js",
+	"doctor.config.mjs",
+	"doctor.config.cjs",
+	"doctor.config.json",
+	"doctor.config.jsonc",
+	"react-doctor.config.json",
+	"package.json",
+	"pnpm-workspace.yaml",
+	"tsconfig.json",
+	"tsconfig.base.json",
+	".oxlintrc.json",
+	".eslintrc.json",
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"yarn.lock",
+	"bun.lock",
+	"bun.lockb",
+	".gitignore"
+];
+const OXLINT_OUTPUT_MAX_BYTES = 50 * 1024 * 1024;
+const OXLINT_SPAWN_TIMEOUT_MS = 6e4;
+const NODE_COMPILE_CACHE_DIR_NAME = "node-compile-cache";
+const DEAD_CODE_WORKER_TIMEOUT_MS = 12e4;
+const OXLINT_SPLIT_TOTAL_BUDGET_MS = 18e4;
+const DEAD_CODE_PHASE_TIMEOUT_MS = 15e4;
+const LINT_PHASE_TIMEOUT_MS = 3e5;
+const SCAN_TOTAL_DEADLINE_MS = 9e5;
+const DEAD_CODE_WORKER_MAX_OLD_SPACE_MB = 8192;
+const DEAD_CODE_WORKER_MEM_BUDGET_BYTES = 2 * 1024 * 1024 * 1024;
+const DEAD_CODE_TIMEOUT_CEILING_MS = 6e5;
+const DEAD_CODE_PHASE_TIMEOUT_OVER_WORKER_MS = 3e4;
+const DEAD_CODE_OVERLAP_PARSE_SHARE = .4;
+const RECOMMENDED_PNPM_MINIMUM_RELEASE_AGE_MINUTES = 10080;
+const REACT_SERVER_DOM_PACKAGES = [
+	"react-server-dom-webpack",
+	"react-server-dom-parcel",
+	"react-server-dom-turbopack"
+];
+const REACT_BLOG_RSC_ADVISORY_URL = "https://react.dev/blog/2025/12/03/critical-security-vulnerability-in-react-server-components";
+const VERCEL_NEXTJS_SECURITY_RELEASE_URL = "https://vercel.com/changelog/next-js-may-2026-security-release";
+const DIAGNOSTIC_CATEGORY_BUCKETS = [
+	"Security",
+	"Bugs",
+	"Performance",
+	"Accessibility",
+	"Maintainability"
+];
+const APP_ONLY_RULE_KEYS = new Set([
+	"react-hooks-js/static-components",
+	"react-doctor/no-render-prop-children",
+	"react-doctor/prefer-explicit-variants"
+]);
+const COMPILER_CLEANUP_BUCKET = "compiler-cleanup";
+const COMPILER_CLEANUP_RULE_KEYS = new Set(["react-doctor/react-compiler-no-manual-memoization"]);
+const ROOT_CAUSE_GROUPABLE_RULE_KEYS = new Set([
+	"react-doctor/no-derived-state",
+	"react-doctor/no-derived-state-effect",
+	"react-doctor/no-derived-useState",
+	"react-doctor/no-adjust-state-on-prop-change",
+	"react-doctor/no-reset-all-state-on-prop-change"
+]);
+const MAX_GLOB_PATTERN_LENGTH_CHARS = 1024;
+const CONFIG_CACHE_TTL_MS = 300 * 1e3;
+const SOCKET_FREE_PURL_API_BASE = "https://firewall-api.socket.dev/purl";
+const SOCKET_PACKAGE_PAGE_BASE = "https://socket.dev/npm/package";
+const SOCKET_FREE_USER_AGENT = "react-doctor-supply-chain";
+const FILE_LINT_CACHE_FILENAME = "file-lint-cache.json";
+const FILE_LINT_CACHE_MAX_FILE_COUNT = 5e4;
+const SUPPLY_CHAIN_PLUGIN = "socket";
+const SUPPLY_CHAIN_RULE = "low-supply-chain-score";
+const SUPPLY_CHAIN_CATEGORY = "Security";
+const SUPPLY_CHAIN_OVERLAP_TIMEOUT_MS = 9e4;
+const SUPPLY_CHAIN_CACHE_SUBDIR = "supply-chain";
+const SUPPLY_CHAIN_IGNORED_PACKAGES = new Set(["next"]);
+const hasIgnoredPathSegment = (relativePath) => relativePath.split(/[/\\]/).slice(0, -1).some((segment) => IGNORED_DIRECTORIES.has(segment));
 const isLintableSourceFile = (filePath) => SOURCE_FILE_PATTERN.test(filePath) && !GENERATED_BUNDLE_FILE_PATTERN.test(filePath);
 const isMinifiedSource = (absolutePath) => {
 	let fileDescriptor;
@@ -32885,23 +33049,38 @@ const readDirectoryEntries = (directoryPath) => {
 		throw error;
 	}
 };
-const countSourceFilesViaFilesystem = (rootDirectory) => {
-	let count = 0;
+function* walkSourceTreeFiles(rootDirectory) {
 	const stack = [rootDirectory];
 	while (stack.length > 0) {
 		const currentDirectory = stack.pop();
-		const entries = readDirectoryEntries(currentDirectory);
-		for (const entry of entries) {
+		if (currentDirectory === void 0) continue;
+		for (const entry of readDirectoryEntries(currentDirectory)) {
+			const absolutePath = Path.join(currentDirectory, entry.name);
 			if (entry.isDirectory()) {
-				if (!entry.name.startsWith(".") && !IGNORED_DIRECTORIES.has(entry.name)) stack.push(Path.join(currentDirectory, entry.name));
+				if (!IGNORED_DIRECTORIES.has(entry.name)) stack.push(absolutePath);
 				continue;
 			}
-			if (entry.isFile() && isLintableSourceFile(entry.name) && !isLargeMinifiedFile(Path.join(currentDirectory, entry.name))) count++;
+			if (entry.isFile()) yield {
+				absolutePath,
+				name: entry.name
+			};
 		}
 	}
-	return count;
+}
+const collectSizedSourceFiles = (rootDirectory, relativePaths) => {
+	const entries = [];
+	for (const relativePath of relativePaths) {
+		const absolutePath = Path.resolve(rootDirectory, relativePath);
+		const sizeBytes = statSourceFileSize(absolutePath);
+		if (isLargeMinifiedFile(absolutePath, sizeBytes)) continue;
+		entries.push({
+			path: relativePath,
+			sizeBytes: sizeBytes ?? 0
+		});
+	}
+	return entries;
 };
-const countSourceFilesViaGit = (rootDirectory) => {
+const listSourceFilesViaGit = (rootDirectory) => {
 	const result = spawnSync("git", [
 		"ls-files",
 		"-z",
@@ -32914,9 +33093,16 @@ const countSourceFilesViaGit = (rootDirectory) => {
 		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 && isLintableSourceFile(filePath) && !isLargeMinifiedFile(Path.resolve(rootDirectory, filePath))).length;
+	return result.stdout.split("\0").filter((filePath) => filePath.length > 0 && isLintableSourceFile(filePath) && !hasIgnoredPathSegment(filePath));
+};
+const listSourceFilesViaFilesystem = (rootDirectory) => {
+	const filePaths = [];
+	for (const { absolutePath, name } of walkSourceTreeFiles(rootDirectory)) if (isLintableSourceFile(name)) filePaths.push(Path.relative(rootDirectory, absolutePath).replace(/\\/g, "/"));
+	return filePaths;
 };
-const countSourceFiles = (rootDirectory) => countSourceFilesViaGit(rootDirectory) ?? countSourceFilesViaFilesystem(rootDirectory);
+const listSourceFilesWithSize = (rootDirectory) => collectSizedSourceFiles(rootDirectory, (listSourceFilesViaGit(rootDirectory) ?? listSourceFilesViaFilesystem(rootDirectory)).sort());
+const listSourceFiles = (rootDirectory) => listSourceFilesWithSize(rootDirectory).map((entry) => entry.path);
+const countSourceFiles = (rootDirectory) => listSourceFilesWithSize(rootDirectory).length;
 const cachedPackageJsons = /* @__PURE__ */ new Map();
 const clearPackageJsonCache = () => {
 	cachedPackageJsons.clear();
@@ -33725,136 +33911,6 @@ const resolveEffectiveReactMajor = (reactVersion, packageJson) => {
 	if (peerFloor === null) return hasUpperBoundOnlyPeerRange(peerReactRange) ? null : installedReactMajor;
 	return installedReactMajor !== null ? Math.min(installedReactMajor, peerFloor) : peerFloor;
 };
-const JSX_FILE_PATTERN = /\.(tsx|jsx)$/;
-const MILLISECONDS_PER_SECOND = 1e3;
-const SCORE_API_URL = "https://www.react.doctor/api/score";
-const FETCH_TIMEOUT_MS = 1e4;
-const GITHUB_VIEWER_PERMISSION_TIMEOUT_MS = 2e3;
-const PER_WORKER_MEM_BUDGET_BYTES = 1024 * 1024 * 1024;
-const DEFAULT_BRANCH_CANDIDATES = ["main", "master"];
-const ADOPTABLE_LINT_CONFIG_FILENAMES = [".oxlintrc.json", ".eslintrc.json"];
-const GIT_SHOW_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
-const ES_TARGET_YEAR_BY_NAME = {
-	es3: 1999,
-	es5: 2009,
-	es6: 2015,
-	es2015: 2015,
-	es2016: 2016,
-	es2017: 2017,
-	es2018: 2018,
-	es2019: 2019,
-	es2020: 2020,
-	es2021: 2021,
-	es2022: 2022,
-	es2023: 2023,
-	es2024: 2024,
-	es2025: 2025,
-	esnext: 9999
-};
-/**
-* tsconfig filenames probed when resolving a project's TypeScript
-* compiler options — the root config first, then a monorepo base config.
-*/
-const TSCONFIG_FILENAMES = ["tsconfig.json", "tsconfig.base.json"];
-/**
-* Project-config files that `StagedFiles.materialize` copies into
-* the temp directory alongside staged sources so oxlint resolves
-* `tsconfig` / `package.json` / lint configs the same way it would
-* in the working tree. Hoisted out of the staged-files helper so
-* the constant lives next to the rest of the IO budget knobs.
-*/
-const STAGED_FILES_PROJECT_CONFIG_FILENAMES = [
-	"tsconfig.json",
-	"tsconfig.base.json",
-	"package.json",
-	"doctor.config.ts",
-	"doctor.config.mts",
-	"doctor.config.cts",
-	"doctor.config.js",
-	"doctor.config.mjs",
-	"doctor.config.cjs",
-	"doctor.config.json",
-	"doctor.config.jsonc",
-	"oxlint.json",
-	".oxlintrc.json"
-];
-const CONFIG_FINGERPRINT_FILENAMES = [
-	"doctor.config.ts",
-	"doctor.config.mts",
-	"doctor.config.cts",
-	"doctor.config.js",
-	"doctor.config.mjs",
-	"doctor.config.cjs",
-	"doctor.config.json",
-	"doctor.config.jsonc",
-	"react-doctor.config.json",
-	"package.json",
-	"pnpm-workspace.yaml",
-	"tsconfig.json",
-	"tsconfig.base.json",
-	".oxlintrc.json",
-	".eslintrc.json",
-	"pnpm-lock.yaml",
-	"package-lock.json",
-	"yarn.lock",
-	"bun.lock",
-	"bun.lockb",
-	".gitignore"
-];
-const OXLINT_OUTPUT_MAX_BYTES = 50 * 1024 * 1024;
-const OXLINT_SPAWN_TIMEOUT_MS = 6e4;
-const NODE_COMPILE_CACHE_DIR_NAME = "node-compile-cache";
-const DEAD_CODE_WORKER_TIMEOUT_MS = 12e4;
-const OXLINT_SPLIT_TOTAL_BUDGET_MS = 18e4;
-const DEAD_CODE_PHASE_TIMEOUT_MS = 15e4;
-const LINT_PHASE_TIMEOUT_MS = 3e5;
-const SCAN_TOTAL_DEADLINE_MS = 9e5;
-const DEAD_CODE_WORKER_MAX_OLD_SPACE_MB = 8192;
-const DEAD_CODE_TIMEOUT_CEILING_MS = 6e5;
-const DEAD_CODE_PHASE_TIMEOUT_OVER_WORKER_MS = 3e4;
-const DEAD_CODE_OVERLAP_PARSE_SHARE = .4;
-const RECOMMENDED_PNPM_MINIMUM_RELEASE_AGE_MINUTES = 10080;
-const REACT_SERVER_DOM_PACKAGES = [
-	"react-server-dom-webpack",
-	"react-server-dom-parcel",
-	"react-server-dom-turbopack"
-];
-const REACT_BLOG_RSC_ADVISORY_URL = "https://react.dev/blog/2025/12/03/critical-security-vulnerability-in-react-server-components";
-const VERCEL_NEXTJS_SECURITY_RELEASE_URL = "https://vercel.com/changelog/next-js-may-2026-security-release";
-const DIAGNOSTIC_CATEGORY_BUCKETS = [
-	"Security",
-	"Bugs",
-	"Performance",
-	"Accessibility",
-	"Maintainability"
-];
-const APP_ONLY_RULE_KEYS = new Set([
-	"react-hooks-js/static-components",
-	"react-doctor/no-render-prop-children",
-	"react-doctor/prefer-explicit-variants"
-]);
-const COMPILER_CLEANUP_BUCKET = "compiler-cleanup";
-const COMPILER_CLEANUP_RULE_KEYS = new Set(["react-doctor/react-compiler-no-manual-memoization"]);
-const ROOT_CAUSE_GROUPABLE_RULE_KEYS = new Set([
-	"react-doctor/no-derived-state",
-	"react-doctor/no-derived-state-effect",
-	"react-doctor/no-derived-useState",
-	"react-doctor/no-adjust-state-on-prop-change",
-	"react-doctor/no-reset-all-state-on-prop-change"
-]);
-const MAX_GLOB_PATTERN_LENGTH_CHARS = 1024;
-const CONFIG_CACHE_TTL_MS = 300 * 1e3;
-const SOCKET_FREE_PURL_API_BASE = "https://firewall-api.socket.dev/purl";
-const SOCKET_PACKAGE_PAGE_BASE = "https://socket.dev/npm/package";
-const SOCKET_FREE_USER_AGENT = "react-doctor-supply-chain";
-const FILE_LINT_CACHE_FILENAME = "file-lint-cache.json";
-const FILE_LINT_CACHE_MAX_FILE_COUNT = 5e4;
-const SUPPLY_CHAIN_PLUGIN = "socket";
-const SUPPLY_CHAIN_RULE = "low-supply-chain-score";
-const SUPPLY_CHAIN_CATEGORY = "Security";
-const SUPPLY_CHAIN_OVERLAP_TIMEOUT_MS = 9e4;
-const SUPPLY_CHAIN_CACHE_SUBDIR = "supply-chain";
-const SUPPLY_CHAIN_IGNORED_PACKAGES = new Set(["next"]);
 const TSCONFIG_FILENAME = "tsconfig.json";
 const isRelativeExtendsValue = (extendsValue) => extendsValue.startsWith("./") || extendsValue.startsWith("../") || Path.isAbsolute(extendsValue);
 const ensureJsonExtension = (filePath) => Path.extname(filePath) === "" ? `${filePath}.json` : filePath;
@@ -34546,7 +34602,10 @@ for (const [legacyRuleKey, nativeRuleKey] of Object.entries(LEGACY_RULE_KEY_TO_N
 	NATIVE_RULE_KEY_TO_LEGACY_RULE_KEYS.set(nativeRuleKey, aliases);
 }
 const getLegacyRuleKeysForNative = (ruleKey) => NATIVE_RULE_KEY_TO_LEGACY_RULE_KEYS.get(ruleKey) ?? [];
-const canonicalizeRuleKey = (ruleKey) => LEGACY_RULE_KEY_TO_NATIVE_RULE_KEY[ruleKey] ?? ruleKey;
+const canonicalizeRuleKey = (ruleKey) => {
+	const nativeRuleKey = LEGACY_RULE_KEY_TO_NATIVE_RULE_KEY[ruleKey];
+	return typeof nativeRuleKey === "string" ? nativeRuleKey : ruleKey;
+};
 const isReactDoctorShortIdOf = (bareRuleKey, qualifiedRuleKey) => !bareRuleKey.includes("/") && qualifiedRuleKey === `react-doctor/${bareRuleKey}`;
 const isSameRuleKey = (candidateRuleKey, targetRuleKey) => {
 	const canonicalCandidate = canonicalizeRuleKey(candidateRuleKey);
@@ -34573,7 +34632,7 @@ const tokenizeRuleList = (ruleList) => {
 const FOREIGN_INLINE_DISABLE_PATTERN = /(?:\/\/|\/\*)[ \t]*(eslint|oxlint)-disable-(next-line|line)(?![\w-])([^\r\n]*)/;
 const FOREIGN_BLOCK_DISABLE_PATTERN = /\/\*[ \t]*(eslint|oxlint)-disable(?![\w-])([^*\r\n]*)/;
 const FOREIGN_BLOCK_ENABLE_PATTERN = /\/\*[ \t]*(?:eslint|oxlint)-enable(?![\w-])([^*\r\n]*)/;
-const buildHint = (tool, token, ruleId) => `oxlint matches plugin rules only by their full name, so \`${token}\` in your ${tool}-disable comment does not silence \`${ruleId}\` — change it to \`${ruleId}\`.`;
+const buildHint = (tool, token, ruleId) => `oxlint matches plugin rules only by their full name, so \`${token}\` in your ${tool}-disable comment does not silence \`${ruleId}\` — add \`${ruleId}\` to the comment (e.g. \`${token}, ${ruleId}\`).`;
 const tokenMisnamesRule = (token, ruleId) => token !== ruleId && isSameRuleKey(token, ruleId);
 const detectInlineNearMiss = (lines, diagnosticLineIndex, ruleId) => {
 	const candidates = [{
@@ -35049,6 +35108,7 @@ const collectStringSet = (values) => {
 	if (!Array.isArray(values)) return /* @__PURE__ */ new Set();
 	return new Set(values.filter((value) => typeof value === "string"));
 };
+const JSX_NO_UNDEF_IDENTIFIER_PATTERN = /^`([^`]+)`/;
 /**
 * Pre-compiles every stateful filter and returns a single
 * `apply(diagnostic)` closure that runs (in order):
@@ -35082,11 +35142,28 @@ const buildDiagnosticPipeline = (input) => {
 	const compiledOverrides = compileIgnoreOverrides(userConfig);
 	const textComponentNames = collectStringSet(userConfig?.textComponents);
 	const rawTextWrapperComponentNames = collectStringSet(userConfig?.rawTextWrapperComponents);
+	const runtimeGlobalNames = collectStringSet(userConfig?.runtimeGlobals);
 	const hasTextComponents = textComponentNames.size > 0;
 	const hasRawTextWrappers = rawTextWrapperComponentNames.size > 0;
+	const hasRuntimeGlobals = runtimeGlobalNames.size > 0;
 	const fileLinesCache = /* @__PURE__ */ new Map();
 	const fileContextCache = /* @__PURE__ */ new Map();
 	const libraryFileCache = /* @__PURE__ */ new Map();
+	const suppressions = /* @__PURE__ */ new Map();
+	const suppress = (diagnostic, source) => {
+		const { ruleKey } = getDiagnosticRuleIdentity(diagnostic);
+		const suppressionKey = `${ruleKey}\u0000${source}`;
+		const existing = suppressions.get(suppressionKey);
+		suppressions.set(suppressionKey, existing ? {
+			...existing,
+			count: existing.count + 1
+		} : {
+			rule: ruleKey,
+			source,
+			count: 1
+		});
+		return null;
+	};
 	const isLibraryFile = (filePath) => {
 		let cached = libraryFileCache.get(filePath);
 		if (cached === void 0) {
@@ -35135,50 +35212,60 @@ const buildDiagnosticPipeline = (input) => {
 		if (hasRawTextWrappers && isInsideStringOnlyWrapper(lines, diagnostic.line, diagnostic.column, rawTextWrapperComponentNames)) return true;
 		return false;
 	};
-	return { apply: (diagnostic) => {
-		if (shouldAutoSuppress(diagnostic)) return null;
-		let current = diagnostic;
-		let explicitSeverityOverride;
-		let explicitRuleOverride;
-		if (severityControls) {
-			const { ruleKey, category } = getDiagnosticRuleIdentity(current);
-			explicitRuleOverride = resolveRuleSeverityOverride({ ruleKey }, severityControls);
-			explicitSeverityOverride = resolveRuleSeverityOverride({
-				ruleKey,
-				category
-			}, severityControls);
-			if (explicitSeverityOverride === "off") return null;
-			if (explicitSeverityOverride !== void 0) current = restampSeverity(current, explicitSeverityOverride);
-		}
-		if (explicitRuleOverride === void 0) {
-			if (isAppOnlyRule(`${current.plugin}/${current.rule}`) && isLibraryFile(current.filePath)) return null;
-		}
-		if (!showWarnings && current.severity === "warning" && explicitSeverityOverride !== "warn") return null;
-		if (userConfig) {
-			if (isRuleIgnored(`${current.plugin}/${current.rule}`)) return null;
-			if (isFileIgnoredByPatterns(current.filePath, rootDirectory, ignoredFilePatterns)) return null;
-			if (isDiagnosticIgnoredByOverrides(current, rootDirectory, compiledOverrides)) return null;
-			if (isRnRawTextSuppressedByConfig(current)) return null;
-		}
-		if (respectInlineDisables && current.line > 0) {
-			const lines = getFileLines(current.filePath);
-			if (lines) {
-				const ruleIdentifier = `${current.plugin}/${current.rule}`;
-				const evaluation = evaluateSuppression(lines, current.line - 1, ruleIdentifier);
-				if (evaluation.isSuppressed) return null;
-				if (evaluation.nearMissHint) current = {
-					...current,
-					suppressionHint: evaluation.nearMissHint
-				};
+	const isJsxNoUndefSuppressedByConfig = (diagnostic) => {
+		if (!hasRuntimeGlobals) return false;
+		if (diagnostic.rule !== "jsx-no-undef") return false;
+		const identifierMatch = JSX_NO_UNDEF_IDENTIFIER_PATTERN.exec(diagnostic.message);
+		return identifierMatch !== null && runtimeGlobalNames.has(identifierMatch[1]);
+	};
+	return {
+		apply: (diagnostic) => {
+			if (shouldAutoSuppress(diagnostic)) return null;
+			let current = diagnostic;
+			let explicitSeverityOverride;
+			let explicitRuleOverride;
+			if (severityControls) {
+				const { ruleKey, category } = getDiagnosticRuleIdentity(current);
+				explicitRuleOverride = resolveRuleSeverityOverride({ ruleKey }, severityControls);
+				explicitSeverityOverride = resolveRuleSeverityOverride({
+					ruleKey,
+					category
+				}, severityControls);
+				if (explicitSeverityOverride === "off") return suppress(current, "config");
+				if (explicitSeverityOverride !== void 0) current = restampSeverity(current, explicitSeverityOverride);
 			}
-		}
-		const fileContext = getFileContext(current.filePath);
-		if (fileContext !== "production") current = {
-			...current,
-			fileContext
-		};
-		return current;
-	} };
+			if (explicitRuleOverride === void 0) {
+				if (isAppOnlyRule(`${current.plugin}/${current.rule}`) && isLibraryFile(current.filePath)) return null;
+			}
+			if (!showWarnings && current.severity === "warning" && explicitSeverityOverride !== "warn") return null;
+			if (userConfig) {
+				if (isRuleIgnored(`${current.plugin}/${current.rule}`)) return suppress(current, "config");
+				if (isFileIgnoredByPatterns(current.filePath, rootDirectory, ignoredFilePatterns)) return null;
+				if (isDiagnosticIgnoredByOverrides(current, rootDirectory, compiledOverrides)) return suppress(current, "override");
+				if (isRnRawTextSuppressedByConfig(current)) return null;
+				if (isJsxNoUndefSuppressedByConfig(current)) return null;
+			}
+			if (respectInlineDisables && current.line > 0) {
+				const lines = getFileLines(current.filePath);
+				if (lines) {
+					const ruleIdentifier = `${current.plugin}/${current.rule}`;
+					const evaluation = evaluateSuppression(lines, current.line - 1, ruleIdentifier);
+					if (evaluation.isSuppressed) return suppress(current, "inline");
+					if (evaluation.nearMissHint) current = {
+						...current,
+						suppressionHint: evaluation.nearMissHint
+					};
+				}
+			}
+			const fileContext = getFileContext(current.filePath);
+			if (fileContext !== "production") current = {
+				...current,
+				fileContext
+			};
+			return current;
+		},
+		summarizeSuppressions: () => [...suppressions.values()]
+	};
 };
 const OxlintUnavailableKind = Literals(["binary-not-found", "native-binding-missing"]);
 var OxlintUnavailable = class extends TaggedErrorClass()("OxlintUnavailable", {
@@ -35398,7 +35485,7 @@ const resolveScanConcurrency = (requested) => {
 	if (!Number.isFinite(requested) || requested < 1) return 1;
 	return Math.min(Math.floor(requested), 32);
 };
-const readSystemFacts = () => ({
+const readSystemFacts$1 = () => ({
 	availableCores: os.availableParallelism(),
 	totalMemoryBytes: os.totalmem(),
 	cgroupMemoryLimitBytes: readCgroupMemoryLimitBytes()
@@ -35419,7 +35506,7 @@ const readSystemFacts = () => ({
 * `facts` is injectable so tests exercise core-bound, memory-bound, cgroup-
 * limited, and ceiling cases without mocking `os` or the filesystem.
 */
-const resolveAutoScanConcurrency = (facts = readSystemFacts()) => {
+const resolveAutoScanConcurrency = (facts = readSystemFacts$1()) => {
 	const availableMemoryBytes = Math.min(facts.totalMemoryBytes, facts.cgroupMemoryLimitBytes ?? Number.POSITIVE_INFINITY);
 	const memoryBoundedWorkers = Math.floor(availableMemoryBytes / PER_WORKER_MEM_BUDGET_BYTES);
 	return resolveScanConcurrency(Math.min(facts.availableCores, memoryBoundedWorkers));
@@ -35460,13 +35547,7 @@ var ScanDeadlineMs = class extends Reference("react-doctor/ScanDeadlineMs", { de
 * without recompiling react-doctor. Tests override via
 * `Layer.succeed(SupplyChainOverlapTimeoutMs, ...)`.
 */
-var SupplyChainOverlapTimeoutMs = class extends Reference("react-doctor/SupplyChainOverlapTimeoutMs", { defaultValue: () => {
-	const raw = process.env["REACT_DOCTOR_SUPPLY_CHAIN_TIMEOUT_MS"];
-	if (raw === void 0) return SUPPLY_CHAIN_OVERLAP_TIMEOUT_MS;
-	const parsed = Number(raw);
-	if (!Number.isFinite(parsed) || parsed <= 0) return SUPPLY_CHAIN_OVERLAP_TIMEOUT_MS;
-	return parsed;
-} }) {};
+var SupplyChainOverlapTimeoutMs = class extends Reference("react-doctor/SupplyChainOverlapTimeoutMs", { defaultValue: () => readPositiveEnvMs("REACT_DOCTOR_SUPPLY_CHAIN_TIMEOUT_MS", SUPPLY_CHAIN_OVERLAP_TIMEOUT_MS) }) {};
 /**
 * Hard cap on combined stdout+stderr bytes per oxlint batch. The
 * subprocess gets SIGKILL'd if it produces more; the recovery path
@@ -35610,6 +35691,13 @@ const BOOLEAN_FIELD_NAMES = [
 	"adoptExistingLintConfig"
 ];
 const STRING_FIELD_NAMES = ["rootDir"];
+const STRING_ARRAY_FIELD_NAMES = [
+	"projects",
+	"textComponents",
+	"rawTextWrapperComponents",
+	"runtimeGlobals",
+	"serverAuthFunctionNames"
+];
 const SURFACE_CONTROL_FIELD_NAMES = [
 	"includeTags",
 	"excludeTags",
@@ -35711,6 +35799,7 @@ const validateConfigTypes = (config) => {
 	const validated = { ...config };
 	for (const fieldName of BOOLEAN_FIELD_NAMES) applyFieldValidator(config, validated, fieldName, (value) => coerceMaybeBooleanString(fieldName, value));
 	for (const fieldName of STRING_FIELD_NAMES) applyFieldValidator(config, validated, fieldName, (value) => validateString(fieldName, value));
+	for (const fieldName of STRING_ARRAY_FIELD_NAMES) applyFieldValidator(config, validated, fieldName, (value) => validateStringArrayField(fieldName, value));
 	applyFieldValidator(config, validated, "surfaces", validateSurfacesField);
 	for (const fieldName of SEVERITY_FIELD_NAMES) applyFieldValidator(config, validated, fieldName, (value) => validateSeverityMap(fieldName, value, fieldName === "categories"));
 	applyFieldValidator(config, validated, "plugins", (value) => validateStringArrayField("plugins", value));
@@ -36695,14 +36784,17 @@ const checkReactServerComponentsAdvisory = (scanDirectory, project) => {
 	return diagnostics;
 };
 const REDUCED_MOTION_GREP_PATTERN = "prefers-reduced-motion|useReducedMotion|MotionConfig|reducedMotion";
-const REDUCED_MOTION_FILE_GLOBS = [
-	"*.ts",
-	"*.tsx",
-	"*.js",
-	"*.jsx",
-	"*.css",
-	"*.scss"
-];
+const REDUCED_MOTION_PATTERN = new RegExp(REDUCED_MOTION_GREP_PATTERN);
+const REDUCED_MOTION_FILE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".css",
+	".scss"
+]);
+const REDUCED_MOTION_FILE_GLOBS = [...REDUCED_MOTION_FILE_EXTENSIONS].map((extension) => `*${extension}`);
+const GIT_GREP_NO_MATCH_STATUS = 1;
 const MISSING_REDUCED_MOTION_DIAGNOSTIC = {
 	filePath: "package.json",
 	plugin: "react-doctor",
@@ -36714,6 +36806,19 @@ const MISSING_REDUCED_MOTION_DIAGNOSTIC = {
 	column: 0,
 	category: "Accessibility"
 };
+const hasReducedMotionHandlingViaFilesystem = (rootDirectory) => {
+	for (const { absolutePath, name } of walkSourceTreeFiles(rootDirectory)) {
+		if (!REDUCED_MOTION_FILE_EXTENSIONS.has(Path.extname(name))) continue;
+		let content;
+		try {
+			content = NFS.readFileSync(absolutePath, "utf-8");
+		} catch {
+			continue;
+		}
+		if (REDUCED_MOTION_PATTERN.test(content)) return true;
+	}
+	return false;
+};
 const checkReducedMotion = (rootDirectory) => {
 	const packageJsonPath = Path.join(rootDirectory, "package.json");
 	if (!isFile(packageJsonPath)) return [];
@@ -36732,22 +36837,21 @@ const checkReducedMotion = (rootDirectory) => {
 	const result = spawnSync("git", [
 		"grep",
 		"--untracked",
-		"-ql",
-		"-E",
+		"-lE",
 		REDUCED_MOTION_GREP_PATTERN,
 		"--",
 		...REDUCED_MOTION_FILE_GLOBS
 	], {
 		cwd: rootDirectory,
+		encoding: "utf-8",
 		stdio: [
 			"ignore",
 			"pipe",
 			"pipe"
 		]
 	});
-	if (result.error) return [MISSING_REDUCED_MOTION_DIAGNOSTIC];
-	if (result.status === 0) return [];
-	return [MISSING_REDUCED_MOTION_DIAGNOSTIC];
+	if (!(!result.error && (result.status === 0 || result.status === GIT_GREP_NO_MATCH_STATUS))) return hasReducedMotionHandlingViaFilesystem(rootDirectory) ? [] : [MISSING_REDUCED_MOTION_DIAGNOSTIC];
+	return result.status === 0 && result.stdout.split("\n").some((filePath) => filePath.length > 0 && !hasIgnoredPathSegment(filePath)) ? [] : [MISSING_REDUCED_MOTION_DIAGNOSTIC];
 };
 const buildSecurityScanDiagnostic = (finding, entry, relativePath) => ({
 	filePath: relativePath,
@@ -36897,7 +37001,10 @@ const shouldEnableRule = (requires, tags, capabilities, ignoredTags, disabledBy)
 	}
 	return true;
 };
-const checkSecurityScan = (rootDirectory, options = {}) => {
+const yieldToEventLoop = () => new Promise((resolve) => {
+	setImmediate(resolve);
+});
+const createSecurityScanSession = (rootDirectory, options) => {
 	const capabilities = options.project ? buildCapabilities(options.project) : /* @__PURE__ */ new Set();
 	const ignoredTags = options.ignoredTags ?? /* @__PURE__ */ new Set();
 	const enabledScanRules = REACT_DOCTOR_RULES.flatMap((entry) => {
@@ -36912,7 +37019,7 @@ const checkSecurityScan = (rootDirectory, options = {}) => {
 			committedFilesOnly: rule.committedFilesOnly === true
 		}];
 	});
-	if (enabledScanRules.length === 0) return [];
+	if (enabledScanRules.length === 0) return null;
 	const diagnostics = [];
 	const seen = /* @__PURE__ */ new Set();
 	const gitIgnoredCache = /* @__PURE__ */ new Map();
@@ -36924,15 +37031,34 @@ const checkSecurityScan = (rootDirectory, options = {}) => {
 		}
 		return status === true;
 	};
-	for (const file of collectSecurityScanFiles(rootDirectory)) for (const { entry, scan, committedFilesOnly } of enabledScanRules) for (const finding of scan(file)) {
-		if (committedFilesOnly && isFileGitIgnored(file)) continue;
-		const diagnostic = buildSecurityScanDiagnostic(finding, entry, file.relativePath);
-		const key = `${diagnostic.rule}:${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.message}`;
-		if (seen.has(key)) continue;
-		seen.add(key);
-		diagnostics.push(diagnostic);
+	const scanFile = (file) => {
+		for (const { entry, scan, committedFilesOnly } of enabledScanRules) for (const finding of scan(file)) {
+			if (committedFilesOnly && isFileGitIgnored(file)) continue;
+			const diagnostic = buildSecurityScanDiagnostic(finding, entry, file.relativePath);
+			const key = `${diagnostic.rule}:${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}:${diagnostic.message}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			diagnostics.push(diagnostic);
+		}
+	};
+	return {
+		scanFile,
+		diagnostics
+	};
+};
+const checkSecurityScanCooperative = async (rootDirectory, options = {}) => {
+	const session = createSecurityScanSession(rootDirectory, options);
+	if (session === null) return [];
+	let filesSinceYield = 0;
+	for (const file of collectSecurityScanFiles(rootDirectory)) {
+		session.scanFile(file);
+		filesSinceYield += 1;
+		if (filesSinceYield >= 16) {
+			filesSinceYield = 0;
+			await yieldToEventLoop();
+		}
 	}
-	return diagnostics;
+	return session.diagnostics;
 };
 var import_picocolors = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	let p = process || {}, argv = p.argv || [], env = p.env || {};
@@ -37149,6 +37275,74 @@ const collectDeadCodeIgnorePatterns = (rootDirectory) => {
 	return [...seen].filter((pattern) => pattern.length > 0);
 };
 const collectDeadCodeEntryPatterns = (rootDirectory) => [...new Set(collectKnipPatterns(rootDirectory, "entry"))].filter((pattern) => pattern.length > 0);
+const readSystemFacts = () => ({
+	availableCores: os.availableParallelism(),
+	totalMemoryBytes: os.totalmem(),
+	cgroupMemoryLimitBytes: readCgroupMemoryLimitBytes()
+});
+/**
+* How many real deslop dead-code child processes may run at once, across the
+* concurrent per-project `runInspect` fibers of one CLI run. The cap is the
+* smaller of the core count and the number of `DEAD_CODE_WORKER_MEM_BUDGET_BYTES`
+* workers that fit in available memory, floored at 1.
+*
+* On a roomy dev box / CI runner this resolves high enough that every
+* concurrently-scanned project still spawns its own worker (no serialization vs
+* the prior uncapped behavior); on a memory-constrained runner it collapses
+* toward 1, so the `withDeadCodeWorkerSlot` semaphore serializes the spawns
+* instead of oversubscribing memory with N simultaneous children — the global
+* cap the per-project spawn path lacked.
+*
+* Mirrors `resolveAutoScanConcurrency` (lint), but budgets memory per the
+* heavier dead-code worker. `facts` is injectable for tests.
+*/
+const resolveDeadCodeConcurrency = (facts = readSystemFacts()) => {
+	const availableMemoryBytes = Math.min(facts.totalMemoryBytes, facts.cgroupMemoryLimitBytes ?? Number.POSITIVE_INFINITY);
+	const memoryBoundedWorkers = Math.floor(availableMemoryBytes / DEAD_CODE_WORKER_MEM_BUDGET_BYTES);
+	return Math.max(1, Math.min(facts.availableCores, memoryBoundedWorkers));
+};
+let availableSlots = -1;
+const waiters = [];
+const releaseSlot = () => {
+	const nextWaiter = waiters.shift();
+	if (nextWaiter !== void 0) nextWaiter();
+	else availableSlots += 1;
+};
+/**
+* Runs `task` once a dead-code worker slot is free, releasing the slot when the
+* task settles (success or failure). With a high cap (roomy machine) every
+* caller proceeds immediately; with a low cap (constrained runner) callers
+* queue and run as slots free.
+*
+* `abortSignal` short-circuits the WAIT: if it's already aborted, or fires while
+* this caller is queued, the call rejects without acquiring a slot or running
+* `task` — so a cancelled scan (e.g. lint failed) doesn't sit in the queue and
+* then spawn a child only to tear it down. A queued caller that aborts removes
+* its own waiter so a later release never hands a slot to a dead request.
+*/
+const withDeadCodeWorkerSlot = async (task, abortSignal) => {
+	if (abortSignal?.aborted) throw new Error("Dead-code worker aborted.");
+	if (availableSlots < 0) availableSlots = resolveDeadCodeConcurrency();
+	if (availableSlots > 0) availableSlots -= 1;
+	else await new Promise((resolve, reject) => {
+		const waiter = () => {
+			abortSignal?.removeEventListener("abort", onAbort);
+			resolve();
+		};
+		const onAbort = () => {
+			const queuedIndex = waiters.indexOf(waiter);
+			if (queuedIndex !== -1) waiters.splice(queuedIndex, 1);
+			reject(/* @__PURE__ */ new Error("Dead-code worker aborted."));
+		};
+		waiters.push(waiter);
+		abortSignal?.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await task();
+	} finally {
+		releaseSlot();
+	}
+};
 /**
 * Resolves a path to its canonical, symlink-free form, falling back to
 * the input when it cannot be realpath'd (broken symlink, permission
@@ -37173,6 +37367,11 @@ const toCanonicalPath = (filePath) => {
 };
 const DEAD_CODE_PLUGIN = "deslop";
 const DEAD_CODE_CATEGORY = "Maintainability";
+const REACT_DOCTOR_TOOLCHAIN_PACKAGES = new Set([
+	"react-doctor",
+	"eslint-plugin-react-doctor",
+	"oxlint-plugin-react-doctor"
+]);
 const DEAD_CODE_WORKER_SCRIPT = `
 const inputChunks = [];
 process.stdin.on("data", (chunk) => inputChunks.push(chunk));
@@ -37439,14 +37638,17 @@ const checkDeadCode = async (options) => {
 	if (!NFS.existsSync(Path.join(rootDirectory, "package.json"))) return [];
 	const entryPatterns = collectDeadCodeEntryPatterns(rootDirectory);
 	const ignorePatterns = collectDeadCodeIgnorePatterns(rootDirectory);
-	const result = parseDeadCodeWorkerResult(await runDeadCodeWorkerWithTimeout((options.createWorker ?? createDeadCodeWorker)({
-		rootDirectory,
-		entryPatterns,
-		tsConfigPath: resolveTsConfigPath(rootDirectory),
-		ignorePatterns,
-		deslopJsModuleSpecifier: options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js"),
-		parseConcurrency: options.parseConcurrency
-	}), options.workerTimeoutMs ?? 12e4, options.abortSignal));
+	const spawnAndRun = () => {
+		return runDeadCodeWorkerWithTimeout((options.createWorker ?? createDeadCodeWorker)({
+			rootDirectory,
+			entryPatterns,
+			tsConfigPath: resolveTsConfigPath(rootDirectory),
+			ignorePatterns,
+			deslopJsModuleSpecifier: options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js"),
+			parseConcurrency: options.parseConcurrency
+		}), options.workerTimeoutMs ?? 12e4, options.abortSignal);
+	};
+	const result = parseDeadCodeWorkerResult(options.createWorker === void 0 ? await withDeadCodeWorkerSlot(spawnAndRun, options.abortSignal) : await spawnAndRun());
 	const toRelative = (filePath) => toRelativeFilePath(rootDirectory, filePath);
 	const diagnostics = [];
 	for (const unusedFile of result.unusedFiles) diagnostics.push({
@@ -37475,6 +37677,7 @@ const checkDeadCode = async (options) => {
 		});
 	}
 	for (const unusedDependency of result.unusedDependencies) {
+		if (REACT_DOCTOR_TOOLCHAIN_PACKAGES.has(unusedDependency.name)) continue;
 		const label = unusedDependency.isDevDependency ? "devDependency" : "dependency";
 		diagnostics.push({
 			filePath: "package.json",
@@ -37544,6 +37747,7 @@ const isDiagnosticOnSurface = (diagnostic, surface, config) => {
 	return true;
 };
 const filterDiagnosticsForSurface = (diagnostics, surface, config) => diagnostics.filter((diagnostic) => isDiagnosticOnSurface(diagnostic, surface, config));
+const remainingDeadlineBudgetMs = (deadlineEpochMs) => Math.max(deadlineEpochMs - Date.now(), 0);
 /**
 * Budget for the dead-code phase, scaled to the work. deslop's graph build is
 * CPU-bound and roughly linear in file count, so a fixed 120s cap is too tight
@@ -37562,53 +37766,6 @@ const resolveDeadCodeTimeout = (input) => {
 		phaseTimeoutMs: workerTimeoutMs + DEAD_CODE_PHASE_TIMEOUT_OVER_WORKER_MS
 	};
 };
-const collectSizedSourceFiles = (rootDirectory, relativePaths) => {
-	const entries = [];
-	for (const relativePath of relativePaths) {
-		const absolutePath = Path.resolve(rootDirectory, relativePath);
-		const sizeBytes = statSourceFileSize(absolutePath);
-		if (isLargeMinifiedFile(absolutePath, sizeBytes)) continue;
-		entries.push({
-			path: relativePath,
-			sizeBytes: sizeBytes ?? 0
-		});
-	}
-	return entries;
-};
-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 && isLintableSourceFile(filePath));
-};
-const listSourceFilesViaFilesystem = (rootDirectory) => {
-	const filePaths = [];
-	const stack = [rootDirectory];
-	while (stack.length > 0) {
-		const currentDirectory = stack.pop();
-		const entries = readDirectoryEntries(currentDirectory);
-		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() && isLintableSourceFile(entry.name)) filePaths.push(Path.relative(rootDirectory, absolutePath).replace(/\\/g, "/"));
-		}
-	}
-	return filePaths;
-};
-const listSourceFilesWithSize = (rootDirectory) => collectSizedSourceFiles(rootDirectory, listSourceFilesViaGit(rootDirectory) ?? listSourceFilesViaFilesystem(rootDirectory));
-const listSourceFiles = (rootDirectory) => listSourceFilesWithSize(rootDirectory).map((entry) => entry.path);
 const resolveLintIncludePaths = (rootDirectory, userConfig, project) => {
 	if (!Array.isArray(userConfig?.ignore?.files) || userConfig.ignore.files.length === 0) return;
 	const ignoredPatterns = compileIgnoredFilePatterns(userConfig);
@@ -37653,7 +37810,6 @@ var DeadCode = class DeadCode extends Service()("react-doctor/DeadCode") {
 		return yield* tryPromise({
 			try: (signal) => checkDeadCode({
 				rootDirectory: input.rootDirectory,
-				userConfig: input.userConfig,
 				parseConcurrency: input.parseConcurrency,
 				workerTimeoutMs: input.workerTimeoutMs,
 				abortSignal: signal
@@ -37776,6 +37932,11 @@ const isSafeGitRevision = (candidate) => {
 	if (candidate.includes("..") || candidate.includes("@{")) return false;
 	return SAFE_GIT_REVISION_PATTERN.test(candidate);
 };
+const resolveSpawnArgsLengthCap = () => {
+	if (process.platform === "win32") return SPAWN_ARGS_MAX_LENGTH_CHARS;
+	if (process.platform === "darwin") return SPAWN_ARGS_MAX_LENGTH_CHARS_DARWIN;
+	return SPAWN_ARGS_MAX_LENGTH_CHARS_POSIX;
+};
 /**
 * Splits a git revision range into its endpoints: three-dot `A...B`
 * (symmetric, merge-base) or two-dot `A..B` (direct). Returns `null`
@@ -37847,43 +38008,47 @@ var Git = class Git extends Service()("react-doctor/Git") {
 		* reason: GitInvocationFailed })` so the rest of the codebase
 		* sees a single failure channel.
 		*/
-		const runCommand = (input) => scoped(gen(function* () {
-			const handle = yield* spawner.spawn(make$1(input.command, [...input.args], {
-				cwd: input.directory,
-				env: input.env,
-				extendEnv: true
-			}));
-			const maxStdoutBytes = input.maxStdoutBytes;
-			const stdoutByteCount = yield* make$13(0);
-			const [stdout, stderr, status] = yield* all([
-				mkString(decodeText(maxStdoutBytes === void 0 ? handle.stdout : handle.stdout.pipe(tap((chunk) => updateAndGet(stdoutByteCount, (total) => total + chunk.length).pipe(flatMap$2((total) => total > maxStdoutBytes ? fail$4(new ReactDoctorError({ reason: new GitInvocationFailed({
-					args: [...input.args],
-					directory: input.directory,
-					cause: /* @__PURE__ */ new Error(`git stdout exceeded ${maxStdoutBytes} bytes`)
-				}) })) : void_)))))),
-				mkString(decodeText(handle.stderr)),
-				handle.exitCode
-			], { concurrency: 3 });
-			return {
-				status,
-				stdout,
-				stderr
-			};
-		})).pipe(catchTag$1("PlatformError", (cause) => {
-			if (input.command !== "git") return succeed$2({
+		const runCommand = (input) => {
+			const foldSpawnFailure = (cause) => input.command !== "git" ? succeed$2({
 				status: 127,
 				stdout: "",
 				stderr: String(cause)
-			});
-			return new ReactDoctorError({ reason: new GitInvocationFailed({
+			}) : fail$4(new ReactDoctorError({ reason: new GitInvocationFailed({
 				args: [...input.args],
 				directory: input.directory,
 				cause
-			}) });
-		}), withSpan("git.exec", { attributes: {
-			"git.command": input.command,
-			"git.subcommand": input.args[0] ?? ""
-		} }));
+			}) }));
+			return scoped(gen(function* () {
+				if (!isDirectory(input.directory)) return yield* foldSpawnFailure(`spawn ENOTDIR (cwd is not a directory: ${input.directory})`);
+				const argvLengthChars = input.command.length + 1 + input.args.reduce((total, arg) => total + arg.length + 1, 0);
+				const spawnArgsLengthCap = resolveSpawnArgsLengthCap();
+				if (argvLengthChars > spawnArgsLengthCap) return yield* foldSpawnFailure(`spawn ENAMETOOLONG (${argvLengthChars} argv chars exceed ${spawnArgsLengthCap})`);
+				const handle = yield* spawner.spawn(make$1(input.command, [...input.args], {
+					cwd: input.directory,
+					env: input.env,
+					extendEnv: true
+				}));
+				const maxStdoutBytes = input.maxStdoutBytes;
+				const stdoutByteCount = yield* make$13(0);
+				const [stdout, stderr, status] = yield* all([
+					mkString(decodeText(maxStdoutBytes === void 0 ? handle.stdout : handle.stdout.pipe(tap((chunk) => updateAndGet(stdoutByteCount, (total) => total + chunk.length).pipe(flatMap$2((total) => total > maxStdoutBytes ? fail$4(new ReactDoctorError({ reason: new GitInvocationFailed({
+						args: [...input.args],
+						directory: input.directory,
+						cause: /* @__PURE__ */ new Error(`git stdout exceeded ${maxStdoutBytes} bytes`)
+					}) })) : void_)))))),
+					mkString(decodeText(handle.stderr)),
+					handle.exitCode
+				], { concurrency: 3 });
+				return {
+					status,
+					stdout,
+					stderr
+				};
+			})).pipe(catchTag$1("PlatformError", foldSpawnFailure), withSpan("git.exec", { attributes: {
+				"git.command": input.command,
+				"git.subcommand": input.args[0] ?? ""
+			} }));
+		};
 		const runGit = (directory, args) => runCommand({
 			command: "git",
 			args,
@@ -37916,7 +38081,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 			"rev-parse",
 			"--verify",
 			branch
-		]).pipe(map$3((result) => result.status === 0));
+		]).pipe(map$3((result) => result.status === 0), catch_$1((error) => error.reason._tag === "GitInvocationFailed" ? succeed$2(false) : fail$4(error)));
 		const headSha = (directory) => runGit(directory, ["rev-parse", "HEAD"]).pipe(map$3((result) => result.status === 0 ? trimOrNull(result.stdout) : null));
 		const mergeBase = (input) => isSafeGitRevision(input.ref) ? runGit(input.directory, [
 			"merge-base",
@@ -38026,6 +38191,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 				if (resolvedCurrentBranch === null && explicitBaseBranch === void 0) return null;
 				const baseBranch = explicitBaseBranch ?? (yield* defaultBranch(directory));
 				if (baseBranch === null) return null;
+				if (!isSafeGitRevision(baseBranch)) return null;
 				if (explicitBaseBranch !== void 0) {
 					if (!(yield* branchExists(directory, explicitBaseBranch))) return yield* fail$4(new ReactDoctorError({ reason: new GitBaseBranchMissing({ branch: explicitBaseBranch }) }));
 				}
@@ -38130,7 +38296,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 				]);
 				if (result.status !== 0) return null;
 				return parseChangedLineRanges(result.stdout);
-			}).pipe(withSpan("Git.changedLineRanges"))
+			}).pipe(catch_$1((error) => error.reason._tag === "GitInvocationFailed" ? succeed$2(null) : fail$4(error)), withSpan("Git.changedLineRanges"))
 		});
 	})).pipe(provide$2(layer$2.pipe(provide$2(mergeAll$1(layer$1, layer)))));
 	/**
@@ -38296,12 +38462,12 @@ const findFilesWithDisableDirectivesViaGit = async (rootDirectory, includePaths)
 		return null;
 	}
 	if (grepResult === null) return null;
-	return grepResult.stdout.split("\n").filter((filePath) => filePath.length > 0 && isLintableSourceFile(filePath));
+	return grepResult.stdout.split("\n").filter((filePath) => filePath.length > 0 && isLintableSourceFile(filePath) && !hasIgnoredPathSegment(filePath));
 };
 const findFilesWithDisableDirectivesViaFilesystem = (rootDirectory, includePaths) => {
 	const matches = [];
 	const checkFile = (relativePath) => {
-		if (!isLintableSourceFile(relativePath)) return;
+		if (!isLintableSourceFile(relativePath) || hasIgnoredPathSegment(relativePath)) return;
 		const absolutePath = Path.join(rootDirectory, relativePath);
 		let content;
 		try {
@@ -38315,22 +38481,7 @@ const findFilesWithDisableDirectivesViaFilesystem = (rootDirectory, includePaths
 		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;
-		const entries = readDirectoryEntries(current);
-		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));
-		}
-	}
+	for (const { absolutePath } of walkSourceTreeFiles(rootDirectory)) checkFile(Path.relative(rootDirectory, absolutePath));
 	return matches;
 };
 const findFilesWithDisableDirectives = async (rootDirectory, includePaths) => await findFilesWithDisableDirectivesViaGit(rootDirectory, includePaths) ?? findFilesWithDisableDirectivesViaFilesystem(rootDirectory, includePaths);
@@ -38376,7 +38527,7 @@ const normalizeConfigForHash = (config) => {
 	if (Array.isArray(clone?.jsPlugins)) clone.jsPlugins = clone.jsPlugins.map((_, index) => `<plugin:${index}>`);
 	return clone;
 };
-const computeRulesetHash = (input) => crypto.createHash("sha1").update(JSON.stringify(normalizeConfigForHash(input.config))).update("\0").update([...input.toolchainVersions].join("\0")).update("\0").update([...input.ignorePatterns].join("\n")).update(" ").update(input.tsconfigContent ?? "").digest("hex");
+const computeRulesetHash = (input) => crypto.createHash("sha1").update(JSON.stringify(normalizeConfigForHash(input.config))).update("\0").update([...input.toolchainVersions].join("\0")).update("\0").update([...input.ignorePatterns].join("\n")).update("\0").update(input.tsconfigContent ?? "").digest("hex");
 /**
 * Loads a plugin module via the local require resolver and extracts
 * `(name, ruleNames)` from either `module.exports.meta + rules` or
@@ -38547,12 +38698,12 @@ const createOxlintConfig = ({ pluginPath, project, customRulesOnly = false, exte
 		if (customRulesOnly && registryEntry.originallyExternal) continue;
 		if (rule.framework !== "global" && !rule.requires) continue;
 		if (!shouldEnableRule(rule.requires, rule.tags, capabilities, ignoredTags, rule.disabledBy)) continue;
-		const explicitSeverity = resolveRuleSeverityOverride({
+		const explicitRuleOverride = resolveRuleSeverityOverride({ ruleKey: registryEntry.key }, severityControls);
+		if (rule.defaultEnabled === false && explicitRuleOverride === void 0) continue;
+		const severity = resolveRuleSeverityOverride({
 			ruleKey: registryEntry.key,
 			category: rule.category
-		}, severityControls);
-		if (rule.defaultEnabled === false && explicitSeverity === void 0) continue;
-		const severity = explicitSeverity ?? resolveCompilerCleanupBucketSeverity(registryEntry.key, severityControls) ?? rule.severity;
+		}, severityControls) ?? resolveCompilerCleanupBucketSeverity(registryEntry.key, severityControls) ?? rule.severity;
 		if (severity === "off") continue;
 		enabledReactDoctorRules[registryEntry.key] = severity;
 	}
@@ -38654,24 +38805,38 @@ const createFileLintCache = (cacheDirectory, rulesetHash) => {
 				updatedAtMs: Date.now(),
 				files: Object.fromEntries(cappedEntries)
 			};
-			const keptHashes = Object.entries(rulesets).sort(([, first], [, second]) => second.updatedAtMs - first.updatedAtMs).slice(0, 8).map(([hash]) => hash);
-			const prunedRulesets = {};
-			for (const hash of keptHashes) prunedRulesets[hash] = rulesets[hash];
 			atomicWriteJson(cacheFilePath, {
 				version: 1,
-				rulesets: prunedRulesets
+				rulesets: Object.fromEntries(Object.entries(rulesets).filter(([, bucket]) => isRecord(bucket) && typeof bucket.updatedAtMs === "number").sort(([, first], [, second]) => second.updatedAtMs - first.updatedAtMs).slice(0, 8))
 			});
 		}
 	};
 };
 const bundledRequire = createRequire(import.meta.url);
+const childNodeVersionByBinaryPath = /* @__PURE__ */ new Map();
+const resolveChildNodeVersion = (nodeBinaryPath) => {
+	if (nodeBinaryPath === process.execPath) return process.version;
+	const cachedVersion = childNodeVersionByBinaryPath.get(nodeBinaryPath);
+	if (cachedVersion !== void 0) return cachedVersion;
+	let version;
+	try {
+		version = execFileSync(nodeBinaryPath, ["--version"], {
+			encoding: "utf8",
+			timeout: NODE_VERSION_PROBE_TIMEOUT_MS
+		}).trim();
+	} catch {
+		version = `unknown:${nodeBinaryPath}`;
+	}
+	childNodeVersionByBinaryPath.set(nodeBinaryPath, version);
+	return version;
+};
 const TOOLCHAIN_PACKAGE_SPECIFIERS = [
 	"oxlint/package.json",
 	"oxlint-plugin-react-doctor/package.json",
 	"eslint-plugin-react-hooks/package.json"
 ];
-const resolveOxlintToolchainVersions = () => {
-	const versions = [`node=${process.version}`];
+const resolveOxlintToolchainVersions = (nodeBinaryPath = process.execPath) => {
+	const versions = [`node=${resolveChildNodeVersion(nodeBinaryPath)}`];
 	for (const specifier of TOOLCHAIN_PACKAGE_SPECIFIERS) try {
 		const packageJson = bundledRequire(specifier);
 		const version = typeof packageJson.version === "string" ? packageJson.version : "unknown";
@@ -39205,11 +39370,12 @@ const REACT_COMPILER_TITLE = "React Compiler can't optimize this";
 const REACT_COMPILER_TODO_TITLE = "React Compiler doesn't support this syntax";
 const REACT_COMPILER_IMPACT = "This component misses React Compiler's automatic memoization & re-renders more than it should";
 const REACT_COMPILER_ACTION = "Rewrite the flagged code so the compiler can optimize it.";
+const REACT_COMPILER_INCOMPATIBLE_LIBRARY_ACTION = "It's how the library works, not a bug in your code. Memoize values you pass from it into other memoized components, or suppress it with `// react-doctor-disable-next-line react-hooks-js/incompatible-library`.";
 const REACT_COMPILER_GENERIC_MESSAGE = `${REACT_COMPILER_IMPACT}. ${REACT_COMPILER_ACTION}`;
-const buildReactCompilerMessage = (reasonSummary) => {
+const buildReactCompilerMessage = (reasonSummary, action = REACT_COMPILER_ACTION) => {
 	const normalizedSummary = reasonSummary.replace(TRAILING_PERIOD_PATTERN, "");
-	if (!normalizedSummary) return REACT_COMPILER_GENERIC_MESSAGE;
-	return `${REACT_COMPILER_IMPACT}: ${normalizedSummary}. ${REACT_COMPILER_ACTION}`;
+	if (!normalizedSummary) return `${REACT_COMPILER_IMPACT}. ${action}`;
+	return `${REACT_COMPILER_IMPACT}: ${normalizedSummary}. ${action}`;
 };
 const PLUGIN_CATEGORY_MAP = {
 	react: "Bugs",
@@ -39258,7 +39424,7 @@ const resolveCleanedDiagnostic = (message, help, plugin, rule, project) => {
 		const [reasonSummary = "", ...reasonDetailLines] = bailoutReason.split("\n");
 		const reasonDetail = reasonDetailLines.join("\n").trim();
 		return {
-			message: buildReactCompilerMessage(reasonSummary.trim()),
+			message: buildReactCompilerMessage(reasonSummary.trim(), rule === "incompatible-library" ? REACT_COMPILER_INCOMPATIBLE_LIBRARY_ACTION : REACT_COMPILER_ACTION),
 			help: appendReanimatedSharedValueHint(reasonDetail || help, rule, project)
 		};
 	}
@@ -39519,28 +39685,46 @@ const isParallelismRelatedSpawnError = (error) => {
 * loop with a slimmer config in that case.
 */
 const spawnLintBatches = async (input) => {
-	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes, splitTotalBudgetMs = OXLINT_SPLIT_TOTAL_BUDGET_MS, splitMaxDepth = 8, signal } = input;
+	const { baseArgs, fileBatches, rootDirectory, nodeBinaryPath, project, onPartialFailure, onFileProgress, spawnTimeoutMs, outputMaxBytes, splitTotalBudgetMs = OXLINT_SPLIT_TOTAL_BUDGET_MS, splitMaxDepth = 8, signal, deadlineEpochMs } = input;
 	const requestedConcurrency = resolveScanConcurrency(input.concurrency ?? 1);
 	const totalFileCount = fileBatches.reduce((sum, batch) => sum + batch.length, 0);
 	const runBatchPass = async (concurrency) => {
 		const allDiagnostics = [];
 		const droppedFiles = [];
+		const deadlineSkippedFiles = [];
+		const isPastDeadline = () => deadlineEpochMs !== void 0 && remainingDeadlineBudgetMs(deadlineEpochMs) === 0;
 		let firstDropReason = null;
-		const splitDeadlineMs = Date.now() + splitTotalBudgetMs;
-		const spawnLintBatch = async (batch, depth) => {
+		const spawnLintBatch = async (batch, depth, batchState) => {
+			if (isPastDeadline()) {
+				deadlineSkippedFiles.push(...batch);
+				batchState.deadlineSkippedFileCount += batch.length;
+				return [];
+			}
 			const batchArgs = [...baseArgs, ...batch];
 			try {
 				return parseOxlintOutput(await spawnOxlint(batchArgs, rootDirectory, nodeBinaryPath, spawnTimeoutMs, outputMaxBytes, signal), project, rootDirectory);
 			} catch (error) {
 				if (!isSplittableReactDoctorError(error)) throw error;
-				const splitBudgetExhausted = Date.now() >= splitDeadlineMs || depth >= splitMaxDepth;
-				if (batch.length <= 1 || splitBudgetExhausted) {
+				if (isPastDeadline()) {
+					deadlineSkippedFiles.push(...batch);
+					batchState.deadlineSkippedFileCount += batch.length;
+					return [];
+				}
+				batchState.deadlineMs ??= Date.now() + splitTotalBudgetMs;
+				const isBudgetElapsed = Date.now() >= batchState.deadlineMs;
+				const isDepthCapReached = depth >= splitMaxDepth;
+				if (batch.length <= 1 || isBudgetElapsed || isDepthCapReached) {
 					droppedFiles.push(...batch);
-					if (firstDropReason === null) firstDropReason = splitBudgetExhausted && batch.length > 1 ? `${error.message} (split budget exhausted after ${splitMaxDepth} levels / ${splitTotalBudgetMs / MILLISECONDS_PER_SECOND}s)` : error.message;
+					if (firstDropReason === null) {
+						let limitHint = "";
+						if (isDepthCapReached) limitHint = ` (split depth cap of ${splitMaxDepth} levels reached)`;
+						else if (isBudgetElapsed) limitHint = ` (split budget of ${splitTotalBudgetMs / MILLISECONDS_PER_SECOND}s exhausted at depth ${depth})`;
+						firstDropReason = batch.length > 1 ? `${error.message}${limitHint}` : error.message;
+					}
 					return [];
 				}
 				const splitIndex = Math.ceil(batch.length / 2);
-				return [...await spawnLintBatch(batch.slice(0, splitIndex), depth + 1), ...await spawnLintBatch(batch.slice(splitIndex), depth + 1)];
+				return [...await spawnLintBatch(batch.slice(0, splitIndex), depth + 1, batchState), ...await spawnLintBatch(batch.slice(splitIndex), depth + 1, batchState)];
 			}
 		};
 		let startedFileCount = 0;
@@ -39556,9 +39740,17 @@ const spawnLintBatches = async (input) => {
 		progressTimer?.unref?.();
 		try {
 			const batchResults = await mapWithConcurrency(fileBatches, concurrency, async (batch) => {
+				if (isPastDeadline()) {
+					deadlineSkippedFiles.push(...batch);
+					return [];
+				}
 				startedFileCount += batch.length;
-				const batchDiagnostics = await spawnLintBatch(batch, 0);
-				scannedFileCount += batch.length;
+				const batchState = {
+					deadlineMs: null,
+					deadlineSkippedFileCount: 0
+				};
+				const batchDiagnostics = await spawnLintBatch(batch, 0, batchState);
+				scannedFileCount += batch.length - batchState.deadlineSkippedFileCount;
 				if (onFileProgress) {
 					displayedFileCount = Math.min(Math.max(displayedFileCount, scannedFileCount), totalFileCount);
 					onFileProgress(displayedFileCount, totalFileCount);
@@ -39569,12 +39761,13 @@ const spawnLintBatches = async (input) => {
 		} finally {
 			if (progressTimer !== null) clearInterval(progressTimer);
 		}
-		if (droppedFiles.length > 0 && onPartialFailure) {
-			const previewFiles = droppedFiles.slice(0, 3).join(", ");
-			const remainderHint = droppedFiles.length > 3 ? `, +${droppedFiles.length - 3} more` : "";
-			const reasonHint = firstDropReason ? ` — first failure: ${firstDropReason}` : "";
-			onPartialFailure(`${droppedFiles.length} file(s) failed to lint and were skipped (${previewFiles}${remainderHint})${reasonHint}`);
-		}
+		const reportSkippedFiles = (skippedFiles, buildMessage) => {
+			if (skippedFiles.length === 0 || !onPartialFailure) return;
+			onPartialFailure(buildMessage(`${skippedFiles.slice(0, 3).join(", ")}${skippedFiles.length > 3 ? `, +${skippedFiles.length - 3} more` : ""}`));
+		};
+		const reasonHint = firstDropReason ? ` — first failure: ${firstDropReason}` : "";
+		reportSkippedFiles(droppedFiles, (fileListPreview) => `${droppedFiles.length} file(s) failed to lint and were skipped (${fileListPreview})${reasonHint}`);
+		reportSkippedFiles(deadlineSkippedFiles, (fileListPreview) => `${deadlineSkippedFiles.length} file(s) skipped — max scan duration reached before they were linted (${fileListPreview})`);
 		return allDiagnostics;
 	};
 	let diagnostics;
@@ -39631,7 +39824,14 @@ const resolveReactDoctorCacheDir = (projectDirectory) => {
 	if (cacheDirOverride) return Path.join(cacheDirOverride, projectCacheSubdir(projectDirectory));
 	const nodeModulesDirectory = Path.join(projectDirectory, "node_modules");
 	if (NFS.existsSync(nodeModulesDirectory)) return Path.join(nodeModulesDirectory, ".cache", "react-doctor");
-	return Path.join(os.tmpdir(), "react-doctor-cache", projectCacheSubdir(projectDirectory));
+	return Path.join(os.tmpdir(), `react-doctor-cache-${resolveUserCacheScope()}`, projectCacheSubdir(projectDirectory));
+};
+const resolveUserCacheScope = () => {
+	try {
+		return String(process.getuid?.() ?? os.userInfo().username);
+	} catch {
+		return "shared";
+	}
 };
 const sortSourceFilesByCost = (entries) => [...entries].sort((left, right) => right.sizeBytes - left.sizeBytes).map((entry) => entry.path);
 /**
@@ -39771,7 +39971,8 @@ const runOxlint = async (options) => {
 				spawnTimeoutMs,
 				outputMaxBytes,
 				concurrency: options.concurrency,
-				signal: options.signal
+				signal: options.signal,
+				deadlineEpochMs: options.deadlineEpochMs
 			});
 			writeOxlintConfig(passConfigPath, buildConfigForPass({}));
 			try {
@@ -39799,7 +40000,7 @@ const runOxlint = async (options) => {
 					extendsPaths: [],
 					ruleSelection: "cacheable"
 				}),
-				toolchainVersions: resolveOxlintToolchainVersions(),
+				toolchainVersions: resolveOxlintToolchainVersions(nodeBinaryPath),
 				ignorePatterns: combinedPatterns,
 				tsconfigContent
 			});
@@ -39813,7 +40014,7 @@ const runOxlint = async (options) => {
 					missFiles.push(candidateFile);
 					continue;
 				}
-				const cacheKey = `${candidateFile.replaceAll("\\", "/")}${contentHash}`;
+				const cacheKey = `${candidateFile.replaceAll("\\", "/")}\u0000${contentHash}`;
 				cacheKeyByFile.set(candidateFile, cacheKey);
 				const cachedDiagnostics = cache.lookup(cacheKey);
 				if (cachedDiagnostics === null) missFiles.push(candidateFile);
@@ -39870,7 +40071,8 @@ const runOxlint = async (options) => {
 			spawnTimeoutMs,
 			outputMaxBytes,
 			concurrency: options.concurrency,
-			signal: options.signal
+			signal: options.signal,
+			deadlineEpochMs: options.deadlineEpochMs
 		});
 		writeOxlintConfig(configPath, buildConfig({ extendsPaths }));
 		try {
@@ -39974,7 +40176,8 @@ var Linter = class Linter extends Service()("react-doctor/Linter") {
 				outputMaxBytes,
 				concurrency,
 				signal,
-				lintBatchOrdering
+				lintBatchOrdering,
+				deadlineEpochMs: input.deadlineEpochMs
 			}),
 			catch: ensureReactDoctorError
 		});
@@ -40129,7 +40332,7 @@ const ScoreApiResponseSchema = Struct({
 	})))
 });
 const parseScoreResult = (value) => getOrNull(decodeUnknownOption(ScoreApiResponseSchema)(value));
-const stripLocalFileFields = (diagnostics) => diagnostics.map(({ filePath: _filePath, fileContext: _fileContext, ...rest }) => rest);
+const stripLocalFileFields = (diagnostics) => diagnostics.map(({ filePath: _filePath, fileContext: _fileContext, fixGroupId: _fixGroupId, ...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`;
@@ -40433,7 +40636,10 @@ const ALERT_SEVERITY_RANK = {
 	medium: 2,
 	low: 1
 };
-const severityRank = (severity) => ALERT_SEVERITY_RANK[severity.toLowerCase()] ?? 0;
+const severityRank = (severity) => {
+	const normalized = severity.toLowerCase();
+	return Object.hasOwn(ALERT_SEVERITY_RANK, normalized) ? ALERT_SEVERITY_RANK[normalized] : 0;
+};
 const displaySeverity = (severity) => {
 	const normalized = sanitizeTerminalText(severity.toLowerCase());
 	return normalized === "middle" ? "medium" : normalized;
@@ -40450,7 +40656,7 @@ const ALERT_TYPE_LABELS = {
 	typosquat: "possible typosquat"
 };
 const humanizeAlertType = (type) => type.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase().trim();
-const friendlyAlertType = (type) => ALERT_TYPE_LABELS[type] ?? sanitizeTerminalText(humanizeAlertType(type));
+const friendlyAlertType = (type) => Object.hasOwn(ALERT_TYPE_LABELS, type) ? ALERT_TYPE_LABELS[type] : sanitizeTerminalText(humanizeAlertType(type));
 const summarizeAlertNote = (note) => {
 	const collapsed = sanitizeTerminalText(note.replace(/\s+/g, " ").trim());
 	const firstSentence = collapsed.split(/(?<=\.)\s/)[0] || collapsed;
@@ -40545,7 +40751,10 @@ const checkSupplyChain = (input) => gen(function* () {
 * outage.
 */
 var SupplyChain = class SupplyChain extends Service()("react-doctor/SupplyChain") {
-	static layerNode = succeed$3(SupplyChain, SupplyChain.of({ run: (input) => unwrap(checkSupplyChain(input).pipe(map$3((diagnostics) => fromIterable$1(diagnostics)), withSpan("SupplyChain.run"))) }));
+	static layerNode = succeed$3(SupplyChain, SupplyChain.of({ run: (input) => unwrap(flatMap$2(SupplyChainOverlapTimeoutMs, (totalTimeoutMs) => checkSupplyChain({
+		...input,
+		totalTimeoutMs
+	})).pipe(map$3((diagnostics) => fromIterable$1(diagnostics)), withSpan("SupplyChain.run"))) }));
 	static layerOf = (diagnostics) => succeed$3(SupplyChain, SupplyChain.of({ run: () => fromIterable$1(diagnostics) }));
 };
 const getObjectProperty = (value, propertyName) => {
@@ -40607,7 +40816,10 @@ const formatLintFailText = (reasonTag, nodeVersion) => {
 *      diagnostics).
 *   2. beforeLint hook (e.g. CLI renders the project-detection block)
 *   3. environment checks (reduced-motion + pnpm hardening +
-*      expo/react-native + security scan), collected synchronously
+*      expo/react-native), collected synchronously. The heavier
+*      content-regex security scan is forked instead (like supply-chain
+*      below) and joined before the concat, so its CPU overlaps lint
+*      rather than blocking the event loop before it.
 *   4. The supply-chain check (Socket.dev) is forked onto a background
 *      fiber so its ~100% network-bound time overlaps the ~100%
 *      CPU/subprocess-bound lint pass below, collapsing two serial
@@ -40627,7 +40839,7 @@ const formatLintFailText = (reasonTag, nodeVersion) => {
 *      order, so terminal output is identical either way; supply-chain
 *      rides alongside without a spinner.
 *   6. Join the supply-chain fiber, then assemble the diagnostics in a
-*      FIXED order (env, supply-chain, lint, dead-code) so the output is
+*      FIXED order (env, security-scan, supply-chain, lint, dead-code) so the output is
 *      byte-identical regardless of which fiber settled first. The
 *      viewer-permission fiber is joined later, during score-metadata
 *      assembly (it feeds score metadata, not diagnostics). The per-element
@@ -40688,12 +40900,13 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 		...checkPnpmHardening(scanDirectory),
 		...checkReactServerComponentsAdvisory(scanDirectory, project),
 		...checkExpoProject(scanDirectory, project),
-		...checkReactNativeProject(scanDirectory, project),
-		...checkSecurityScan(scanDirectory, {
-			project,
-			ignoredTags: input.ignoredTags
-		})
+		...checkReactNativeProject(scanDirectory, project)
 	])));
+	const securityScanFailedRef = yield* make$13(false);
+	const securityScanFiber = yield* forkChild(runCollect(applyPerElementPipeline(isDiffMode ? empty$4 : unwrap(tryPromise(() => checkSecurityScanCooperative(scanDirectory, {
+		project,
+		ignoredTags: input.ignoredTags
+	})).pipe(map$3((diagnostics) => fromIterable$1(diagnostics)), catch_$1(() => set(securityScanFailedRef, true).pipe(as(empty$4))))))).pipe(withSpan("SecurityScan.run")));
 	const shouldRunSupplyChain = !isDiffMode || (input.supplyChainManifestChanged ?? false);
 	const supplyChainOverlapTimeout = yield* SupplyChainOverlapTimeoutMs;
 	const supplyChainFiber = yield* forkChild(shouldRunSupplyChain ? runCollect(applyPerElementPipeline(supplyChainService.run({
@@ -40724,6 +40937,7 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 	const deadCodePhaseTimeoutMs = yield* DeadCodePhaseTimeoutMs;
 	const resolveDeadCodePhaseTimeoutMs = (scaledPhaseTimeoutMs) => deadCodePhaseTimeoutMs === 15e4 ? scaledPhaseTimeoutMs : deadCodePhaseTimeoutMs;
 	const workerCountSuffix = scanConcurrency > 1 ? ` ${highlighter.dim(`[~${scanConcurrency} workers]`)}` : "";
+	const capToDeadline = (phaseTimeoutMs) => input.deadlineEpochMs === void 0 ? phaseTimeoutMs : Math.min(phaseTimeoutMs, remainingDeadlineBudgetMs(input.deadlineEpochMs));
 	const shouldRunDeadCode = input.runDeadCode && !isDiffMode && (showWarnings || deadCodeMaySurfaceWhenWarningsHidden(resolvedConfig.config));
 	const deadCodeOverlapMode = yield* DeadCodeOverlap;
 	const shouldOverlapDeadCode = shouldRunDeadCode && deadCodeOverlapMode === "on";
@@ -40731,7 +40945,6 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 	const lintConcurrency = deadCodeParseConcurrency === void 0 ? scanConcurrency : Math.max(1, scanConcurrency - deadCodeParseConcurrency);
 	const buildCollectDeadCode = (deadCodeTimeout) => runCollect(applyPerElementPipeline(deadCodeService.run({
 		rootDirectory: scanDirectory,
-		userConfig: resolvedConfig.config,
 		parseConcurrency: deadCodeParseConcurrency,
 		workerTimeoutMs: deadCodeTimeout.workerTimeoutMs
 	}).pipe(catchTag("ReactDoctorError", (error) => unwrap(gen(function* () {
@@ -40754,7 +40967,7 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 	});
 	const deadCodeFiber = shouldOverlapDeadCode ? yield* forkChild(buildCollectDeadCode({
 		workerTimeoutMs: overlapDeadCodeTimeout.workerTimeoutMs,
-		phaseTimeoutMs: resolveDeadCodePhaseTimeoutMs(overlapDeadCodeTimeout.phaseTimeoutMs)
+		phaseTimeoutMs: capToDeadline(resolveDeadCodePhaseTimeoutMs(overlapDeadCodeTimeout.phaseTimeoutMs))
 	})) : null;
 	const scanProgress = yield* progressService.start("Scanning...");
 	const scanStartTime = Date.now();
@@ -40779,7 +40992,8 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 		onCacheStats: (cacheHitFileCount, totalConsideredFileCount) => {
 			lintCacheHitFileCount = cacheHitFileCount;
 			lintCacheTotalFileCount = totalConsideredFileCount;
-		}
+		},
+		deadlineEpochMs: input.deadlineEpochMs
 	}).pipe(catchTag("ReactDoctorError", (error) => unwrap(gen(function* () {
 		yield* set(lintFailure, {
 			didFail: true,
@@ -40806,7 +41020,13 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 	let deadCodeCollected = [];
 	if (lintFailureState.didFail) {
 		if (deadCodeFiber !== null) yield* interrupt(deadCodeFiber);
-	} else if (shouldRunDeadCode) {
+	} else if (shouldRunDeadCode) if (input.deadlineEpochMs !== void 0 && remainingDeadlineBudgetMs(input.deadlineEpochMs) === 0) {
+		if (deadCodeFiber !== null) yield* interrupt(deadCodeFiber);
+		yield* set(deadCodeFailure, {
+			didFail: true,
+			reason: "Dead-code analysis skipped — max scan duration reached."
+		});
+	} else {
 		yield* scanProgress.update(`Scanned ${scannedFilesLabel}, analyzing dead code...`);
 		const sequentialDeadCodeTimeout = resolveDeadCodeTimeout({
 			sourceFileCount: totalFileCount,
@@ -40815,7 +41035,7 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 		});
 		deadCodeCollected = deadCodeFiber !== null ? yield* join(deadCodeFiber) : yield* buildCollectDeadCode({
 			workerTimeoutMs: sequentialDeadCodeTimeout.workerTimeoutMs,
-			phaseTimeoutMs: resolveDeadCodePhaseTimeoutMs(sequentialDeadCodeTimeout.phaseTimeoutMs)
+			phaseTimeoutMs: capToDeadline(resolveDeadCodePhaseTimeoutMs(sequentialDeadCodeTimeout.phaseTimeoutMs))
 		});
 	}
 	const deadCodeFailureState = lintFailureState.didFail ? {
@@ -40829,9 +41049,11 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 	else yield* scanProgress.succeed(`Scanned ${scannedFilesLabel} in ${scanElapsedSeconds}s${workerCountSuffix}`);
 	const supplyChainResult = yield* join(supplyChainFiber);
 	const supplyChainCollected = supplyChainResult.diagnostics;
+	const securityScanCollected = yield* join(securityScanFiber);
 	yield* reporterService.finalize;
 	const finalDiagnostics = sortDiagnosticsStable(assignFixGroups([
 		...envCollected,
+		...securityScanCollected,
 		...supplyChainCollected,
 		...lintCollected,
 		...deadCodeCollected
@@ -40851,12 +41073,13 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 	};
 	const scoreSurface = input.scoreSurface ?? "score";
 	const scoreDiagnostics = filterDiagnosticsForSurface([...finalDiagnostics], scoreSurface, resolvedConfig.config);
-	const score = lintFailureState.didFail ? null : yield* scoreService.compute({
+	const score = lintFailureState.didFail || deadCodeFailureState.didFail ? null : yield* scoreService.compute({
 		diagnostics: scoreDiagnostics,
 		isCi: input.isCi,
 		metadata: scoreMetadata
 	});
 	const lintPartialFailures = yield* get$2(partialFailuresRef);
+	const securityScanFailed = yield* get$2(securityScanFailedRef);
 	return {
 		project,
 		userConfig: resolvedConfig.config,
@@ -40877,8 +41100,10 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 		scanElapsedMilliseconds,
 		scanConcurrency,
 		supplyChainOverlapTimedOut: supplyChainResult.timedOut,
+		securityScanFailed,
 		lintCacheHitFileCount,
-		lintCacheTotalFileCount
+		lintCacheTotalFileCount,
+		suppressedRuleCounts: transform.summarizeSuppressions()
 	};
 }).pipe(withSpan("runInspect", { attributes: {
 	"inspect.directory": input.directory,
@@ -42903,6 +43128,7 @@ const SENTRY_FLUSH_TIMEOUT_MS = 2e3;
 const METRIC = {
 	cliInvoked: "cli.invoked",
 	cliError: "cli.error",
+	cliEnvironmentError: "cli.env_error",
 	projectDetected: "project.detected",
 	projectPathSelected: "project.path_selected",
 	projectConfigSelected: "project.config_selected",
@@ -42915,6 +43141,8 @@ const METRIC = {
 	scanCheckSkipped: "scan.check_skipped",
 	baselineDegraded: "baseline.degraded",
 	ruleFired: "rule.fired",
+	ruleDisabled: "rule.disabled",
+	ruleSuppressed: "rule.suppressed",
 	lintFailed: "lint.failed",
 	deadCodeFailed: "deadcode.failed",
 	scoreUnavailable: "score.unavailable",
@@ -42927,12 +43155,17 @@ const METRIC = {
 	installWorkflow: "install.workflow",
 	installAgentHooks: "install.agent_hooks",
 	installDependency: "install.dependency",
+	ciScaffolded: "ci.scaffolded",
+	ciUpgraded: "ci.upgraded",
+	ciConfigured: "ci.configured",
 	rulesChanged: "rules.changed",
 	rulesQueried: "rules.queried",
 	lspSessionStarted: "lsp.session.started",
 	lspScanCompleted: "lsp.scan.completed",
 	lspScanDuration: "lsp.scan.duration",
-	lspScanDiagnostics: "lsp.scan.diagnostics"
+	lspScanDiagnostics: "lsp.scan.diagnostics",
+	aiTrainingWarningShown: "ai.training.warning_shown",
+	jsonOutUsed: "json.out_used"
 };
 //#endregion
 //#region src/cli/utils/to-category-key.ts
@@ -43249,5 +43482,5 @@ const startLanguageServer = () => {
 };
 //#endregion
 export { startLanguageServer };
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="9ee72ccc-703c-588f-b7e4-c92657144721")}catch(e){}}();
-//# debugId=9ee72ccc-703c-588f-b7e4-c92657144721
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="6811672b-baa6-5b7c-b676-5121c592d4a0")}catch(e){}}();
+//# debugId=6811672b-baa6-5b7c-b676-5121c592d4a0