react-doctor 0.7.6-dev.fbd85e3 → 0.7.7-dev.04c7e36

package/dist/lsp.js

@@ -32959,7 +32959,6 @@ 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;
@@ -33092,7 +33091,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.7.6";
+const CORE_PACKAGE_VERSION = "0.7.7";
 const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
 const DEAD_CODE_SUMMARY_CACHE_FILENAME = "dead-code-summaries.json";
 const SUPPLY_CHAIN_PLUGIN = "socket";
@@ -33195,13 +33194,15 @@ const listSourceFilesViaFilesystem = (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 UTF8_BOM_CHARACTER = "";
+const stripUtf8Bom = (content) => content.startsWith(UTF8_BOM_CHARACTER) ? content.slice(1) : content;
 const cachedPackageJsons = /* @__PURE__ */ new Map();
 const clearPackageJsonCache = () => {
 	cachedPackageJsons.clear();
 };
 const readPackageJsonUncached = (packageJsonPath) => {
 	try {
-		return JSON.parse(NFS.readFileSync(packageJsonPath, "utf-8"));
+		return JSON.parse(stripUtf8Bom(NFS.readFileSync(packageJsonPath, "utf-8")));
 	} catch (error) {
 		if (error instanceof SyntaxError) return {};
 		if (isErrnoException(error)) {
@@ -36343,6 +36344,49 @@ const assignFixGroups = (diagnostics) => {
 		};
 	});
 };
+const DERIVED_STATE_RULE_PRIORITY = new Map([
+	["no-initialize-state", 0],
+	["no-adjust-state-on-prop-change", 1],
+	["no-derived-state", 2],
+	["no-derived-state-effect", 3]
+]);
+const buildDiagnosticSiteKey = (diagnostic) => `${diagnostic.filePath}\u0000${diagnostic.line}\u0000${diagnostic.column}`;
+const isReactDoctorRulesOfHooksDiagnostic = (diagnostic) => diagnostic.plugin === "react-doctor" && diagnostic.rule === "rules-of-hooks";
+const isReactCompilerHooksDiagnostic = (diagnostic) => diagnostic.plugin === "react-hooks-js" && diagnostic.rule === "hooks";
+const doDiagnosticSpansOverlap = (first, second) => {
+	if (first.filePath !== second.filePath || first.plugin !== second.plugin) return false;
+	if (first.offset !== void 0 && second.offset !== void 0) {
+		const firstEnd = first.offset + Math.max(first.length ?? 1, 1);
+		const secondEnd = second.offset + Math.max(second.length ?? 1, 1);
+		return first.offset < secondEnd && second.offset < firstEnd;
+	}
+	const firstEndLine = first.endLine ?? first.line;
+	const secondEndLine = second.endLine ?? second.line;
+	return first.line <= secondEndLine && second.line <= firstEndLine;
+};
+const keepHighestSeverity = (survivingDiagnostic, collapsedDiagnostic) => collapsedDiagnostic.severity === "error" && survivingDiagnostic.severity !== "error" ? {
+	...survivingDiagnostic,
+	severity: "error"
+} : survivingDiagnostic;
+const dedupeRelatedDiagnostics = (diagnostics) => {
+	const reactDoctorHookSites = new Set(diagnostics.filter(isReactDoctorRulesOfHooksDiagnostic).map(buildDiagnosticSiteKey));
+	const uniqueDiagnostics = [];
+	for (const diagnostic of diagnostics) {
+		if (isReactCompilerHooksDiagnostic(diagnostic) && reactDoctorHookSites.has(buildDiagnosticSiteKey(diagnostic))) continue;
+		const priority = DERIVED_STATE_RULE_PRIORITY.get(diagnostic.rule);
+		if (priority !== void 0) {
+			const overlappingDiagnosticIndex = uniqueDiagnostics.findIndex((candidate) => candidate.rule !== diagnostic.rule && DERIVED_STATE_RULE_PRIORITY.has(candidate.rule) && doDiagnosticSpansOverlap(candidate, diagnostic));
+			if (overlappingDiagnosticIndex >= 0) {
+				const existingDiagnostic = uniqueDiagnostics[overlappingDiagnosticIndex];
+				const existingPriority = existingDiagnostic ? DERIVED_STATE_RULE_PRIORITY.get(existingDiagnostic.rule) : void 0;
+				if (existingDiagnostic && existingPriority !== void 0) uniqueDiagnostics[overlappingDiagnosticIndex] = priority < existingPriority ? keepHighestSeverity(diagnostic, existingDiagnostic) : keepHighestSeverity(existingDiagnostic, diagnostic);
+				continue;
+			}
+		}
+		uniqueDiagnostics.push(diagnostic);
+	}
+	return uniqueDiagnostics;
+};
 const compareStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 const sortDiagnosticsStable = (diagnostics) => [...diagnostics].sort((left, right) => compareStrings(left.filePath, right.filePath) || left.line - right.line || left.column - right.column || compareStrings(left.plugin, right.plugin) || compareStrings(left.rule, right.rule) || compareStrings(left.severity, right.severity) || compareStrings(left.message, right.message));
 const getDirectDependencyNames = (packageJson) => new Set([...Object.keys(packageJson.dependencies ?? {}), ...Object.keys(packageJson.devDependencies ?? {})]);
@@ -36768,7 +36812,6 @@ const PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
 const PNPM_LOCKFILE = "pnpm-lock.yaml";
 const PACKAGE_JSON_FILE = "package.json";
 const PNPM_HARDENING_RULE_KEY = "require-pnpm-hardening";
-const UTF8_BOM_CHAR = "";
 const HARDENING_SETTING_KEYS = new Set([
 	"minimumReleaseAge",
 	"blockExoticSubdeps",
@@ -36793,12 +36836,11 @@ const stripInlineComment = (rawValue) => {
 	return rawValue;
 };
 const unquote = (rawValue) => rawValue.replace(/^["']|["']$/g, "");
-const stripBom = (rawContent) => rawContent.startsWith(UTF8_BOM_CHAR) ? rawContent.slice(1) : rawContent;
 const parseHardeningSettings = (content) => {
 	let minimumReleaseAge = null;
 	let blockExoticSubdeps = null;
 	let trustPolicy = null;
-	const lines = stripBom(content).split(/\r?\n/);
+	const lines = stripUtf8Bom(content).split(/\r?\n/);
 	for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
 		const lineText = lines[lineIndex];
 		if (lineText === void 0) continue;
@@ -36832,7 +36874,7 @@ const isPnpmManagedProject = (rootDirectory) => {
 	const packageJsonPath = Path.join(rootDirectory, PACKAGE_JSON_FILE);
 	if (!isFile(packageJsonPath)) return false;
 	try {
-		const packageJsonRaw = NFS.readFileSync(packageJsonPath, "utf-8");
+		const packageJsonRaw = stripUtf8Bom(NFS.readFileSync(packageJsonPath, "utf-8"));
 		const packageJson = JSON.parse(packageJsonRaw);
 		if (packageJson !== null && typeof packageJson === "object" && "packageManager" in packageJson && typeof packageJson.packageManager === "string" && packageJson.packageManager.startsWith("pnpm@")) return true;
 	} catch {
@@ -37118,18 +37160,45 @@ const checkReactServerComponentsAdvisory = (scanDirectory, project) => {
 	}
 	return diagnostics;
 };
-const REDUCED_MOTION_GREP_PATTERN = "prefers-reduced-motion|useReducedMotion|MotionConfig|reducedMotion";
-const REDUCED_MOTION_PATTERN = new RegExp(REDUCED_MOTION_GREP_PATTERN);
-const REDUCED_MOTION_FILE_EXTENSIONS = new Set([
+const getTypescriptScriptKind = (fileName) => {
+	if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (fileName.endsWith(".ts")) return ts.ScriptKind.TS;
+	return ts.ScriptKind.JS;
+};
+const unwrapTypescriptExpression = (expression) => {
+	let currentExpression = expression;
+	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
+	return currentExpression;
+};
+const EMPTY_MOTION_EXPRESSION_EVIDENCE = {
+	isAnimationFunction: false,
+	isMotionComponent: false,
+	isMotionComponentFactory: false,
+	isMotionComponentNamespace: false,
+	isMotionConfig: false,
+	isMotionNamespace: false,
+	isReducedMotionHook: false
+};
+const MOTION_COMPONENT_FACTORY_EXPORT_NAMES = new Set(["m", "motion"]);
+const MOTION_COMPONENT_NAMESPACE_EXPORT_NAMES = new Set(["Reorder"]);
+const MOTION_COMPONENT_NAMESPACE_MEMBER_NAMES = new Set(["Item"]);
+const MOTION_ANIMATION_FUNCTION_EXPORT_NAMES = new Set(["animate"]);
+const REDUCED_MOTION_HOOK_EXPORT_NAME = "useReducedMotion";
+const MOTION_CONFIG_EXPORT_NAME = "MotionConfig";
+const REDUCED_MOTION_PROP_NAME = "reducedMotion";
+const REDUCED_MOTION_CONFIG_VALUES = new Set(["always", "user"]);
+const SCRIPT_MODULE_EXTENSIONS = [
 	".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;
+	".jsx"
+];
+const SCRIPT_FILE_EXTENSIONS = new Set(SCRIPT_MODULE_EXTENSIONS);
+const STYLE_FILE_EXTENSIONS = new Set([".css", ".scss"]);
+const MOTION_SOURCE_PREFILTER = /framer-motion|["']motion(?:\/[A-Za-z0-9_./-]+)?["']|MotionConfig|useReducedMotion/;
+const REDUCED_MOTION_MEDIA_QUERY_PATTERN = /@media\s+([^{}]*\(\s*prefers-reduced-motion\s*:\s*reduce\s*\)[^{}]*)\{/gi;
+const CSS_DECLARATION_PATTERN = /(?:^|[;{])\s*[-_A-Za-z][-_A-Za-z0-9]*\s*:/;
 const MISSING_REDUCED_MOTION_DIAGNOSTIC = {
 	filePath: "package.json",
 	plugin: "react-doctor",
@@ -37141,52 +37210,406 @@ const MISSING_REDUCED_MOTION_DIAGNOSTIC = {
 	column: 0,
 	category: "Accessibility"
 };
-const hasReducedMotionHandlingViaFilesystem = (rootDirectory) => {
+const isMotionModuleSource = (moduleSource) => {
+	for (const packageName of MOTION_LIBRARY_PACKAGES) if (moduleSource === packageName || moduleSource.startsWith(`${packageName}/`)) return true;
+	return false;
+};
+const classifyMotionExport = (exportName) => ({
+	isAnimationFunction: MOTION_ANIMATION_FUNCTION_EXPORT_NAMES.has(exportName),
+	isMotionComponent: false,
+	isMotionComponentFactory: MOTION_COMPONENT_FACTORY_EXPORT_NAMES.has(exportName),
+	isMotionComponentNamespace: MOTION_COMPONENT_NAMESPACE_EXPORT_NAMES.has(exportName),
+	isMotionConfig: exportName === MOTION_CONFIG_EXPORT_NAME,
+	isMotionNamespace: false,
+	isReducedMotionHook: exportName === REDUCED_MOTION_HOOK_EXPORT_NAME
+});
+const getImportModuleSource = (node) => {
+	let currentNode = node;
+	while (currentNode) {
+		if (ts.isImportDeclaration(currentNode) && ts.isStringLiteral(currentNode.moduleSpecifier)) return currentNode.moduleSpecifier.text;
+		currentNode = currentNode.parent;
+	}
+	return null;
+};
+const getImportedBindingEvidence = (declaration, typeChecker, program, visitedSymbols) => {
+	const moduleSource = getImportModuleSource(declaration);
+	if (!moduleSource) return null;
+	if (isMotionModuleSource(moduleSource) && ts.isNamespaceImport(declaration)) return {
+		...EMPTY_MOTION_EXPRESSION_EVIDENCE,
+		isMotionNamespace: true
+	};
+	if (isMotionModuleSource(moduleSource) && ts.isImportSpecifier(declaration)) {
+		if (declaration.isTypeOnly) return null;
+		return classifyMotionExport(declaration.propertyName?.text ?? declaration.name.text);
+	}
+	if (isMotionModuleSource(moduleSource) && ts.isImportClause(declaration)) {
+		if (declaration.isTypeOnly) return null;
+		return EMPTY_MOTION_EXPRESSION_EVIDENCE;
+	}
+	if (ts.isImportSpecifier(declaration) && !declaration.isTypeOnly || ts.isImportClause(declaration) && !declaration.isTypeOnly && declaration.name) {
+		const importedName = ts.isImportSpecifier(declaration) ? declaration.propertyName?.text ?? declaration.name.text : "default";
+		const moduleSourceFile = getLocalModuleSourceFile(moduleSource, declaration.getSourceFile().fileName, program);
+		if (!moduleSourceFile) return null;
+		return resolveModuleExportEvidence(moduleSourceFile, importedName, typeChecker, program, visitedSymbols);
+	}
+	return null;
+};
+const getLocalModuleSourceFile = (moduleSource, importingFileName, program) => {
+	if (!moduleSource.startsWith(".")) return null;
+	const moduleBasePath = Path.resolve(Path.dirname(importingFileName), moduleSource);
+	const moduleBaseExtension = Path.extname(moduleBasePath);
+	const typescriptModuleBasePath = moduleBaseExtension === ".js" || moduleBaseExtension === ".jsx" ? moduleBasePath.slice(0, -moduleBaseExtension.length) : null;
+	const candidates = [
+		moduleBasePath,
+		...typescriptModuleBasePath ? [
+			`${typescriptModuleBasePath}.ts`,
+			`${typescriptModuleBasePath}.tsx`,
+			Path.join(typescriptModuleBasePath, "index.ts"),
+			Path.join(typescriptModuleBasePath, "index.tsx")
+		] : [],
+		...SCRIPT_MODULE_EXTENSIONS.map((extension) => `${moduleBasePath}${extension}`),
+		...SCRIPT_MODULE_EXTENSIONS.map((extension) => Path.join(moduleBasePath, `index${extension}`))
+	];
+	for (const candidate of candidates) {
+		const sourceFile = program.getSourceFile(candidate);
+		if (sourceFile) return sourceFile;
+	}
+	return null;
+};
+const resolveModuleExportEvidence = (sourceFile, exportName, typeChecker, program, visitedSymbols) => {
+	const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+	if (moduleSymbol && visitedSymbols.has(moduleSymbol)) return EMPTY_MOTION_EXPRESSION_EVIDENCE;
+	const nextVisitedSymbols = new Set(visitedSymbols);
+	if (moduleSymbol) nextVisitedSymbols.add(moduleSymbol);
+	for (const statement of sourceFile.statements) {
+		if (exportName === "default" && ts.isExportAssignment(statement) && !statement.isExportEquals) {
+			const evidence = resolveMotionExpressionEvidence(statement.expression, typeChecker, program, nextVisitedSymbols);
+			if (hasMotionExpressionEvidence(evidence)) return evidence;
+			continue;
+		}
+		if (!ts.isExportDeclaration(statement) || !statement.moduleSpecifier) continue;
+		if (statement.isTypeOnly) continue;
+		if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const moduleSource = statement.moduleSpecifier.text;
+		if (!statement.exportClause) {
+			if (isMotionModuleSource(moduleSource)) {
+				const evidence = classifyMotionExport(exportName);
+				if (hasMotionExpressionEvidence(evidence)) return evidence;
+				continue;
+			}
+			const moduleSourceFile = getLocalModuleSourceFile(moduleSource, sourceFile.fileName, program);
+			if (moduleSourceFile) {
+				const evidence = resolveModuleExportEvidence(moduleSourceFile, exportName, typeChecker, program, nextVisitedSymbols);
+				if (hasMotionExpressionEvidence(evidence)) return evidence;
+			}
+			continue;
+		}
+		if (!ts.isNamedExports(statement.exportClause)) continue;
+		for (const exportSpecifier of statement.exportClause.elements) {
+			if (exportSpecifier.name.text !== exportName || exportSpecifier.isTypeOnly) continue;
+			const sourceExportName = exportSpecifier.propertyName?.text ?? exportSpecifier.name.text;
+			if (isMotionModuleSource(moduleSource)) return classifyMotionExport(sourceExportName);
+			const moduleSourceFile = getLocalModuleSourceFile(moduleSource, sourceFile.fileName, program);
+			if (!moduleSourceFile) continue;
+			return resolveModuleExportEvidence(moduleSourceFile, sourceExportName, typeChecker, program, nextVisitedSymbols);
+		}
+	}
+	if (!moduleSymbol) return EMPTY_MOTION_EXPRESSION_EVIDENCE;
+	const exportedSymbol = typeChecker.getExportsOfModule(moduleSymbol).find((candidateSymbol) => candidateSymbol.name === exportName);
+	if (!exportedSymbol || nextVisitedSymbols.has(exportedSymbol)) return EMPTY_MOTION_EXPRESSION_EVIDENCE;
+	nextVisitedSymbols.add(exportedSymbol);
+	let resolvedEvidence = EMPTY_MOTION_EXPRESSION_EVIDENCE;
+	for (const declaration of exportedSymbol.declarations ?? []) {
+		if (ts.isExportSpecifier(declaration)) {
+			const targetSymbol = typeChecker.getExportSpecifierLocalTargetSymbol(declaration);
+			for (const targetDeclaration of targetSymbol?.declarations ?? []) {
+				const importedEvidence = getImportedBindingEvidence(targetDeclaration, typeChecker, program, nextVisitedSymbols);
+				if (importedEvidence) resolvedEvidence = mergeMotionExpressionEvidence(resolvedEvidence, importedEvidence);
+				if (ts.isVariableDeclaration(targetDeclaration) && targetDeclaration.initializer) resolvedEvidence = mergeMotionExpressionEvidence(resolvedEvidence, resolveMotionExpressionEvidence(targetDeclaration.initializer, typeChecker, program, nextVisitedSymbols));
+			}
+		}
+		if (ts.isVariableDeclaration(declaration) && declaration.initializer) resolvedEvidence = mergeMotionExpressionEvidence(resolvedEvidence, resolveMotionExpressionEvidence(declaration.initializer, typeChecker, program, nextVisitedSymbols));
+	}
+	return resolvedEvidence;
+};
+const mergeMotionExpressionEvidence = (leftEvidence, rightEvidence) => ({
+	isAnimationFunction: leftEvidence.isAnimationFunction || rightEvidence.isAnimationFunction,
+	isMotionComponent: leftEvidence.isMotionComponent || rightEvidence.isMotionComponent,
+	isMotionComponentFactory: leftEvidence.isMotionComponentFactory || rightEvidence.isMotionComponentFactory,
+	isMotionComponentNamespace: leftEvidence.isMotionComponentNamespace || rightEvidence.isMotionComponentNamespace,
+	isMotionConfig: leftEvidence.isMotionConfig || rightEvidence.isMotionConfig,
+	isMotionNamespace: leftEvidence.isMotionNamespace || rightEvidence.isMotionNamespace,
+	isReducedMotionHook: leftEvidence.isReducedMotionHook || rightEvidence.isReducedMotionHook
+});
+const hasMotionExpressionEvidence = (evidence) => evidence.isAnimationFunction || evidence.isMotionComponent || evidence.isMotionComponentFactory || evidence.isMotionComponentNamespace || evidence.isMotionConfig || evidence.isMotionNamespace || evidence.isReducedMotionHook;
+const classifyMotionMember = (receiverEvidence, memberName) => {
+	if (receiverEvidence.isMotionNamespace) return classifyMotionExport(memberName);
+	if (receiverEvidence.isMotionComponentFactory) return {
+		...EMPTY_MOTION_EXPRESSION_EVIDENCE,
+		isMotionComponent: true
+	};
+	if (receiverEvidence.isMotionComponentNamespace && MOTION_COMPONENT_NAMESPACE_MEMBER_NAMES.has(memberName)) return {
+		...EMPTY_MOTION_EXPRESSION_EVIDENCE,
+		isMotionComponent: true
+	};
+	return EMPTY_MOTION_EXPRESSION_EVIDENCE;
+};
+const resolveMotionExpressionEvidence = (expression, typeChecker, program, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (ts.isIdentifier(unwrappedExpression)) {
+		const symbol = typeChecker.getSymbolAtLocation(unwrappedExpression);
+		if (!symbol || visitedSymbols.has(symbol)) return EMPTY_MOTION_EXPRESSION_EVIDENCE;
+		const nextVisitedSymbols = new Set(visitedSymbols);
+		nextVisitedSymbols.add(symbol);
+		let resolvedEvidence = EMPTY_MOTION_EXPRESSION_EVIDENCE;
+		for (const declaration of symbol.declarations ?? []) {
+			const importedEvidence = getImportedBindingEvidence(declaration, typeChecker, program, nextVisitedSymbols);
+			if (importedEvidence) {
+				resolvedEvidence = mergeMotionExpressionEvidence(resolvedEvidence, importedEvidence);
+				continue;
+			}
+			if (ts.isVariableDeclaration(declaration) && declaration.initializer) resolvedEvidence = mergeMotionExpressionEvidence(resolvedEvidence, resolveMotionExpressionEvidence(declaration.initializer, typeChecker, program, nextVisitedSymbols));
+			if (ts.isBindingElement(declaration) && ts.isObjectBindingPattern(declaration.parent) && ts.isVariableDeclaration(declaration.parent.parent) && declaration.parent.parent.initializer) {
+				const propertyName = declaration.propertyName ?? declaration.name;
+				if (ts.isIdentifier(propertyName) || ts.isStringLiteral(propertyName)) {
+					const receiverEvidence = resolveMotionExpressionEvidence(declaration.parent.parent.initializer, typeChecker, program, nextVisitedSymbols);
+					resolvedEvidence = mergeMotionExpressionEvidence(resolvedEvidence, classifyMotionMember(receiverEvidence, propertyName.text));
+				}
+			}
+		}
+		return resolvedEvidence;
+	}
+	if (ts.isPropertyAccessExpression(unwrappedExpression)) return classifyMotionMember(resolveMotionExpressionEvidence(unwrappedExpression.expression, typeChecker, program, visitedSymbols), unwrappedExpression.name.text);
+	if (ts.isElementAccessExpression(unwrappedExpression) && unwrappedExpression.argumentExpression && (ts.isStringLiteral(unwrappedExpression.argumentExpression) || ts.isNoSubstitutionTemplateLiteral(unwrappedExpression.argumentExpression))) return classifyMotionMember(resolveMotionExpressionEvidence(unwrappedExpression.expression, typeChecker, program, visitedSymbols), unwrappedExpression.argumentExpression.text);
+	if (ts.isCallExpression(unwrappedExpression)) {
+		if (ts.isIdentifier(unwrappedExpression.expression) && unwrappedExpression.expression.text === "require" && !typeChecker.getSymbolAtLocation(unwrappedExpression.expression) && unwrappedExpression.arguments.length === 1 && ts.isStringLiteral(unwrappedExpression.arguments[0]) && isMotionModuleSource(unwrappedExpression.arguments[0].text)) return {
+			...EMPTY_MOTION_EXPRESSION_EVIDENCE,
+			isMotionNamespace: true
+		};
+		if (ts.isPropertyAccessExpression(unwrappedExpression.expression) && unwrappedExpression.expression.name.text === "bind") {
+			const boundReceiverEvidence = resolveMotionExpressionEvidence(unwrappedExpression.expression.expression, typeChecker, program, visitedSymbols);
+			if (boundReceiverEvidence.isAnimationFunction) return boundReceiverEvidence;
+		}
+		const calleeEvidence = resolveMotionExpressionEvidence(unwrappedExpression.expression, typeChecker, program, visitedSymbols);
+		if (calleeEvidence.isMotionComponentFactory) return {
+			...EMPTY_MOTION_EXPRESSION_EVIDENCE,
+			isMotionComponent: true
+		};
+		return calleeEvidence;
+	}
+	return EMPTY_MOTION_EXPRESSION_EVIDENCE;
+};
+const getStaticStringExpressionValue = (expression, typeChecker, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
+	if (ts.isStringLiteral(unwrappedExpression) || ts.isNoSubstitutionTemplateLiteral(unwrappedExpression)) return unwrappedExpression.text;
+	if (!ts.isIdentifier(unwrappedExpression)) return null;
+	const symbol = typeChecker.getSymbolAtLocation(unwrappedExpression);
+	if (!symbol || visitedSymbols.has(symbol)) return null;
+	const nextVisitedSymbols = new Set(visitedSymbols);
+	nextVisitedSymbols.add(symbol);
+	for (const declaration of symbol.declarations ?? []) {
+		if (!ts.isVariableDeclaration(declaration) || !declaration.initializer) continue;
+		if (!ts.isVariableDeclarationList(declaration.parent)) continue;
+		if (!(declaration.parent.flags & ts.NodeFlags.Const)) continue;
+		const value = getStaticStringExpressionValue(declaration.initializer, typeChecker, nextVisitedSymbols);
+		if (value !== null) return value;
+	}
+	return null;
+};
+const getStaticJsxAttributeValue = (attribute, typeChecker) => {
+	if (!attribute.initializer) return null;
+	if (ts.isStringLiteral(attribute.initializer)) return attribute.initializer.text;
+	if (!ts.isJsxExpression(attribute.initializer) || !attribute.initializer.expression) return null;
+	return getStaticStringExpressionValue(attribute.initializer.expression, typeChecker);
+};
+const isExpressionValueConsumed = (expression) => {
+	let currentExpression = expression;
+	while (ts.isParenthesizedExpression(currentExpression.parent) || ts.isAsExpression(currentExpression.parent) || ts.isSatisfiesExpression(currentExpression.parent) || ts.isNonNullExpression(currentExpression.parent) || ts.isTypeAssertionExpression(currentExpression.parent)) currentExpression = currentExpression.parent;
+	return !ts.isExpressionStatement(currentExpression.parent) && !ts.isVoidExpression(currentExpression.parent);
+};
+const jsxElementHasReducedMotionConfiguration = (attributes, typeChecker) => attributes.properties.some((attribute) => ts.isJsxAttribute(attribute) && ts.isIdentifier(attribute.name) && attribute.name.text === REDUCED_MOTION_PROP_NAME && REDUCED_MOTION_CONFIG_VALUES.has(getStaticJsxAttributeValue(attribute, typeChecker) ?? ""));
+const collectScriptMotionEvidence = (sourceFile, typeChecker, program) => {
+	const evidence = {
+		hasMotionUse: false,
+		hasReducedMotionHandling: false
+	};
+	const visitNode = (node) => {
+		if (ts.isCallExpression(node)) {
+			const calleeEvidence = resolveMotionExpressionEvidence(node.expression, typeChecker, program);
+			const isAnimationFunctionCallViaCallOrApply = (ts.isPropertyAccessExpression(node.expression) && (node.expression.name.text === "call" || node.expression.name.text === "apply") || ts.isElementAccessExpression(node.expression) && node.expression.argumentExpression && (ts.isStringLiteral(node.expression.argumentExpression) || ts.isNoSubstitutionTemplateLiteral(node.expression.argumentExpression)) && (node.expression.argumentExpression.text === "call" || node.expression.argumentExpression.text === "apply")) && resolveMotionExpressionEvidence(node.expression.expression, typeChecker, program).isAnimationFunction;
+			if (calleeEvidence.isAnimationFunction || isAnimationFunctionCallViaCallOrApply) evidence.hasMotionUse = true;
+			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);
+			if (tagEvidence.isMotionComponent || tagEvidence.isMotionComponentFactory) evidence.hasMotionUse = true;
+			if (tagEvidence.isMotionConfig && jsxElementHasReducedMotionConfiguration(node.attributes, typeChecker)) evidence.hasReducedMotionHandling = true;
+		}
+		ts.forEachChild(node, visitNode);
+	};
+	visitNode(sourceFile);
+	return evidence;
+};
+const analyzeReducedMotionSources = (sources) => {
+	if (!sources.some(({ sourceText }) => MOTION_SOURCE_PREFILTER.test(sourceText))) return {
+		hasMotionUse: false,
+		hasReducedMotionHandling: false
+	};
+	const compilerOptions = {
+		allowJs: true,
+		checkJs: false,
+		jsx: ts.JsxEmit.Preserve,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		noEmit: true,
+		noLib: true,
+		noResolve: true,
+		skipLibCheck: true,
+		target: ts.ScriptTarget.Latest
+	};
+	const sourceTextByFileName = new Map(sources.map(({ fileName: sourceFileName, sourceText: content }) => [Path.resolve(sourceFileName), content]));
+	const compilerHost = ts.createCompilerHost(compilerOptions);
+	const getDefaultSourceFile = compilerHost.getSourceFile.bind(compilerHost);
+	compilerHost.getSourceFile = (requestedFileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => sourceTextByFileName.has(Path.resolve(requestedFileName)) ? ts.createSourceFile(Path.resolve(requestedFileName), sourceTextByFileName.get(Path.resolve(requestedFileName)) ?? "", languageVersionOrOptions, true, getTypescriptScriptKind(requestedFileName)) : getDefaultSourceFile(requestedFileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+	const program = ts.createProgram([...sourceTextByFileName.keys()], compilerOptions, compilerHost);
+	const typeChecker = program.getTypeChecker();
+	const evidence = {
+		hasMotionUse: false,
+		hasReducedMotionHandling: false
+	};
+	for (const sourceFileName of sourceTextByFileName.keys()) {
+		const sourceFile = program.getSourceFile(sourceFileName);
+		if (!sourceFile) continue;
+		const fileEvidence = collectScriptMotionEvidence(sourceFile, typeChecker, program);
+		evidence.hasMotionUse ||= fileEvidence.hasMotionUse;
+		evidence.hasReducedMotionHandling ||= fileEvidence.hasReducedMotionHandling;
+	}
+	return evidence;
+};
+const removeCssCommentsAndStrings = (content) => {
+	let sanitizedContent = "";
+	let quote = null;
+	let isInsideComment = false;
+	let isInsideLineComment = false;
+	for (let characterIndex = 0; characterIndex < content.length; characterIndex += 1) {
+		const character = content[characterIndex];
+		const nextCharacter = content[characterIndex + 1];
+		if (isInsideLineComment) {
+			sanitizedContent += character === "\n" ? "\n" : " ";
+			if (character === "\n") isInsideLineComment = false;
+			continue;
+		}
+		if (isInsideComment) {
+			if (character === "*" && nextCharacter === "/") {
+				sanitizedContent += "  ";
+				characterIndex += 1;
+				isInsideComment = false;
+			} else sanitizedContent += character === "\n" ? "\n" : " ";
+			continue;
+		}
+		if (quote) {
+			if (character === "\\") {
+				sanitizedContent += "  ";
+				characterIndex += 1;
+				continue;
+			}
+			if (character === quote) quote = null;
+			sanitizedContent += character === "\n" ? "\n" : " ";
+			continue;
+		}
+		if (character === "/" && nextCharacter === "*") {
+			sanitizedContent += "  ";
+			characterIndex += 1;
+			isInsideComment = true;
+			continue;
+		}
+		if (character === "/" && nextCharacter === "/") {
+			sanitizedContent += "  ";
+			characterIndex += 1;
+			isInsideLineComment = true;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			sanitizedContent += " ";
+			quote = character;
+			continue;
+		}
+		sanitizedContent += character;
+	}
+	return sanitizedContent;
+};
+const findMatchingClosingBrace = (content, openingBraceIndex) => {
+	let depth = 0;
+	for (let characterIndex = openingBraceIndex; characterIndex < content.length; characterIndex += 1) {
+		if (content[characterIndex] === "{") depth += 1;
+		if (content[characterIndex] !== "}") continue;
+		depth -= 1;
+		if (depth === 0) return characterIndex;
+	}
+	return -1;
+};
+const hasReducedMotionMediaQuery = (content) => {
+	const sanitizedContent = removeCssCommentsAndStrings(content);
+	REDUCED_MOTION_MEDIA_QUERY_PATTERN.lastIndex = 0;
+	for (const match of sanitizedContent.matchAll(REDUCED_MOTION_MEDIA_QUERY_PATTERN)) {
+		const mediaPrelude = match[1];
+		if (/\bnot\b/i.test(mediaPrelude)) continue;
+		const openingBraceIndex = (match.index ?? 0) + match[0].lastIndexOf("{");
+		const closingBraceIndex = findMatchingClosingBrace(sanitizedContent, openingBraceIndex);
+		if (closingBraceIndex === -1) continue;
+		const body = sanitizedContent.slice(openingBraceIndex + 1, closingBraceIndex);
+		if (CSS_DECLARATION_PATTERN.test(body)) return true;
+	}
+	return false;
+};
+const collectProjectMotionEvidence = (rootDirectory) => {
+	const scriptSources = [];
+	let hasReducedMotionHandling = false;
 	for (const { absolutePath, name } of walkSourceTreeFiles(rootDirectory)) {
-		if (!REDUCED_MOTION_FILE_EXTENSIONS.has(Path.extname(name))) continue;
+		const extension = Path.extname(name);
+		if (!SCRIPT_FILE_EXTENSIONS.has(extension) && !STYLE_FILE_EXTENSIONS.has(extension)) continue;
 		let content;
 		try {
 			content = NFS.readFileSync(absolutePath, "utf-8");
 		} catch {
 			continue;
 		}
-		if (REDUCED_MOTION_PATTERN.test(content)) return true;
+		if (STYLE_FILE_EXTENSIONS.has(extension)) {
+			if (hasReducedMotionMediaQuery(content)) hasReducedMotionHandling = true;
+			continue;
+		}
+		scriptSources.push({
+			fileName: absolutePath,
+			sourceText: content
+		});
 	}
-	return false;
+	if (scriptSources.length === 0) return {
+		hasMotionUse: false,
+		hasReducedMotionHandling
+	};
+	const scriptEvidence = analyzeReducedMotionSources(scriptSources);
+	const hasMotionUse = scriptEvidence.hasMotionUse;
+	hasReducedMotionHandling ||= scriptEvidence.hasReducedMotionHandling;
+	return {
+		hasMotionUse,
+		hasReducedMotionHandling
+	};
 };
 const checkReducedMotion = (rootDirectory) => {
 	const packageJsonPath = Path.join(rootDirectory, "package.json");
 	if (!isFile(packageJsonPath)) return [];
-	let hasMotionLibrary = false;
 	try {
 		const packageJson = readPackageJson(packageJsonPath);
 		const allDependencies = {
 			...packageJson.dependencies,
 			...packageJson.devDependencies
 		};
-		hasMotionLibrary = Object.keys(allDependencies).some((packageName) => MOTION_LIBRARY_PACKAGES.has(packageName));
+		if (!Object.keys(allDependencies).some((packageName) => MOTION_LIBRARY_PACKAGES.has(packageName))) return [];
 	} catch {
 		return [];
 	}
-	if (!hasMotionLibrary) return [];
-	const result = spawnSync("git", [
-		"grep",
-		"--untracked",
-		"-lE",
-		REDUCED_MOTION_GREP_PATTERN,
-		"--",
-		...REDUCED_MOTION_FILE_GLOBS
-	], {
-		cwd: rootDirectory,
-		encoding: "utf-8",
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	});
-	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 evidence = collectProjectMotionEvidence(rootDirectory);
+	return evidence.hasMotionUse && !evidence.hasReducedMotionHandling ? [MISSING_REDUCED_MOTION_DIAGNOSTIC] : [];
 };
 const buildSecurityScanDiagnostic = (finding, entry, relativePath) => ({
 	filePath: relativePath,
@@ -37494,9 +37917,7 @@ const highlighter = {
 	gray: import_picocolors.default.gray,
 	bold: import_picocolors.default.bold
 };
-const NEXT_ENTRY_FILE_PATTERN = /^(?:\.\/)?(?:src\/)?(?:middleware|proxy)\.(?:tsx?|jsx?|mts|mjs)$/;
-const shouldIncludeExplicitLintPath = (filePath, project) => JSX_FILE_PATTERN.test(filePath) || project?.framework === "nextjs" && NEXT_ENTRY_FILE_PATTERN.test(filePath);
-const computeExplicitLintIncludePaths = (includePaths, project) => includePaths.length > 0 ? includePaths.filter((filePath) => shouldIncludeExplicitLintPath(filePath, project)) : void 0;
+const computeExplicitLintIncludePaths = (includePaths) => includePaths.length > 0 ? includePaths.filter(isLintableSourceFile) : void 0;
 const LINGUIST_ATTRIBUTE_PATTERN = /^linguist-(?:vendored|generated)(?:=([a-zA-Z0-9]+))?$/i;
 const FALSY_VALUES = new Set([
 	"false",
@@ -38338,11 +38759,11 @@ const resolveDeadCodeTimeout = (input) => {
 		phaseTimeoutMs: workerTimeoutMs + DEAD_CODE_PHASE_TIMEOUT_OVER_WORKER_MS
 	};
 };
-const resolveLintIncludePaths = (rootDirectory, userConfig, project) => {
+const resolveLintIncludePaths = (rootDirectory, userConfig) => {
 	if (!Array.isArray(userConfig?.ignore?.files) || userConfig.ignore.files.length === 0) return;
 	const ignoredPatterns = compileIgnoredFilePatterns(userConfig);
 	return listSourceFiles(rootDirectory).filter((filePath) => {
-		if (!shouldIncludeExplicitLintPath(filePath, project)) return false;
+		if (!isLintableSourceFile(filePath)) return false;
 		return !isFileIgnoredByPatterns(filePath, rootDirectory, ignoredPatterns);
 	});
 };
@@ -38560,6 +38981,7 @@ const parseGithubViewerPermission = (stdout) => {
 	return /^[A-Z_]+$/.test(value) ? value.toLowerCase() : null;
 };
 const splitNullSeparated = (value) => value.split("\0").filter((entry) => entry.length > 0);
+const UNTRACKED_FILE_LAST_LINE = Number.MAX_SAFE_INTEGER;
 /**
 * `Git` wraps every `git`-via-subprocess call react-doctor makes
 * behind a `Context.Service`. The production layer (`layerNode`)
@@ -38630,6 +39052,14 @@ var Git = class Git extends Service()("react-doctor/Git") {
 			args,
 			directory
 		});
+		const listUntrackedFilePaths = (directory, includePaths = []) => runGit(directory, [
+			"ls-files",
+			"-z",
+			"--others",
+			"--exclude-standard",
+			...includePaths.length > 0 ? ["--", ...includePaths] : []
+		]).pipe(map$3((result) => result.status === 0 ? splitNullSeparated(result.stdout) : null));
+		const mergeUntracked = (directory, trackedFilePaths, includeUntracked) => includeUntracked ? listUntrackedFilePaths(directory).pipe(map$3((untracked) => untracked === null ? trackedFilePaths : [...new Set([...trackedFilePaths, ...untracked])])) : succeed$2(trackedFilePaths);
 		const currentBranch = (directory) => runGit(directory, [
 			"rev-parse",
 			"--abbrev-ref",
@@ -38752,7 +39182,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 			githubViewerPermission,
 			branchExists,
 			mergeBase,
-			diffSelection: ({ directory, explicitBaseBranch }) => gen(function* () {
+			diffSelection: ({ directory, explicitBaseBranch, includeUntracked = false }) => gen(function* () {
 				if (explicitBaseBranch !== void 0 && explicitBaseBranch.trim().length === 0) return yield* fail$4(new ReactDoctorError({ reason: new GitBaseBranchInvalid({ detail: "Diff base branch cannot be empty." }) }));
 				if (explicitBaseBranch !== void 0) {
 					const range = parseGitDiffRange(explicitBaseBranch);
@@ -38781,7 +39211,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 						"HEAD"
 					]);
 					if (uncommitted.status !== 0) return null;
-					const files = splitNullSeparated(uncommitted.stdout);
+					const files = yield* mergeUntracked(directory, splitNullSeparated(uncommitted.stdout), includeUntracked);
 					if (files.length === 0) return null;
 					return {
 						currentBranch: resolvedCurrentBranch,
@@ -38811,7 +39241,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 					currentBranch: resolvedCurrentBranch,
 					baseBranch,
 					diffBaseRef: mergeBaseRef,
-					changedFiles: splitNullSeparated(diff.stdout),
+					changedFiles: yield* mergeUntracked(directory, splitNullSeparated(diff.stdout), includeUntracked),
 					isCurrentChanges: false
 				};
 			}).pipe(withSpan("Git.diffSelection")),
@@ -38857,7 +39287,7 @@ var Git = class Git extends Service()("react-doctor/Git") {
 					stdout: result.stdout
 				};
 			}).pipe(withSpan("Git.grep")),
-			changedLineRanges: ({ directory, baseRef, cached, files }) => gen(function* () {
+			changedLineRanges: ({ directory, baseRef, cached, files, includeUntracked = false }) => gen(function* () {
 				if (files.length === 0) return [];
 				if (baseRef !== void 0 && !isSafeGitRevision(baseRef)) return null;
 				const result = yield* runGit(directory, [
@@ -38871,7 +39301,14 @@ var Git = class Git extends Service()("react-doctor/Git") {
 					...files
 				]);
 				if (result.status !== 0) return null;
-				return parseChangedLineRanges(result.stdout);
+				const changedLineRanges = parseChangedLineRanges(result.stdout);
+				if (cached || !includeUntracked) return changedLineRanges;
+				const untrackedFilePaths = yield* listUntrackedFilePaths(directory, files);
+				if (untrackedFilePaths === null) return changedLineRanges;
+				return [...changedLineRanges, ...untrackedFilePaths.map((file) => ({
+					file,
+					ranges: [[1, UNTRACKED_FILE_LAST_LINE]]
+				}))];
 			}).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)))));
@@ -39456,13 +39893,13 @@ const encodeSidecarFileEntry = (entry) => ({
 	diagnostics: entry.diagnostics
 });
 const emptyCache = () => ({
-	version: 1,
+	version: 2,
 	rulesets: {}
 });
 const loadRulesetEntries = (cacheFilePath, rulesetHash) => {
 	const entries = /* @__PURE__ */ new Map();
 	const persisted = failOpenReadJson(cacheFilePath, emptyCache());
-	if (persisted.version !== 1 || !isRecord(persisted.rulesets)) return entries;
+	if (persisted.version !== 2 || !isRecord(persisted.rulesets)) return entries;
 	const bucket = persisted.rulesets[rulesetHash];
 	if (!isRecord(bucket) || !isRecord(bucket.files)) return entries;
 	for (const [fileKey, rawEntry] of Object.entries(bucket.files)) {
@@ -39482,7 +39919,7 @@ const createSidecarLintCache = (cacheDirectory, rulesetHash) => {
 		},
 		persist: () => {
 			const onDisk = failOpenReadJson(cacheFilePath, emptyCache());
-			const rulesets = onDisk.version === 1 && isRecord(onDisk.rulesets) ? { ...onDisk.rulesets } : {};
+			const rulesets = onDisk.version === 2 && isRecord(onDisk.rulesets) ? { ...onDisk.rulesets } : {};
 			const existingBucket = rulesets[rulesetHash];
 			const existingFiles = isRecord(existingBucket) && isRecord(existingBucket.files) ? existingBucket.files : {};
 			const ourFiles = {};
@@ -39496,7 +39933,7 @@ const createSidecarLintCache = (cacheDirectory, rulesetHash) => {
 				files: Object.fromEntries(cappedEntries)
 			};
 			atomicWriteJson(cacheFilePath, {
-				version: 1,
+				version: 2,
 				rulesets: Object.fromEntries(Object.entries(rulesets).filter(([, bucket]) => isRecord(bucket) && typeof bucket.updatedAtMs === "number").sort(([, first], [, second]) => second.updatedAtMs - first.updatedAtMs).slice(0, 8))
 			});
 		}
@@ -39547,23 +39984,6 @@ const resolveTsConfigRelativePath = (rootDirectory) => {
 	for (const filename of TSCONFIG_FILENAMES) if (NFS.existsSync(Path.join(rootDirectory, filename))) return `./${filename}`;
 	return null;
 };
-const DERIVED_STATE_RULE_PRIORITY = new Map([
-	["no-initialize-state", 0],
-	["no-adjust-state-on-prop-change", 1],
-	["no-derived-state", 2],
-	["no-derived-state-effect", 3]
-]);
-const doDiagnosticSpansOverlap = (first, second) => {
-	if (first.filePath !== second.filePath || first.plugin !== second.plugin) return false;
-	if (first.offset !== void 0 && second.offset !== void 0) {
-		const firstEnd = first.offset + Math.max(first.length ?? 1, 1);
-		const secondEnd = second.offset + Math.max(second.length ?? 1, 1);
-		return first.offset < secondEnd && second.offset < firstEnd;
-	}
-	const firstEndLine = first.endLine ?? first.line;
-	const secondEndLine = second.endLine ?? second.line;
-	return first.line <= secondEndLine && second.line <= firstEndLine;
-};
 const dedupeDiagnostics = (diagnostics) => {
 	const seenKeys = /* @__PURE__ */ new Set();
 	const uniqueDiagnostics = [];
@@ -39571,16 +39991,6 @@ const dedupeDiagnostics = (diagnostics) => {
 		const key = `${diagnostic.filePath}\u0000${diagnostic.line}\u0000${diagnostic.column}\u0000${diagnostic.plugin}\u0000${diagnostic.rule}\u0000${diagnostic.severity}\u0000${diagnostic.message}`;
 		if (seenKeys.has(key)) continue;
 		seenKeys.add(key);
-		const priority = DERIVED_STATE_RULE_PRIORITY.get(diagnostic.rule);
-		if (priority !== void 0) {
-			const overlappingDiagnosticIndex = uniqueDiagnostics.findIndex((candidate) => candidate.rule !== diagnostic.rule && candidate.severity === diagnostic.severity && DERIVED_STATE_RULE_PRIORITY.has(candidate.rule) && doDiagnosticSpansOverlap(candidate, diagnostic));
-			if (overlappingDiagnosticIndex >= 0) {
-				const existingDiagnostic = uniqueDiagnostics[overlappingDiagnosticIndex];
-				const existingPriority = existingDiagnostic ? DERIVED_STATE_RULE_PRIORITY.get(existingDiagnostic.rule) : void 0;
-				if (existingPriority !== void 0 && priority < existingPriority) uniqueDiagnostics[overlappingDiagnosticIndex] = diagnostic;
-				continue;
-			}
-		}
 		uniqueDiagnostics.push(diagnostic);
 	}
 	return uniqueDiagnostics;
@@ -39623,6 +40033,12 @@ const mapWithConcurrency = async (items, concurrency, task) => {
 	if (errors.length > 0) throw errors[0];
 	return results;
 };
+const lineOfUtf8Offset = (sourceBuffer, utf8Offset) => {
+	let lineNumber = 1;
+	const scanEnd = Math.min(utf8Offset, sourceBuffer.length);
+	for (let byteIndex = 0; byteIndex < scanEnd; byteIndex++) if (sourceBuffer[byteIndex] === 10) lineNumber++;
+	return lineNumber;
+};
 const REANIMATED_SHARED_VALUE_HINT = "If this is a Reanimated shared value, prefer its React Compiler-compatible `.get()` / `.set()` accessors over `.value` — https://docs.swmansion.com/react-native-reanimated/docs/core/useSharedValue/#react-compiler-support";
 const ACCESSORS_MIN_VERSION = "3.15.0";
 const supportsAccessors = (reanimatedVersion) => {
@@ -39796,23 +40212,12 @@ const REACT_USE_BINDING_RESOLUTION = {
 	isReactUseBinding: true,
 	isReactNamespaceBinding: false
 };
-const getScriptKind$2 = (filename) => {
-	if (filename.endsWith(".tsx")) return ts.ScriptKind.TSX;
-	if (filename.endsWith(".jsx")) return ts.ScriptKind.JSX;
-	if (filename.endsWith(".ts")) return ts.ScriptKind.TS;
-	return ts.ScriptKind.JS;
-};
 const getUtf16Offset$1 = (sourceText, utf8Offset) => Buffer.from(sourceText).subarray(0, utf8Offset).toString("utf8").length;
-const unwrapExpression = (expression) => {
-	let currentExpression = expression;
-	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
-	return currentExpression;
-};
 const getStaticPropertyName = (node) => {
 	if (!node) return null;
 	if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node)) return node.text;
 	if (ts.isComputedPropertyName(node)) {
-		const expression = unwrapExpression(node.expression);
+		const expression = unwrapTypescriptExpression(node.expression);
 		if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) return expression.text;
 	}
 	return null;
@@ -39841,7 +40246,7 @@ const isReactUseObjectBindingElement = (bindingElement) => {
 	return getStaticPropertyName(bindingElement.propertyName) === USE_IDENTIFIER;
 };
 const isReactRequireCall = (expression) => {
-	const unwrappedExpression = unwrapExpression(expression);
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
 	return ts.isCallExpression(unwrappedExpression) && ts.isIdentifier(unwrappedExpression.expression) && unwrappedExpression.expression.text === REQUIRE_IDENTIFIER && unwrappedExpression.arguments.length === 1 && ts.isStringLiteral(unwrappedExpression.arguments[0]) && unwrappedExpression.arguments[0].text === REACT_MODULE_SOURCE;
 };
 const getModuleSource = (node) => {
@@ -39943,7 +40348,7 @@ const isIdentifierShadowedByLocalBinding = (identifier, sourceFile) => {
 	return false;
 };
 const isReactNamespaceExpression = (expression, reactImportBindings, sourceFile, visitedDeclarations) => {
-	const unwrappedExpression = unwrapExpression(expression);
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
 	if (isReactRequireCall(unwrappedExpression)) return true;
 	if (!ts.isIdentifier(unwrappedExpression)) return false;
 	if (reactImportBindings.namespaceNames.has(unwrappedExpression.text) && !isIdentifierShadowedByLocalBinding(unwrappedExpression, sourceFile)) return true;
@@ -39951,7 +40356,7 @@ const isReactNamespaceExpression = (expression, reactImportBindings, sourceFile,
 };
 const isReactUseExpression = (expression, reactImportBindings, sourceFile, visitedDeclarations) => {
 	if (!expression) return false;
-	const unwrappedExpression = unwrapExpression(expression);
+	const unwrappedExpression = unwrapTypescriptExpression(expression);
 	if (ts.isIdentifier(unwrappedExpression)) {
 		if (reactImportBindings.useImportNames.has(unwrappedExpression.text) && !isIdentifierShadowedByLocalBinding(unwrappedExpression, sourceFile)) return true;
 		if (unwrappedExpression.text === USE_IDENTIFIER) return false;
@@ -40051,7 +40456,7 @@ const findUseCallIdentifier = (sourceFile, useOffset) => {
 	return matchedIdentifier;
 };
 const resolveUseCallBinding = (sourceText, filename, utf8Offset) => {
-	const sourceFile = ts.createSourceFile(filename, sourceText, ts.ScriptTarget.Latest, true, getScriptKind$2(filename));
+	const sourceFile = ts.createSourceFile(filename, sourceText, ts.ScriptTarget.Latest, true, getTypescriptScriptKind(filename));
 	const useIdentifier = findUseCallIdentifier(sourceFile, getUtf16Offset$1(sourceText, utf8Offset));
 	if (!useIdentifier) return null;
 	return resolveIdentifierBinding(useIdentifier, collectReactImportBindings(sourceFile), sourceFile);
@@ -40087,12 +40492,6 @@ const WORKLET_ACCEPTING_CALLEES = new Set([
 	"executeOnUIRuntimeSync"
 ]);
 const GESTURE_ROOT_IDENTIFIER = "Gesture";
-const getScriptKind$1 = (filename) => {
-	if (filename.endsWith(".tsx")) return ts.ScriptKind.TSX;
-	if (filename.endsWith(".jsx")) return ts.ScriptKind.JSX;
-	if (filename.endsWith(".ts")) return ts.ScriptKind.TS;
-	return ts.ScriptKind.JS;
-};
 const getUtf16Offset = (sourceText, utf8Offset) => Buffer.from(sourceText).subarray(0, utf8Offset).toString("utf8").length;
 const hasWorkletDirective = (node) => {
 	if (!ts.isFunctionDeclaration(node) && !ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isMethodDeclaration(node)) return false;
@@ -40164,17 +40563,11 @@ const shouldSuppressCompilerFindingInWorklet = (diagnostic, project, rootDirecto
 	} catch {
 		return false;
 	}
-	return isOffsetInsideWorklet(ts.createSourceFile(absolutePath, sourceText, ts.ScriptTarget.Latest, true, getScriptKind$1(absolutePath)), getUtf16Offset(sourceText, primaryLabel.span.offset));
+	return isOffsetInsideWorklet(ts.createSourceFile(absolutePath, sourceText, ts.ScriptTarget.Latest, true, getTypescriptScriptKind(absolutePath)), getUtf16Offset(sourceText, primaryLabel.span.offset));
 };
 const MANUAL_MEMOIZATION_PLUGIN = "react-doctor";
 const MANUAL_MEMOIZATION_RULE = "react-compiler-no-manual-memoization";
 const REACT_COMPILER_PLUGIN = "react-hooks-js";
-const getScriptKind = (filename) => {
-	if (filename.endsWith(".tsx")) return ts.ScriptKind.TSX;
-	if (filename.endsWith(".jsx")) return ts.ScriptKind.JSX;
-	if (filename.endsWith(".ts")) return ts.ScriptKind.TS;
-	return ts.ScriptKind.JS;
-};
 const isManualMemoizationDiagnostic = (diagnostic) => diagnostic.plugin === MANUAL_MEMOIZATION_PLUGIN && diagnostic.rule === MANUAL_MEMOIZATION_RULE;
 const nodeLineRange = (sourceFile, node) => ({
 	startLine: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1,
@@ -40194,13 +40587,6 @@ const findOutermostEnclosingFunctionRange = (sourceFile, targetLine) => {
 	visit(sourceFile);
 	return foundRange;
 };
-const NEWLINE_BYTE = 10;
-const lineOfUtf8Offset = (sourceBuffer, utf8Offset) => {
-	let lineNumber = 1;
-	const scanEnd = Math.min(utf8Offset, sourceBuffer.length);
-	for (let byteIndex = 0; byteIndex < scanEnd; byteIndex++) if (sourceBuffer[byteIndex] === NEWLINE_BYTE) lineNumber++;
-	return lineNumber;
-};
 /**
 * Drops `react-doctor/react-compiler-no-manual-memoization` diagnostics
 * whose enclosing function also carries a `react-hooks-js` (React
@@ -40243,7 +40629,7 @@ const suppressMemoizationInBailedOutFunctions = (diagnostics, rootDirectory) =>
 		try {
 			const buffer = NFS.readFileSync(absolutePath);
 			parsed = {
-				sourceFile: ts.createSourceFile(absolutePath, buffer.toString("utf8"), ts.ScriptTarget.Latest, true, getScriptKind(absolutePath)),
+				sourceFile: ts.createSourceFile(absolutePath, buffer.toString("utf8"), ts.ScriptTarget.Latest, true, getTypescriptScriptKind(absolutePath)),
 				buffer
 			};
 		} catch {
@@ -40381,11 +40767,11 @@ const buildRelatedLocations = (labels, filePath) => {
 	}
 	return related;
 };
-const isOxlintOutput = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const candidate = value;
-	return Array.isArray(candidate.diagnostics);
-};
+const isOxlintSpan = (value) => isRecord(value) && typeof value.offset === "number" && typeof value.length === "number" && typeof value.line === "number" && typeof value.column === "number";
+const isOxlintLabel = (value) => isRecord(value) && isOxlintSpan(value.span);
+const isMappableOxlintDiagnostic = (value) => isRecord(value) && typeof value.code === "string" && value.code.length > 0 && typeof value.filename === "string" && value.filename.length > 0 && (value.severity === "warning" || value.severity === "error") && Array.isArray(value.labels) && value.labels.every(isOxlintLabel);
+const isEngineFailureDiagnostic = (value) => !isRecord(value) || typeof value.filename !== "string" || value.filename.length === 0;
+const isOxlintOutput = (value) => isRecord(value) && Array.isArray(value.diagnostics);
 /**
 * Parses one oxlint subprocess's stdout into a flat `Diagnostic[]`.
 * Tolerates the leading-notice-line shape oxlint sometimes prints
@@ -40404,23 +40790,59 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 		throw new ReactDoctorError({ reason: new OxlintOutputUnparseable({ preview: stdout.slice(0, 600) }) });
 	}
 	if (!isOxlintOutput(parsed)) throw new ReactDoctorError({ reason: new OxlintOutputUnparseable({ preview: stdout.slice(0, 600) }) });
+	const engineFailureDiagnostic = parsed.diagnostics.find(isEngineFailureDiagnostic);
+	if (engineFailureDiagnostic !== void 0) throw new ReactDoctorError({ reason: new OxlintOutputUnparseable({ preview: JSON.stringify(engineFailureDiagnostic).slice(0, 600) }) });
 	const minifiedFileCache = /* @__PURE__ */ new Map();
+	const sourceBufferCache = /* @__PURE__ */ new Map();
+	const sourceLinesCache = /* @__PURE__ */ new Map();
+	const resolveAbsolutePath = (filename) => Path.isAbsolute(filename) ? filename : Path.resolve(rootDirectory || ".", filename);
+	const readSourceBuffer = (filename) => {
+		const absolutePath = resolveAbsolutePath(filename);
+		const cached = sourceBufferCache.get(absolutePath);
+		if (cached !== void 0) return cached;
+		let sourceBuffer;
+		try {
+			sourceBuffer = NFS.readFileSync(absolutePath);
+		} catch {
+			sourceBuffer = null;
+		}
+		sourceBufferCache.set(absolutePath, sourceBuffer);
+		return sourceBuffer;
+	};
+	const readSourceLines = (filename) => {
+		const absolutePath = resolveAbsolutePath(filename);
+		const cached = sourceLinesCache.get(absolutePath);
+		if (cached !== void 0) return cached;
+		const sourceBuffer = readSourceBuffer(filename);
+		const sourceLines = sourceBuffer ? sourceBuffer.toString("utf8").split("\n") : null;
+		sourceLinesCache.set(absolutePath, sourceLines);
+		return sourceLines;
+	};
 	const isMinifiedDiagnosticFile = (filename) => {
-		const absolutePath = Path.isAbsolute(filename) ? filename : Path.resolve(rootDirectory || ".", filename);
+		const absolutePath = resolveAbsolutePath(filename);
 		const cached = minifiedFileCache.get(absolutePath);
 		if (cached !== void 0) return cached;
 		const minified = isMinifiedSource(absolutePath);
 		minifiedFileCache.set(absolutePath, minified);
 		return minified;
 	};
-	return suppressMemoizationInBailedOutFunctions(parsed.diagnostics.filter((diagnostic) => diagnostic.code && isLintableSourceFile(diagnostic.filename) && !isMinifiedDiagnosticFile(diagnostic.filename) && !shouldSuppressLocalUseHookDiagnostic(diagnostic, rootDirectory) && !shouldSuppressCompilerFindingInWorklet(diagnostic, project, rootDirectory)).map((diagnostic) => {
+	return suppressMemoizationInBailedOutFunctions(parsed.diagnostics.filter((diagnostic) => isMappableOxlintDiagnostic(diagnostic) && isLintableSourceFile(diagnostic.filename) && !isMinifiedDiagnosticFile(diagnostic.filename) && !shouldSuppressLocalUseHookDiagnostic(diagnostic, rootDirectory) && !shouldSuppressCompilerFindingInWorklet(diagnostic, project, rootDirectory)).map((diagnostic) => {
 		const { plugin, rule } = parseRuleCode(diagnostic.code);
 		const primaryLabel = diagnostic.labels[0];
 		const cleaned = cleanDiagnosticMessage(diagnostic.message, diagnostic.help, plugin, rule, project);
 		const normalizedFilePath = diagnostic.filename.replaceAll("\\", "/");
 		const primarySpan = primaryLabel?.span;
+		const sourceBuffer = primarySpan ? readSourceBuffer(diagnostic.filename) : null;
 		const relatedLocations = buildRelatedLocations(diagnostic.labels, normalizedFilePath);
 		const category = resolveDiagnosticCategory(plugin, rule);
+		const matchByOccurrence = resolveMatchByOccurrence(rule, category);
+		const sourceLines = primarySpan ? readSourceLines(diagnostic.filename) : null;
+		const primaryLineIndex = primarySpan ? primarySpan.line - 1 : -1;
+		const primaryLine = sourceLines?.[primaryLineIndex];
+		const primaryColumnIndex = primarySpan ? primarySpan.column - 1 : -1;
+		const isJsxTagLabel = primaryLine !== void 0 && primaryColumnIndex >= 0 && (primaryLine[primaryColumnIndex] === "<" || primaryLine[primaryColumnIndex - 1] === "<");
+		const jsxOpenerEndLineIndex = sourceLines && isJsxTagLabel ? findJsxOpenerSpan(sourceLines, primaryLineIndex) : null;
+		const primarySpanEndLine = jsxOpenerEndLineIndex !== null ? jsxOpenerEndLineIndex + 1 : primarySpan && sourceBuffer ? lineOfUtf8Offset(sourceBuffer, primarySpan.offset + Math.max(primarySpan.length - 1, 0)) : void 0;
 		return {
 			filePath: normalizedFilePath,
 			plugin,
@@ -40434,10 +40856,11 @@ const parseOxlintOutput = (stdout, project, rootDirectory) => {
 			column: primarySpan?.column ?? 0,
 			...primarySpan ? {
 				offset: primarySpan.offset,
-				length: primarySpan.length
+				length: primarySpan.length,
+				...primarySpanEndLine !== void 0 ? { endLine: primarySpanEndLine } : {}
 			} : {},
 			category,
-			...resolveMatchByOccurrence(rule, category) ? { matchByOccurrence: true } : {},
+			...matchByOccurrence ? { matchByOccurrence: true } : {},
 			...relatedLocations.length > 0 ? { relatedLocations } : {}
 		};
 	}), rootDirectory);
@@ -42224,7 +42647,7 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 		directory: scanDirectory,
 		repo
 	}).pipe(orElseSucceed(() => null)) : succeed$2(null));
-	const lintIncludePaths = (input.skipJsxIncludeFilter ? input.includePaths.length > 0 ? [...input.includePaths] : void 0 : computeExplicitLintIncludePaths([...input.includePaths], project)) ?? resolveLintIncludePaths(scanDirectory, resolvedConfig.config, project);
+	const lintIncludePaths = (input.skipExplicitIncludePathFilter ? input.includePaths.length > 0 ? [...input.includePaths] : void 0 : computeExplicitLintIncludePaths([...input.includePaths])) ?? resolveLintIncludePaths(scanDirectory, resolvedConfig.config);
 	const fallbackScannedFilePaths = input.suppressScanSummary ? (lintIncludePaths ?? (yield* filesService.listSourceFiles(scanDirectory))).map((relativePath) => Path.resolve(scanDirectory, relativePath)) : [];
 	const beforeLint = hooks.beforeLint ?? NO_HOOKS.beforeLint;
 	const afterLint = hooks.afterLint ?? NO_HOOKS.afterLint;
@@ -42238,7 +42661,8 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 		respectInlineDisables: input.respectInlineDisables,
 		showWarnings
 	});
-	const applyPerElementPipeline = (rawStream) => rawStream.pipe(filterMap(filterMapNullable(transform.apply)), tap((diagnostic) => reporterService.emit(diagnostic)));
+	const filterPerElementPipeline = (rawStream) => rawStream.pipe(filterMap(filterMapNullable(transform.apply)));
+	const applyPerElementPipeline = (rawStream) => filterPerElementPipeline(rawStream).pipe(tap((diagnostic) => reporterService.emit(diagnostic)));
 	const envCollected = yield* runCollect(applyPerElementPipeline(fromIterable$1(isDiffMode ? [] : [
 		...checkReducedMotion(scanDirectory),
 		...checkPnpmHardening(scanDirectory),
@@ -42367,7 +42791,7 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 		});
 		return empty$4;
 	}))));
-	const lintCollected = yield* runCollect(applyPerElementPipeline(shouldOverlapDeadCode ? baseLintStream.pipe(provideService(OxlintConcurrency, lintConcurrency)) : baseLintStream)).pipe(timeoutOption(lintPhaseTimeoutMs), flatMap$2(match$3({
+	const lintCollected = dedupeRelatedDiagnostics(yield* runCollect(filterPerElementPipeline(shouldOverlapDeadCode ? baseLintStream.pipe(provideService(OxlintConcurrency, lintConcurrency)) : baseLintStream)).pipe(timeoutOption(lintPhaseTimeoutMs), flatMap$2(match$3({
 		onNone: () => set(lintFailure, {
 			didFail: true,
 			reason: `Lint analysis exceeded ${lintPhaseTimeoutMs / MILLISECONDS_PER_SECOND}s and was skipped.`,
@@ -42375,7 +42799,8 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 			reasonKind: null
 		}).pipe(as([])),
 		onSome: succeed$2
-	})));
+	}))));
+	yield* forEach$1(lintCollected, reporterService.emit, { discard: true });
 	const lintFailureState = yield* get$2(lintFailure);
 	yield* afterLint(lintFailureState.didFail);
 	if (lintFailureState.didFail) yield* scanProgress.fail(formatLintFailText(lintFailureState.reasonTag, process.version));
@@ -42719,7 +43144,7 @@ const runEditorScan = async (input) => {
 		warnings,
 		isCi: false,
 		resolveLocalGithubViewerPermission: false,
-		skipJsxIncludeFilter: true
+		skipExplicitIncludePathFilter: true
 	}).pipe(withSpan("runEditorScan", { attributes: {
 		"editor.lint": lint,
 		"editor.runDeadCode": runDeadCode
@@ -42803,7 +43228,7 @@ const computeConfigFingerprint = (projectDirectory, version) => {
 /** Display name used in client-facing messages and progress titles. */
 const SERVER_DISPLAY_NAME = "React Doctor";
 /** Server version reported in `serverInfo`; injected at build, `dev` from source. */
-const SERVER_VERSION = "0.7.6";
+const SERVER_VERSION = "0.7.7";
 /** `Diagnostic.source` shown next to every published diagnostic. */
 const DIAGNOSTIC_SOURCE = "react-doctor";
 /**
@@ -43482,7 +43907,7 @@ const createLintCache = (input) => {
 	let persistTimer = null;
 	try {
 		const parsed = JSON.parse(fs.readFileSync(cacheFilePath, "utf8"));
-		if (parsed.version === 1 && parsed.fingerprint === input.fingerprint) for (const [fsPath, entry] of Object.entries(parsed.entries)) entries.set(fsPath, entry);
+		if (parsed.version === 2 && parsed.fingerprint === input.fingerprint) for (const [fsPath, entry] of Object.entries(parsed.entries)) entries.set(fsPath, entry);
 	} catch {}
 	const persist = () => {
 		if (persistTimer) {
@@ -43493,7 +43918,7 @@ const createLintCache = (input) => {
 		dirty = false;
 		try {
 			const payload = {
-				version: 1,
+				version: 2,
 				fingerprint: input.fingerprint,
 				entries: Object.fromEntries(entries)
 			};
@@ -43506,14 +43931,14 @@ const createLintCache = (input) => {
 		}
 	};
 	return {
-		lookup: (fsPath, stat) => {
+		lookup: (fsPath, identity) => {
 			const entry = entries.get(fsPath);
-			if (entry !== void 0 && entry.mtimeMs === stat.mtimeMs && entry.size === stat.size) return entry.diagnostics;
+			if (entry !== void 0 && entry.contentHash === identity.contentHash) return entry.diagnostics;
 			return null;
 		},
-		store: (fsPath, stat, diagnostics) => {
+		store: (fsPath, identity, diagnostics) => {
 			entries.set(fsPath, {
-				...stat,
+				...identity,
 				diagnostics
 			});
 			dirty = true;
@@ -43602,16 +44027,9 @@ const resolveDiagnosticFsPath = (rawFilePath, scanDirectory, projectDirectory, o
 	}
 	return normalizeFsPath(absolute);
 };
-const statSafe = (fsPath) => {
-	try {
-		const stat = fs.statSync(fsPath);
-		return {
-			mtimeMs: stat.mtimeMs,
-			size: stat.size
-		};
-	} catch {
-		return null;
-	}
+const readFileIdentity = (fsPath) => {
+	const contentHash = hashFileContents(fsPath);
+	return contentHash === null ? null : { contentHash };
 };
 /**
 * Outcome for a per-file request served without running oxlint (every
@@ -43637,7 +44055,7 @@ const outcomeWithoutScan = (request, byFile, requestedPaths) => ({
 * overlay tree (unsaved buffers) or disk, groups diagnostics by canonical
 * absolute path, and reports stale-detection metadata.
 *
-* A persistent per-file lint cache (keyed by mtime + size, namespaced by a
+* A persistent per-file lint cache (keyed by content, namespaced by a
 * config fingerprint) short-circuits unchanged files so a re-opened editor
 * or repeated workspace scan skips the oxlint subprocess for everything it
 * hasn't edited. The cache applies only to disk-based, lint-only, per-file
@@ -43667,15 +44085,15 @@ const createScanRunner = (options) => {
 		const requestedPaths = request.priority === "background" && !request.useOverlay && options.isOpen ? allRequested.filter((fsPath) => !options.isOpen?.(fsPath)) : allRequested;
 		const cache = cacheEnabled && !isWholeProject && !request.useOverlay && !request.runDeadCode ? getCache(projectDirectory) : null;
 		const byFile = /* @__PURE__ */ new Map();
-		const statByPath = /* @__PURE__ */ new Map();
+		const identityByPath = /* @__PURE__ */ new Map();
 		let filesToScan = requestedPaths;
 		if (cache) {
 			const uncached = [];
 			for (const fsPath of requestedPaths) {
-				const stat = statSafe(fsPath);
-				if (stat) {
-					statByPath.set(fsPath, stat);
-					const hit = cache.lookup(fsPath, stat);
+				const identity = readFileIdentity(fsPath);
+				if (identity) {
+					identityByPath.set(fsPath, identity);
+					const hit = cache.lookup(fsPath, identity);
 					if (hit !== null) {
 						if (hit.length > 0) byFile.set(fsPath, hit);
 						continue;
@@ -43718,9 +44136,9 @@ const createScanRunner = (options) => {
 			}
 			if (cache && result.ok && !result.skipped && !result.didLintFail && result.lintPartialFailures.length === 0) {
 				for (const fsPath of filesToScan) {
-					const stat = statByPath.get(fsPath);
-					if (!stat) continue;
-					cache.store(fsPath, stat, byFile.get(fsPath) ?? []);
+					const identity = identityByPath.get(fsPath);
+					if (!identity) continue;
+					cache.store(fsPath, identity, byFile.get(fsPath) ?? []);
 				}
 				cache.schedulePersist();
 			}
@@ -44500,6 +44918,7 @@ const METRIC = {
 	cliInvoked: "cli.invoked",
 	cliError: "cli.error",
 	cliEnvironmentError: "cli.env_error",
+	stagedSnapshotDivergence: "staged.snapshot_divergence",
 	projectDetected: "project.detected",
 	projectPathSelected: "project.path_selected",
 	projectConfigSelected: "project.config_selected",
@@ -44854,5 +45273,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]="b77898db-d8e8-531a-a32b-9de2d1a63635")}catch(e){}}();
-//# debugId=b77898db-d8e8-531a-a32b-9de2d1a63635
+!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]="9428cea1-cc36-547a-941f-20487b0140fc")}catch(e){}}();
+//# debugId=9428cea1-cc36-547a-941f-20487b0140fc