react-doctor 0.9.4 → 0.9.5-dev.4b03b15

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { FrameworkToken } from "oxlint-plugin-react-doctor/core";
+import fs from "node:fs";
 
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.70/node_modules/effect/dist/Types.d.ts
 /**
@@ -9833,13 +9834,13 @@ interface InspectResult {
    * Number of files the scan reported. Distinct from
    * `project.sourceFileCount` in diff / staged mode (where only changed
    * files are scanned). Optional so non-orchestrator constructors keep
-   * working; the multi-project summary falls back to
+   * working; the multi-project report falls back to
    * `project.sourceFileCount` when absent.
    */
   scannedFileCount?: number;
   /**
    * Absolute paths of every file the scan considered. Lets the
-   * multi-project summary count UNIQUE files across projects instead of
+   * multi-project report count UNIQUE files across projects instead of
    * summing per-project counts, which double-counts shared files when one
    * workspace package's tree is nested inside another's.
    */
@@ -9853,8 +9854,8 @@ interface InspectResult {
   /**
    * Wall-clock duration of the scan phase, in milliseconds. Distinct
    * from `elapsedMilliseconds` (which spans the full `inspect()` call
-   * including score fetch + rendering). Used by the multi-project
-   * summary to report combined scan time.
+   * including score fetch + reporting). Used by the multi-project
+   * report to show combined scan time.
    */
   scanElapsedMilliseconds?: number;
   /**

package/dist/index.js

@@ -1,5 +1,5 @@
 
-!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]="e18e3c42-e18e-5087-9b71-eb1bcb203d6b")}catch(e){}}();
+!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]="5415308a-0150-547d-9270-806382225dcf")}catch(e){}}();
 import { i as __toESM$1, r as __require, t as __commonJSMin$1 } from "./chunk-ChKA3wi6.js";
 import { createRequire } from "node:module";
 import { ALL_REACT_DOCTOR_RULE_KEYS, CROSS_FILE_DEPENDENCY_COLLECTORS, CROSS_FILE_RULE_IDS, FRAMEWORK_SPECIFIC_RULE_KEYS, FRAMEWORK_TOKENS, MOTION_LIBRARY_PACKAGES, REACT_COMPILER_RULES, REACT_DOCTOR_RULES, REACT_DOCTOR_RULE_REGISTRY, REACT_DOCTOR_SCAN_RULES, classifySecurityScanFile, collectCrossFileDependencyProbes, resetManifestCaches, shouldReadSecurityScanContent } from "oxlint-plugin-react-doctor/core";
@@ -17,8 +17,8 @@ import * as NodeUrl from "node:url";
 import { fileURLToPath } from "node:url";
 import * as OS from "node:os";
 import os from "node:os";
-import { parseJSON5 } from "confbox";
 import { createJiti } from "jiti";
+import { parseJSON5 } from "confbox";
 import { ANALYZED_MANIFEST_FILENAMES, DEFAULT_EXTENSIONS } from "deslop-js/analyzed-inputs";
 import { convertToTSX } from "@astrojs/compiler/sync";
 import { gzipSync } from "node:zlib";
@@ -62285,7 +62285,7 @@ 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 SIDECAR_LINT_CACHE_FILENAME = "sidecar-lint-cache.json";
-const CORE_PACKAGE_VERSION = "0.9.4";
+const CORE_PACKAGE_VERSION = "0.9.5";
 const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
 const DEAD_CODE_SUMMARY_CACHE_FILENAME = "dead-code-summaries.json";
 const SUPPLY_CHAIN_PLUGIN = "socket";
@@ -62298,17 +62298,20 @@ const SUPPLY_CHAIN_IGNORED_PACKAGES = new Set(["next"]);
 const isErrnoException = (error) => error instanceof Error && "code" in error;
 const IGNORABLE_READDIR_ERROR_CODES = new Set([
 	"EACCES",
+	"EBUSY",
 	"EPERM",
 	"ENOENT",
 	"ENOTDIR",
 	"EINVAL",
 	"ELOOP",
-	"ENAMETOOLONG"
+	"ENAMETOOLONG",
+	"ETIMEDOUT",
+	"UNKNOWN"
 ]);
 const isIgnorableReaddirError = (error) => isErrnoException(error) && typeof error.code === "string" && IGNORABLE_READDIR_ERROR_CODES.has(error.code);
 const readDirectoryEntries = (directoryPath) => {
 	try {
-		return NFS.readdirSync(directoryPath, { withFileTypes: true });
+		return fs.readdirSync(directoryPath, { withFileTypes: true });
 	} catch (error) {
 		if (isIgnorableReaddirError(error)) return [];
 		throw error;
@@ -62316,14 +62319,14 @@ const readDirectoryEntries = (directoryPath) => {
 };
 const isFile = (filePath) => {
 	try {
-		return NFS.statSync(filePath).isFile();
+		return fs.statSync(filePath).isFile();
 	} catch {
 		return false;
 	}
 };
 const isDirectory = (directoryPath) => {
 	try {
-		return NFS.statSync(directoryPath).isDirectory();
+		return fs.statSync(directoryPath).isDirectory();
 	} catch {
 		return false;
 	}
@@ -62753,7 +62756,12 @@ const mergeCompilerOptions = (inherited, current) => {
 	};
 };
 const readResolvedCompilerOptions = (tsConfigPath, extendsDepth, visitedPaths) => {
-	const realPath = NFS.realpathSync.native(tsConfigPath);
+	let realPath;
+	try {
+		realPath = NFS.realpathSync.native(tsConfigPath);
+	} catch {
+		return null;
+	}
 	if (visitedPaths.has(realPath)) return null;
 	const tsConfig = readTsConfig(realPath);
 	if (!tsConfig) return null;
@@ -63281,27 +63289,30 @@ const getSelectedObjectProperty = (expression, propertyName, analysis, visitedEx
 	}
 	return null;
 };
-const configExpressionMayDefineProperty = (expression, propertyName, analysis) => {
+const configExpressionMayDefineProperty = (expression, propertyName, analysis, visitedExpressions = /* @__PURE__ */ new Set()) => {
 	let resolvedExpression = expression;
 	while (ts.isParenthesizedExpression(resolvedExpression) || ts.isAsExpression(resolvedExpression) || ts.isTypeAssertionExpression(resolvedExpression) || ts.isSatisfiesExpression(resolvedExpression) || ts.isNonNullExpression(resolvedExpression)) resolvedExpression = resolvedExpression.expression;
+	if (visitedExpressions.has(resolvedExpression)) return true;
+	const nextVisitedExpressions = new Set(visitedExpressions);
+	nextVisitedExpressions.add(resolvedExpression);
 	if (ts.isIdentifier(resolvedExpression)) {
 		if (analysis.localBindings.has(resolvedExpression.text)) {
 			const localReference = analysis.localBindings.get(resolvedExpression.text);
-			return localReference?.expression ? configExpressionMayDefineProperty(localReference.expression, propertyName, localReference.analysis) : true;
+			return localReference?.expression ? configExpressionMayDefineProperty(localReference.expression, propertyName, localReference.analysis, nextVisitedExpressions) : true;
 		}
 		const scopedBinding = getScopedConfigBinding(resolvedExpression);
-		if (scopedBinding.wasFound) return scopedBinding.initializer ? configExpressionMayDefineProperty(scopedBinding.initializer, propertyName, analysis) : true;
+		if (scopedBinding.wasFound) return scopedBinding.initializer ? configExpressionMayDefineProperty(scopedBinding.initializer, propertyName, analysis, nextVisitedExpressions) : true;
 		const topLevelBinding = getTopLevelBinding(analysis.sourceFile, resolvedExpression.text);
-		return topLevelBinding && ts.isExpression(topLevelBinding) ? configExpressionMayDefineProperty(topLevelBinding, propertyName, analysis) : true;
+		return topLevelBinding && ts.isExpression(topLevelBinding) ? configExpressionMayDefineProperty(topLevelBinding, propertyName, analysis, nextVisitedExpressions) : true;
 	}
 	if (ts.isConditionalExpression(resolvedExpression)) {
-		if (isStaticallyTruthyConfigExpression(resolvedExpression.condition, analysis)) return configExpressionMayDefineProperty(resolvedExpression.whenTrue, propertyName, analysis);
-		if (isStaticallyDisabledConfigExpression(resolvedExpression.condition, analysis)) return configExpressionMayDefineProperty(resolvedExpression.whenFalse, propertyName, analysis);
-		return configExpressionMayDefineProperty(resolvedExpression.whenTrue, propertyName, analysis) || configExpressionMayDefineProperty(resolvedExpression.whenFalse, propertyName, analysis);
+		if (isStaticallyTruthyConfigExpression(resolvedExpression.condition, analysis)) return configExpressionMayDefineProperty(resolvedExpression.whenTrue, propertyName, analysis, nextVisitedExpressions);
+		if (isStaticallyDisabledConfigExpression(resolvedExpression.condition, analysis)) return configExpressionMayDefineProperty(resolvedExpression.whenFalse, propertyName, analysis, nextVisitedExpressions);
+		return configExpressionMayDefineProperty(resolvedExpression.whenTrue, propertyName, analysis, nextVisitedExpressions) || configExpressionMayDefineProperty(resolvedExpression.whenFalse, propertyName, analysis, nextVisitedExpressions);
 	}
 	if (!ts.isObjectLiteralExpression(resolvedExpression)) return true;
 	return resolvedExpression.properties.some((property) => {
-		if (ts.isSpreadAssignment(property)) return configExpressionMayDefineProperty(property.expression, propertyName, analysis);
+		if (ts.isSpreadAssignment(property)) return configExpressionMayDefineProperty(property.expression, propertyName, analysis, nextVisitedExpressions);
 		if (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property) || ts.isMethodDeclaration(property) || ts.isGetAccessorDeclaration(property) || ts.isSetAccessorDeclaration(property)) {
 			const staticPropertyName = getStaticPropertyName$2(property.name);
 			return staticPropertyName === null || staticPropertyName === propertyName;
@@ -63377,7 +63388,13 @@ const analyzeConfigModuleExport = (filePath, exportName, allowCompilerTransform,
 	if (visitedModules.has(moduleVisitKey)) return false;
 	const nextVisitedModules = new Set(visitedModules);
 	nextVisitedModules.add(moduleVisitKey);
-	return analyzeConfigSourceFileExport(parseConfigSourceFile(filePath, NFS.readFileSync(filePath, "utf-8")), filePath, exportName, allowCompilerTransform, importDepth, nextVisitedModules, argumentsList, argumentAnalysis);
+	let sourceText;
+	try {
+		sourceText = NFS.readFileSync(filePath, "utf-8");
+	} catch {
+		return false;
+	}
+	return analyzeConfigSourceFileExport(parseConfigSourceFile(filePath, sourceText), filePath, exportName, allowCompilerTransform, importDepth, nextVisitedModules, argumentsList, argumentAnalysis);
 };
 const analyzeConfigSourceFileExport = (sourceFile, filePath, exportName, allowCompilerTransform, importDepth, visitedModules, argumentsList = [], argumentAnalysis) => {
 	const analysis = {
@@ -66786,6 +66803,11 @@ var DeadCodeResultCacheEnabled = class extends Reference("react-doctor/DeadCodeR
 	if (CACHE_DISABLED_VALUES.has(noDeadCodeCache)) return false;
 	return true;
 } }) {};
+const importDefaultExport = async (jitiInstance, filePath) => {
+	const imported = await jitiInstance.import(filePath);
+	return imported?.default ?? imported;
+};
+const readJson5File = (filePath) => parseJSON5(NFS.readFileSync(filePath, "utf-8"));
 const DIAGNOSTIC_SURFACES = [
 	"cli",
 	"prComment",
@@ -66880,6 +66902,43 @@ const validateStringArrayField = (fieldName, value) => {
 		return false;
 	});
 };
+const validateIgnoreOverride = (rawOverride, index) => {
+	const fieldName = `ignore.overrides[${index}]`;
+	if (!isRecord(rawOverride)) {
+		warnConfigIssue(`config field "${fieldName}" must be an object (got ${typeof rawOverride}); ignoring this override.`);
+		return;
+	}
+	const files = validateStringArrayField(`${fieldName}.files`, rawOverride.files);
+	if (files === void 0) return void 0;
+	const validatedOverride = { files };
+	if (rawOverride.rules !== void 0) {
+		const rules = validateStringArrayField(`${fieldName}.rules`, rawOverride.rules);
+		if (rules !== void 0) validatedOverride.rules = rules;
+	}
+	return validatedOverride;
+};
+const validateIgnoreField = (rawIgnore) => {
+	if (!isRecord(rawIgnore)) {
+		warnConfigIssue(`config field "ignore" must be an object (got ${typeof rawIgnore}); ignoring this field.`);
+		return;
+	}
+	const validatedIgnore = {};
+	for (const fieldName of [
+		"rules",
+		"files",
+		"tags"
+	]) {
+		if (rawIgnore[fieldName] === void 0) continue;
+		const validatedValues = validateStringArrayField(`ignore.${fieldName}`, rawIgnore[fieldName]);
+		if (validatedValues !== void 0) validatedIgnore[fieldName] = validatedValues;
+	}
+	if (rawIgnore.overrides !== void 0) if (!Array.isArray(rawIgnore.overrides)) warnConfigIssue(`config field "ignore.overrides" must be an array (got ${typeof rawIgnore.overrides}); ignoring this field.`);
+	else validatedIgnore.overrides = rawIgnore.overrides.flatMap((rawOverride, index) => {
+		const validatedOverride = validateIgnoreOverride(rawOverride, index);
+		return validatedOverride ? [validatedOverride] : [];
+	});
+	return validatedIgnore;
+};
 const validateSurfaceControls = (surface, rawControls) => {
 	if (!isRecord(rawControls)) {
 		warnConfigIssue(`config field "surfaces.${surface}" must be an object (got ${typeof rawControls}); ignoring this surface.`);
@@ -66955,6 +67014,7 @@ const validateConfigTypes = (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, "ignore", validateIgnoreField);
 	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));
@@ -66978,11 +67038,7 @@ const DATA_CONFIG_EXTENSIONS = new Set(["json", "jsonc"]);
 const PACKAGE_JSON_FILENAME = "package.json";
 const PACKAGE_JSON_CONFIG_KEY = "reactDoctor";
 const LEGACY_CONFIG_FILENAME = "react-doctor.config.json";
-const jiti = createJiti(import.meta.url);
-const importDefaultExport = async (jitiInstance, filePath) => {
-	const imported = await jitiInstance.import(filePath);
-	return imported?.default ?? imported;
-};
+const jiti$1 = createJiti(import.meta.url);
 const SELF_PACKAGE_IMPORT_SPECIFIER = "react-doctor/api";
 const SELF_PACKAGE_RESOLVE_TARGETS = ["react-doctor/api", "@react-doctor/core"];
 const MODULE_NOT_FOUND_ERROR_CODES = new Set(["MODULE_NOT_FOUND", "ERR_MODULE_NOT_FOUND"]);
@@ -66990,7 +67046,7 @@ let selfAliasJiti;
 const getSelfAliasJiti = () => {
 	if (selfAliasJiti !== void 0) return selfAliasJiti;
 	for (const resolveTarget of SELF_PACKAGE_RESOLVE_TARGETS) try {
-		const aliasTargetPath = fileURLToPath(jiti.esmResolve(resolveTarget));
+		const aliasTargetPath = fileURLToPath(jiti$1.esmResolve(resolveTarget));
 		selfAliasJiti = createJiti(import.meta.url, { alias: { [SELF_PACKAGE_IMPORT_SPECIFIER]: aliasTargetPath } });
 		return selfAliasJiti;
 	} catch {
@@ -67002,7 +67058,7 @@ const getSelfAliasJiti = () => {
 const isSelfPackageResolutionError = (error) => error instanceof Error && "code" in error && typeof error.code === "string" && MODULE_NOT_FOUND_ERROR_CODES.has(error.code) && error.message.includes(SELF_PACKAGE_IMPORT_SPECIFIER);
 const loadModuleConfig = async (filePath) => {
 	try {
-		return await importDefaultExport(jiti, filePath);
+		return await importDefaultExport(jiti$1, filePath);
 	} catch (error) {
 		if (!isSelfPackageResolutionError(error)) throw error;
 		const aliasJiti = getSelfAliasJiti();
@@ -67014,12 +67070,11 @@ const loadModuleConfig = async (filePath) => {
 		}
 	}
 };
-const readDataConfig = (filePath) => parseJSON5(NFS.readFileSync(filePath, "utf-8"));
 const readEmbeddedPackageJsonConfig = (directory) => {
 	const packageJsonPath = Path.join(directory, PACKAGE_JSON_FILENAME);
 	if (!isFile(packageJsonPath)) return null;
 	try {
-		const packageJson = parseJSON5(NFS.readFileSync(packageJsonPath, "utf-8"));
+		const packageJson = readJson5File(packageJsonPath);
 		if (isPlainObject(packageJson)) {
 			const embeddedConfig = packageJson[PACKAGE_JSON_CONFIG_KEY];
 			if (isPlainObject(embeddedConfig)) return embeddedConfig;
@@ -67044,7 +67099,7 @@ const loadLegacyConfig = (directory) => {
 		loaded: null
 	};
 	try {
-		const parsed = readDataConfig(legacyFilePath);
+		const parsed = readJson5File(legacyFilePath);
 		if (isPlainObject(parsed)) {
 			warn(`${LEGACY_CONFIG_FILENAME} is deprecated — rename it to ${CONFIG_BASENAME}.json (or author a ${CONFIG_BASENAME}.ts). It is still read for now.`);
 			return {
@@ -67073,7 +67128,7 @@ const loadConfigFromDirectory = async (directory) => {
 		if (!isFile(filePath)) continue;
 		const isDataFile = DATA_CONFIG_EXTENSIONS.has(extension);
 		try {
-			const parsed = isDataFile ? readDataConfig(filePath) : await loadModuleConfig(filePath);
+			const parsed = isDataFile ? readJson5File(filePath) : await loadModuleConfig(filePath);
 			if (isPlainObject(parsed)) return {
 				status: "found",
 				loaded: {
@@ -68619,7 +68674,7 @@ const collectScriptMotionEvidence = (sourceFile, typeChecker, program) => {
 			if (calleeEvidence.isReducedMotionHook && isExpressionValueConsumed(node)) evidence.hasReducedMotionHandling = true;
 		}
 		if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
-			const tagEvidence = ts.isJsxNamespacedName(node.tagName) ? EMPTY_MOTION_EXPRESSION_EVIDENCE : resolveMotionExpressionEvidence(node.tagName, typeChecker, program);
+			const tagEvidence = ts.isIdentifier(node.tagName) || ts.isPropertyAccessExpression(node.tagName) ? resolveMotionExpressionEvidence(node.tagName, typeChecker, program) : EMPTY_MOTION_EXPRESSION_EVIDENCE;
 			if (tagEvidence.isMotionComponent || tagEvidence.isMotionComponentFactory) evidence.hasMotionUse = true;
 			if (tagEvidence.isMotionConfig && jsxElementHasReducedMotionConfiguration(node.attributes, typeChecker)) evidence.hasReducedMotionHandling = true;
 		}
@@ -69275,20 +69330,45 @@ const collectIgnorePatterns = (rootDirectory) => {
 	cachedPatternsByRoot.set(rootDirectory, patterns);
 	return patterns;
 };
-const failOpenReadJson = (filePath, fallback) => {
+const KNIP_DATA_CONFIG_FILENAMES = new Set([
+	"knip.json",
+	"knip.jsonc",
+	".knip.json",
+	".knip.jsonc"
+]);
+const KNIP_CONFIG_FILENAMES = [
+	...KNIP_DATA_CONFIG_FILENAMES,
+	"knip.ts",
+	"knip.js",
+	"knip.config.ts",
+	"knip.config.js"
+];
+const jiti = createJiti(import.meta.url, { moduleCache: false });
+const resolveKnipConfigExport = async (configExport) => {
+	const config = typeof configExport === "function" ? await configExport() : await configExport;
+	return isRecord(config) ? config : null;
+};
+const loadKnipConfigFile = async (configFilename, filePath) => {
 	try {
-		return JSON.parse(NFS.readFileSync(filePath, "utf8"));
+		return await resolveKnipConfigExport(KNIP_DATA_CONFIG_FILENAMES.has(configFilename) ? readJson5File(filePath) : await importDefaultExport(jiti, filePath));
 	} catch {
-		return fallback;
+		return null;
 	}
 };
-const KNIP_JSON_FILENAME = "knip.json";
-const readKnipConfig = (rootDirectory) => {
-	const knipJson = failOpenReadJson(path.join(rootDirectory, KNIP_JSON_FILENAME), null);
-	if (isRecord(knipJson)) return knipJson;
-	const packageJson = failOpenReadJson(path.join(rootDirectory, "package.json"), null);
-	const packageKnipConfig = isRecord(packageJson) ? packageJson.knip : null;
-	return isRecord(packageKnipConfig) ? packageKnipConfig : null;
+const loadKnipConfig = async (rootDirectory) => {
+	for (const configFilename of KNIP_CONFIG_FILENAMES) {
+		const filePath = path.join(rootDirectory, configFilename);
+		if (!isFile(filePath)) continue;
+		const config = await loadKnipConfigFile(configFilename, filePath);
+		if (config) return config;
+	}
+	try {
+		const packageJson = readJson5File(path.join(rootDirectory, "package.json"));
+		const packageKnipConfig = isRecord(packageJson) ? packageJson.knip : null;
+		return isRecord(packageKnipConfig) ? packageKnipConfig : null;
+	} catch {
+		return null;
+	}
 };
 const normalizePatternList = (value) => {
 	if (typeof value === "string" && value.length > 0) return [value];
@@ -69308,22 +69388,28 @@ const collectKnipWorkspacePatterns = (workspaces, settingName) => {
 	}
 	return patterns;
 };
-const collectKnipPatterns = (rootDirectory, settingName) => {
-	const config = readKnipConfig(rootDirectory);
+const collectKnipPatterns = (config, settingName) => {
 	if (!config) return [];
 	return [...normalizePatternList(config[settingName]), ...collectKnipWorkspacePatterns(config.workspaces, settingName)];
 };
-const collectDeadCodeIgnorePatterns = (rootDirectory) => {
+const collectDeadCodeIgnorePatterns = (rootDirectory, config) => {
 	const seen = /* @__PURE__ */ new Set();
 	const sources = [
 		readIgnoreFile(path.join(rootDirectory, ".gitignore")),
 		collectIgnorePatterns(rootDirectory),
-		collectKnipPatterns(rootDirectory, "ignore")
+		collectKnipPatterns(config, "ignore")
 	];
 	for (const source of sources) for (const pattern of source) seen.add(pattern);
 	return [...seen].filter((pattern) => pattern.length > 0);
 };
-const collectDeadCodeEntryPatterns = (rootDirectory) => [...new Set(collectKnipPatterns(rootDirectory, "entry"))].filter((pattern) => pattern.length > 0);
+const collectDeadCodeEntryPatterns = (config) => [...new Set(collectKnipPatterns(config, "entry"))].filter((pattern) => pattern.length > 0);
+const collectDeadCodePatterns = async (rootDirectory) => {
+	const config = await loadKnipConfig(rootDirectory);
+	return {
+		entryPatterns: collectDeadCodeEntryPatterns(config),
+		ignorePatterns: collectDeadCodeIgnorePatterns(rootDirectory, config)
+	};
+};
 const atomicWriteJson = (filePath, value) => {
 	try {
 		NFS.mkdirSync(Path.dirname(filePath), { recursive: true });
@@ -69334,6 +69420,13 @@ const atomicWriteJson = (filePath, value) => {
 		return;
 	}
 };
+const failOpenReadJson = (filePath, fallback) => {
+	try {
+		return JSON.parse(NFS.readFileSync(filePath, "utf8"));
+	} catch {
+		return fallback;
+	}
+};
 const hashFileContents = (filePath) => {
 	try {
 		return crypto.createHash("sha1").update(NFS.readFileSync(filePath)).digest("hex");
@@ -69342,7 +69435,7 @@ const hashFileContents = (filePath) => {
 	}
 };
 const ANALYZED_FILE_EXTENSIONS = new Set(DEFAULT_EXTENSIONS);
-const CORE_SIDE_MANIFEST_NAMES = ["knip.json", "deno.lock"];
+const CORE_SIDE_MANIFEST_NAMES = [...KNIP_CONFIG_FILENAMES, "deno.lock"];
 const ANALYZED_MANIFEST_NAMES = new Set([...ANALYZED_MANIFEST_FILENAMES, ...CORE_SIDE_MANIFEST_NAMES]);
 const isTsConfigLikeFile = (fileName) => (fileName.startsWith("tsconfig") || fileName.startsWith("jsconfig")) && fileName.endsWith(".json");
 const isFingerprintedFile = (fileName) => ANALYZED_FILE_EXTENSIONS.has(Path.extname(fileName).toLowerCase()) || ANALYZED_MANIFEST_NAMES.has(fileName) || isTsConfigLikeFile(fileName);
@@ -69868,8 +69961,7 @@ const runDeadCodeWorkerWithTimeout = (handle, timeoutMs, abortSignal) => new Pro
 const checkDeadCode = async (options) => {
 	const rootDirectory = toCanonicalPath(options.rootDirectory);
 	if (!NFS.existsSync(Path.join(rootDirectory, "package.json"))) return [];
-	const entryPatterns = collectDeadCodeEntryPatterns(rootDirectory);
-	const ignorePatterns = collectDeadCodeIgnorePatterns(rootDirectory);
+	const { entryPatterns, ignorePatterns } = await collectDeadCodePatterns(rootDirectory);
 	const tsConfigPath = resolveTsConfigPath(rootDirectory);
 	const deslopJsModuleSpecifier = options.deslopJsModuleSpecifier ?? import.meta.resolve("deslop-js");
 	const fileStatsSnapshot = options.cacheEnabled ? collectAnalyzedFileStats(rootDirectory) : null;
@@ -70603,7 +70695,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 					changedFiles: yield* mergeUntracked(directory, splitNullSeparated(diff.stdout), includeUntracked),
 					isCurrentChanges: false
 				};
-			}).pipe(withSpan("Git.diffSelection")),
+			}).pipe(catchReasons("ReactDoctorError", { GitInvocationFailed: () => succeed$2(null) }, (_reason, error) => fail$4(error)), withSpan("Git.diffSelection")),
 			stagedFilePaths: (directory) => runGit(directory, [
 				"diff",
 				"--no-ext-diff",
@@ -70819,6 +70911,33 @@ const detectUserLintConfigPaths = (rootDirectory) => {
 	return [];
 };
 const DISABLE_DIRECTIVE_PATTERN = /(eslint|oxlint)-disable/;
+const neutralizedFileLeases = /* @__PURE__ */ new Map();
+const activeNeutralizationInitializations = /* @__PURE__ */ new Set();
+const directoriesOverlap = (left, right) => {
+	const isWithin = (parent, candidate) => {
+		const relativePath = Path.relative(parent, candidate);
+		return relativePath.length === 0 || !relativePath.startsWith(`..${Path.sep}`) && relativePath !== ".." && !Path.isAbsolute(relativePath);
+	};
+	return isWithin(left, right) || isWithin(right, left);
+};
+const withOverlappingInitializationLock = async (rootDirectory, operation) => {
+	const blockers = [...activeNeutralizationInitializations].filter((initialization) => directoriesOverlap(initialization.rootDirectory, rootDirectory)).map((initialization) => initialization.done);
+	let release;
+	const initialization = {
+		rootDirectory,
+		done: new Promise((resolve) => {
+			release = resolve;
+		})
+	};
+	activeNeutralizationInitializations.add(initialization);
+	await Promise.all(blockers);
+	try {
+		return await operation();
+	} finally {
+		activeNeutralizationInitializations.delete(initialization);
+		release();
+	}
+};
 const findFilesWithDisableDirectivesViaGit = async (rootDirectory, includePaths) => {
 	const program = gen(function* () {
 		return yield* (yield* Git).grep({
@@ -70861,34 +70980,84 @@ const findFilesWithDisableDirectivesViaFilesystem = (rootDirectory, includePaths
 };
 const findFilesWithDisableDirectives = async (rootDirectory, includePaths) => await findFilesWithDisableDirectivesViaGit(rootDirectory, includePaths) ?? findFilesWithDisableDirectivesViaFilesystem(rootDirectory, includePaths);
 const neutralizeContent = (content) => content.replaceAll("eslint-disable", "eslint_disable").replaceAll("oxlint-disable", "oxlint_disable");
-const neutralizeDisableDirectives = async (rootDirectory, includePaths) => {
-	const filePaths = await findFilesWithDisableDirectives(rootDirectory, includePaths);
-	const originalContents = /* @__PURE__ */ new Map();
+const collectNeutralizationCandidatePaths = (rootDirectory, discoveredRelativePaths, includePaths) => {
+	const resolvedRootDirectory = NFS.realpathSync(rootDirectory);
+	const requestedPaths = includePaths && includePaths.length > 0 ? new Set(includePaths.flatMap((includePath) => {
+		try {
+			return [NFS.realpathSync(Path.resolve(resolvedRootDirectory, includePath))];
+		} catch {
+			return [];
+		}
+	})) : null;
+	const candidatePaths = /* @__PURE__ */ new Set();
+	for (const relativePath of discoveredRelativePaths) try {
+		candidatePaths.add(NFS.realpathSync(Path.resolve(resolvedRootDirectory, relativePath)));
+	} catch {
+		continue;
+	}
+	for (const leasedPath of neutralizedFileLeases.keys()) {
+		const relativePath = Path.relative(resolvedRootDirectory, leasedPath);
+		if (!(relativePath.length === 0 || !relativePath.startsWith(`..${Path.sep}`) && relativePath !== ".." && !Path.isAbsolute(relativePath)) || requestedPaths && !requestedPaths.has(leasedPath)) continue;
+		candidatePaths.add(leasedPath);
+	}
+	return candidatePaths;
+};
+const neutralizeDisableDirectives = async (rootDirectory, includePaths, options = {}) => {
+	const resolvedRootDirectory = NFS.realpathSync(rootDirectory);
+	const leasedPaths = /* @__PURE__ */ new Set();
 	let isRestored = false;
 	const restore = () => {
 		if (isRestored) return;
 		isRestored = true;
-		for (const [absolutePath, originalContent] of originalContents) try {
-			NFS.writeFileSync(absolutePath, originalContent);
-		} catch (error) {
-			process.stderr.write(`[react-doctor] Failed to restore inline disable directives in ${absolutePath}: ${messageFromUnknown(error)}\n[react-doctor] Run: git checkout -- ${absolutePath}\n`);
+		for (const absolutePath of leasedPaths) {
+			const lease = neutralizedFileLeases.get(absolutePath);
+			if (!lease) continue;
+			lease.referenceCount -= 1;
+			if (lease.referenceCount > 0) continue;
+			neutralizedFileLeases.delete(absolutePath);
+			try {
+				NFS.writeFileSync(absolutePath, lease.originalContent);
+			} catch (error) {
+				process.stderr.write(`[react-doctor] Failed to restore inline disable directives in ${absolutePath}: ${messageFromUnknown(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);
+	const leaseCandidatePath = (absolutePath) => {
+		if (leasedPaths.has(absolutePath)) return;
+		const existingLease = neutralizedFileLeases.get(absolutePath);
+		if (existingLease) {
+			existingLease.referenceCount += 1;
+			leasedPaths.add(absolutePath);
+			return;
+		}
 		let originalContent;
 		try {
 			originalContent = NFS.readFileSync(absolutePath, "utf-8");
 		} catch {
-			continue;
+			return;
 		}
 		const neutralizedContent = neutralizeContent(originalContent);
 		if (neutralizedContent !== originalContent) {
-			originalContents.set(absolutePath, originalContent);
 			NFS.writeFileSync(absolutePath, neutralizedContent);
+			neutralizedFileLeases.set(absolutePath, {
+				originalContent,
+				referenceCount: 1
+			});
+			leasedPaths.add(absolutePath);
 		}
+	};
+	try {
+		await withOverlappingInitializationLock(resolvedRootDirectory, async () => {
+			for (const absolutePath of collectNeutralizationCandidatePaths(resolvedRootDirectory, [], includePaths)) if (neutralizedFileLeases.has(absolutePath)) leaseCandidatePath(absolutePath);
+			const discoveredRelativePaths = await (options.findFiles ?? findFilesWithDisableDirectives)(resolvedRootDirectory, includePaths);
+			for (const absolutePath of collectNeutralizationCandidatePaths(resolvedRootDirectory, discoveredRelativePaths, includePaths)) leaseCandidatePath(absolutePath);
+		});
+	} catch (error) {
+		restore();
+		process.removeListener("exit", onExit);
+		throw error;
 	}
 	return () => {
 		restore();
@@ -75223,7 +75392,7 @@ const materializeSourceTree = (input) => gen(function* () {
 			const sourcePath = path.join(input.directory, subdirectory, configFilename);
 			const targetPath = path.resolve(resolvedTempDirectory, subdirectory, configFilename);
 			if (!isPathInsideDirectory(targetPath, resolvedTempDirectory)) continue;
-			if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) {
+			if (isFile(sourcePath) && !fs.existsSync(targetPath)) {
 				fs.mkdirSync(path.dirname(targetPath), { recursive: true });
 				fs.cpSync(sourcePath, targetPath);
 			}
@@ -75564,16 +75733,17 @@ const detectAiTrainingEnvironment = (environment = process.env) => {
 	for (const [environmentVariable, label] of AI_TRAINING_BY_ENVIRONMENT_VARIABLE) if (environment[environmentVariable]?.trim()) return label;
 	return null;
 };
-const unionValues = (baseValues, overrideValues) => [...new Set([...baseValues, ...overrideValues])];
+const stringValues = (values) => Array.isArray(values) ? values.filter((value) => typeof value === "string") : [];
+const unionValues = (baseValues, overrideValues) => [...new Set([...stringValues(baseValues), ...stringValues(overrideValues)])];
 const mergeIgnores = (baseIgnore, overrideIgnore) => {
 	const mergedIgnore = {
 		...baseIgnore,
 		...overrideIgnore
 	};
-	if (baseIgnore.rules && overrideIgnore.rules) mergedIgnore.rules = unionValues(baseIgnore.rules, overrideIgnore.rules);
-	if (baseIgnore.files && overrideIgnore.files) mergedIgnore.files = unionValues(baseIgnore.files, overrideIgnore.files);
-	if (baseIgnore.tags && overrideIgnore.tags) mergedIgnore.tags = unionValues(baseIgnore.tags, overrideIgnore.tags);
-	if (baseIgnore.overrides && overrideIgnore.overrides) mergedIgnore.overrides = [...baseIgnore.overrides, ...overrideIgnore.overrides];
+	if (baseIgnore.rules !== void 0 || overrideIgnore.rules !== void 0) mergedIgnore.rules = unionValues(baseIgnore.rules, overrideIgnore.rules);
+	if (baseIgnore.files !== void 0 || overrideIgnore.files !== void 0) mergedIgnore.files = unionValues(baseIgnore.files, overrideIgnore.files);
+	if (baseIgnore.tags !== void 0 || overrideIgnore.tags !== void 0) mergedIgnore.tags = unionValues(baseIgnore.tags, overrideIgnore.tags);
+	if (baseIgnore.overrides !== void 0 || overrideIgnore.overrides !== void 0) mergedIgnore.overrides = [...Array.isArray(baseIgnore.overrides) ? baseIgnore.overrides : [], ...Array.isArray(overrideIgnore.overrides) ? overrideIgnore.overrides : []];
 	return mergedIgnore;
 };
 /**
@@ -75781,4 +75951,4 @@ const toJsonReport = (result, options) => buildJsonReport({
 export { AmbiguousProjectError, NoReactDependencyError, NotADirectoryError, PackageJsonNotFoundError, ProjectNotFoundError, ReactDoctorError, buildJsonReport, buildJsonReportError, clearCaches, defineConfig, diagnose, filterSourceFiles, getDiffInfo, hasReactRuntime, isProjectDiscoveryError, isReactDoctorError, summarizeDiagnostics, toJsonReport };
 
 //# sourceMappingURL=index.js.map
-//# debugId=e18e3c42-e18e-5087-9b71-eb1bcb203d6b
+//# debugId=5415308a-0150-547d-9270-806382225dcf