oxlint-plugin-react-doctor 0.6.2-dev.173cc0a → 0.6.2-dev.59e8178

package/dist/index.js

@@ -588,7 +588,7 @@ const SETTER_PATTERN = /^set[A-Z]/;
 const RENDER_FUNCTION_PATTERN = /^render[A-Z]/;
 const UPPERCASE_PATTERN = /^[A-Z]/;
 const REACT_HANDLER_PROP_PATTERN = /^on[A-Z]/;
-const HOOK_NAME_PATTERN$1 = /^use[A-Z]/;
+const HOOK_NAME_PATTERN = /^use[A-Z]/;
 const HANDLER_FUNCTION_NAME_PATTERN = /^(?:on|handle)[A-Z]/;
 const EFFECT_HOOK_NAMES$1 = new Set(["useEffect", "useLayoutEffect"]);
 const HOOKS_WITH_DEPS = new Set([
@@ -4928,8 +4928,7 @@ const isValidTypeValue = (rawValue, settings) => {
 	if (rawValue === "reset") return settings.reset;
 	return false;
 };
-const isProvenValidExpression = (rawExpression, settings, resolvedBindings = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
+const isProvenValidExpression = (expression, settings, resolvedBindings = /* @__PURE__ */ new Set()) => {
 	if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return isValidTypeValue(expression.value, settings);
 	if (isNodeOfType(expression, "TemplateLiteral")) {
 		const staticValue = getStaticTemplateLiteralValue(expression);
@@ -5096,20 +5095,11 @@ const resolveSettings$46 = (settings) => {
 		ignoreExclusiveCheckedAttribute: ruleSettings.ignoreExclusiveCheckedAttribute ?? false
 	};
 };
-const isTruthyDisabledJsxValue = (attribute) => {
-	if (!attribute.value) return true;
-	if (isNodeOfType(attribute.value, "JSXExpressionContainer")) {
-		const expression = attribute.value.expression;
-		return isNodeOfType(expression, "Literal") && expression.value === true;
-	}
-	return false;
-};
 const collectFromJsxAttributes = (attributes) => {
 	let checkedNode = null;
 	let defaultCheckedNode = null;
 	let hasOnChangeOrReadOnly = false;
 	let hasSpread = false;
-	let hasTruthyDisabled = false;
 	for (const attribute of attributes) {
 		if (isNodeOfType(attribute, "JSXSpreadAttribute")) {
 			hasSpread = true;
@@ -5120,14 +5110,12 @@ const collectFromJsxAttributes = (attributes) => {
 		if (name === "checked") checkedNode = attribute;
 		else if (name === "defaultChecked" && !defaultCheckedNode) defaultCheckedNode = attribute;
 		else if (name === "onChange" || name === "readOnly") hasOnChangeOrReadOnly = true;
-		else if (name === "disabled" && isTruthyDisabledJsxValue(attribute)) hasTruthyDisabled = true;
 	}
 	return {
 		checkedNode,
 		defaultCheckedNode,
 		hasOnChangeOrReadOnly,
-		hasSpread,
-		hasTruthyDisabled
+		hasSpread
 	};
 };
 const collectFromObjectProperties = (objectExpression) => {
@@ -5135,7 +5123,6 @@ const collectFromObjectProperties = (objectExpression) => {
 	let defaultCheckedNode = null;
 	let hasOnChangeOrReadOnly = false;
 	let hasSpread = false;
-	let hasTruthyDisabled = false;
 	for (const property of objectExpression.properties) {
 		if (isNodeOfType(property, "SpreadElement")) {
 			hasSpread = true;
@@ -5150,17 +5137,12 @@ const collectFromObjectProperties = (objectExpression) => {
 		if (propertyName === "checked") checkedNode = property;
 		else if (propertyName === "defaultChecked" && !defaultCheckedNode) defaultCheckedNode = property;
 		else if (propertyName === "onChange" || propertyName === "readOnly") hasOnChangeOrReadOnly = true;
-		else if (propertyName === "disabled") {
-			const propertyValue = property.value;
-			if (isNodeOfType(propertyValue, "Literal") && propertyValue.value === true) hasTruthyDisabled = true;
-		}
 	}
 	return {
 		checkedNode,
 		defaultCheckedNode,
 		hasOnChangeOrReadOnly,
-		hasSpread,
-		hasTruthyDisabled
+		hasSpread
 	};
 };
 const checkedRequiresOnchangeOrReadonly = defineRule({
@@ -5176,7 +5158,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 				node: presence.checkedNode,
 				message: EXCLUSIVE_MESSAGE
 			});
-			if (presence.checkedNode && !presence.hasOnChangeOrReadOnly && !presence.hasSpread && !presence.hasTruthyDisabled && !settings.ignoreMissingProperties) context.report({
+			if (presence.checkedNode && !presence.hasOnChangeOrReadOnly && !presence.hasSpread && !settings.ignoreMissingProperties) context.report({
 				node: presence.checkedNode,
 				message: MISSING_MESSAGE$1
 			});
@@ -6450,7 +6432,7 @@ const displayName = defineRule({
 			},
 			ArrowFunctionExpression(node) {
 				if (!containsJsx$1(node)) return;
-				if (isNodeOfType(node.parent, "ArrowFunctionExpression") || isNodeOfType(node.parent, "ReturnStatement")) {
+				if (isNodeOfType(node.parent, "ArrowFunctionExpression")) {
 					reportAt(node);
 					return;
 				}
@@ -7367,7 +7349,7 @@ const TRANSPARENT_WRAPPER_TYPES = new Set([
 	"ParenthesizedExpression",
 	"ChainExpression"
 ]);
-const unwrapExpression$3 = (node) => {
+const unwrapExpression$2 = (node) => {
 	let current = node;
 	while (TRANSPARENT_WRAPPER_TYPES.has(current.type)) {
 		const inner = current.expression;
@@ -7493,7 +7475,7 @@ const symbolHasStableHookOrigin = (symbol) => {
 	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
 	const initializerRaw = declarator.init;
 	if (!initializerRaw) return false;
-	const initializer = unwrapExpression$3(initializerRaw);
+	const initializer = unwrapExpression$2(initializerRaw);
 	if (symbol.kind === "const") {
 		if (isNodeOfType(initializer, "Literal") && (initializer.value === null || typeof initializer.value === "number" || typeof initializer.value === "string" || typeof initializer.value === "boolean")) return true;
 		if (isNodeOfType(initializer, "TemplateLiteral") && getStaticTemplateLiteralValue(initializer) !== null) return true;
@@ -7513,13 +7495,13 @@ const symbolHasStableHookOrigin = (symbol) => {
 	return false;
 };
 const symbolHasUseEffectEventOrigin = (symbol) => {
-	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
+	const initializer = symbol.initializer ? unwrapExpression$2(symbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
 	return getHookName(initializer.callee) === "useEffectEvent";
 };
 const getFunctionValueNode = (symbol) => {
 	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return symbol.declarationNode;
-	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
+	const initializer = symbol.initializer ? unwrapExpression$2(symbol.initializer) : null;
 	if (initializer && (isNodeOfType(initializer, "FunctionExpression") || isNodeOfType(initializer, "ArrowFunctionExpression"))) return initializer;
 	return null;
 };
@@ -7615,14 +7597,6 @@ const flattenReferenceRootName = (reference) => {
 	if (isNodeOfType(referencedIdentifier, "JSXIdentifier")) return referencedIdentifier.name;
 	return "";
 };
-const REF_CURRENT_SEGMENT = ".current";
-const truncateAtRefCurrent = (chain) => {
-	const refCurrentIndex = chain.indexOf(REF_CURRENT_SEGMENT);
-	if (refCurrentIndex === -1) return chain;
-	const segmentEndIndex = refCurrentIndex + 8;
-	if (segmentEndIndex === chain.length || chain[segmentEndIndex] === ".") return chain.slice(0, refCurrentIndex);
-	return chain;
-};
 const computeDepKey = (reference) => {
 	const referencedIdentifier = reference.identifier;
 	let parent = referencedIdentifier.parent ?? null;
@@ -7653,22 +7627,21 @@ const computeDepKey = (reference) => {
 	const declarator = outermost.parent;
 	if (declarator && isNodeOfType(declarator, "VariableDeclarator") && declarator.init === outermost) {
 		const destructuredPath = getDestructuredPropertyPath(declarator.id);
-		if (destructuredPath) return truncateAtRefCurrent(`${fullName}.${destructuredPath}`);
+		if (destructuredPath) return `${fullName}.${destructuredPath}`;
 	}
-	const truncatedName = truncateAtRefCurrent(fullName);
-	if (truncatedName !== fullName) return truncatedName;
 	if (reference.flag !== "read") {
 		const lastDotIndex = fullName.lastIndexOf(".");
 		if (lastDotIndex !== -1) return fullName.slice(0, lastDotIndex);
 	}
+	if (fullName.endsWith(".current")) return fullName.slice(0, -8);
 	return fullName;
 };
 const computeDeclaredDepKey = (entry) => {
-	const stripped = unwrapExpression$3(entry);
+	const stripped = unwrapExpression$2(entry);
 	if (isNodeOfType(stripped, "Identifier")) return stripped.name;
 	if (isNodeOfType(stripped, "MemberExpression")) return stringifyMemberChain(stripped);
 	if (isNodeOfType(stripped, "CallExpression") && (stripped.arguments?.length ?? 0) === 0) {
-		const callee = unwrapExpression$3(stripped.callee);
+		const callee = unwrapExpression$2(stripped.callee);
 		if (isNodeOfType(callee, "Identifier")) return callee.name;
 		if (isNodeOfType(callee, "MemberExpression") && !hasComputedMemberExpression(callee)) return stringifyMemberChain(callee);
 	}
@@ -7676,16 +7649,16 @@ const computeDeclaredDepKey = (entry) => {
 };
 const depsArrayContainsIdentifier = (depsArgument, identifierName) => {
 	if (!depsArgument) return false;
-	const strippedDepsArgument = unwrapExpression$3(depsArgument);
+	const strippedDepsArgument = unwrapExpression$2(depsArgument);
 	if (!isNodeOfType(strippedDepsArgument, "ArrayExpression")) return false;
 	return strippedDepsArgument.elements.some((element) => {
 		if (!element) return false;
-		const strippedElement = unwrapExpression$3(element);
+		const strippedElement = unwrapExpression$2(element);
 		return isNodeOfType(strippedElement, "Identifier") && strippedElement.name === identifierName;
 	});
 };
 const stringifyMemberChain = (node) => {
-	const stripped = unwrapExpression$3(node);
+	const stripped = unwrapExpression$2(node);
 	if (isNodeOfType(stripped, "Identifier")) return stripped.name;
 	if (isNodeOfType(stripped, "ThisExpression")) return "this";
 	if (isNodeOfType(stripped, "MemberExpression")) {
@@ -7727,13 +7700,13 @@ const hasBroaderDeclaredDependency = (declaredKey, declaredKeys) => {
 	return false;
 };
 const getMemberRootIdentifier = (node) => {
-	const stripped = unwrapExpression$3(node);
+	const stripped = unwrapExpression$2(node);
 	if (isNodeOfType(stripped, "Identifier")) return stripped;
 	if (isNodeOfType(stripped, "MemberExpression")) return getMemberRootIdentifier(stripped.object);
 	return null;
 };
 const hasComputedMemberExpression = (node) => {
-	const stripped = unwrapExpression$3(node);
+	const stripped = unwrapExpression$2(node);
 	if (!isNodeOfType(stripped, "MemberExpression")) return false;
 	if (stripped.computed) return true;
 	return hasComputedMemberExpression(stripped.object);
@@ -7749,7 +7722,7 @@ const getRootSymbol = (node, scopes) => {
 	return rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
 };
 const getDeclaredDepSymbolSource = (node) => {
-	const stripped = unwrapExpression$3(node);
+	const stripped = unwrapExpression$2(node);
 	if (isNodeOfType(stripped, "CallExpression") && (stripped.arguments?.length ?? 0) === 0) return stripped.callee;
 	return node;
 };
@@ -7759,7 +7732,7 @@ const isRegExpLiteral = (node) => {
 };
 const isUnstableInitializer = (node) => {
 	if (!node) return false;
-	const stripped = unwrapExpression$3(node);
+	const stripped = unwrapExpression$2(node);
 	if (isRegExpLiteral(stripped)) return true;
 	if (isNodeOfType(stripped, "ConditionalExpression")) return isUnstableInitializer(stripped.consequent) || isUnstableInitializer(stripped.alternate);
 	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left) || isUnstableInitializer(stripped.right);
@@ -7851,9 +7824,9 @@ const findRefCurrentInCleanup = (callback, scopes) => {
 	};
 	findReturn(callback);
 	if (!cleanupFunction) return null;
-	let found = null;
+	let refCurrentName = null;
 	const visitCleanup = (node) => {
-		if (found) return;
+		if (refCurrentName) return;
 		if (isNodeOfType(node, "MemberExpression")) {
 			const candidateName = getRefCurrentNameFromMemberExpression(node);
 			if (candidateName) {
@@ -7861,10 +7834,7 @@ const findRefCurrentInCleanup = (callback, scopes) => {
 				const symbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
 				const callbackScope = scopes.ownScopeFor(callback) ?? scopes.scopeFor(callback);
 				if (!symbol || !isDescendantScope(symbol.scope, callbackScope)) {
-					found = {
-						refCurrentName: candidateName,
-						refSymbol: symbol
-					};
+					refCurrentName = candidateName;
 					return;
 				}
 			}
@@ -7879,19 +7849,7 @@ const findRefCurrentInCleanup = (callback, scopes) => {
 		}
 	};
 	visitCleanup(cleanupFunction);
-	return found;
-};
-const hasRefCurrentAssignmentInComponent = (refSymbol) => {
-	if (!refSymbol) return false;
-	for (const reference of refSymbol.references) {
-		const memberParent = reference.identifier.parent;
-		if (!memberParent || !isNodeOfType(memberParent, "MemberExpression")) continue;
-		if (memberParent.object !== reference.identifier) continue;
-		if (getRefCurrentNameFromMemberExpression(memberParent) === null) continue;
-		const assignmentParent = memberParent.parent;
-		if (assignmentParent && isNodeOfType(assignmentParent, "AssignmentExpression") && assignmentParent.left === memberParent) return true;
-	}
-	return false;
+	return refCurrentName;
 };
 const hasRefCurrentAssignment = (callback, refCurrentName) => {
 	let didAssignRefCurrent = false;
@@ -7930,21 +7888,9 @@ const hasMemberCallForRoot = (node, rootName) => {
 	const visit = (current) => {
 		if (didFindMemberCall) return;
 		if (isNodeOfType(current, "CallExpression")) {
-			const callee = unwrapExpression$3(current.callee);
-			if (isNodeOfType(callee, "MemberExpression")) {
-				let chainObject = unwrapExpression$3(callee.object);
-				let doesChainPassThroughCurrent = false;
-				while (chainObject && isNodeOfType(chainObject, "MemberExpression")) {
-					if (isNodeOfType(chainObject.property, "Identifier") && chainObject.property.name === "current") {
-						doesChainPassThroughCurrent = true;
-						break;
-					}
-					chainObject = unwrapExpression$3(chainObject.object);
-				}
-				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName) {
-					didFindMemberCall = true;
-					return;
-				}
+			if (getMemberRootIdentifier(unwrapExpression$2(current.callee))?.name === rootName) {
+				didFindMemberCall = true;
+				return;
 			}
 		}
 		const record = current;
@@ -8005,7 +7951,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				return;
 			}
 			const depsArgumentRaw = node.arguments[depsArgumentIndex];
-			const callbackExpression = unwrapExpression$3(callbackArgument);
+			const callbackExpression = unwrapExpression$2(callbackArgument);
 			let callbackToAnalyze = null;
 			const forcedCaptureKeys = /* @__PURE__ */ new Set();
 			if (isNodeOfType(callbackExpression, "ArrowFunctionExpression") || isNodeOfType(callbackExpression, "FunctionExpression")) callbackToAnalyze = callbackExpression;
@@ -8013,7 +7959,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				const callbackSymbol = context.scopes.symbolFor(callbackExpression);
 				const functionValueNode = callbackSymbol ? getFunctionValueNode(callbackSymbol) : null;
 				if (functionValueNode) callbackToAnalyze = functionValueNode;
-				else if (callbackSymbol?.initializer && isNodeOfType(unwrapExpression$3(callbackSymbol.initializer), "CallExpression")) forcedCaptureKeys.add(callbackExpression.name);
+				else if (callbackSymbol?.initializer && isNodeOfType(unwrapExpression$2(callbackSymbol.initializer), "CallExpression")) forcedCaptureKeys.add(callbackExpression.name);
 				else if (depsArgumentRaw) {
 					if (depsArrayContainsIdentifier(depsArgumentRaw, callbackExpression.name)) return;
 					context.report({
@@ -8046,11 +7992,11 @@ If the missing value is recreated every render, move it inside the hook or stabi
 					message: buildAssignmentMessage(assignment.name)
 				});
 				if (outerAssignments.length > 0) return;
-				const refCurrentInCleanup = findRefCurrentInCleanup(callbackToAnalyze, context.scopes);
+				const refCurrentName = findRefCurrentInCleanup(callbackToAnalyze, context.scopes);
 				const shouldCheckRefCleanup = EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) || Boolean(additionalHooksRegex && additionalHooksRegex.test(hookName));
-				if (refCurrentInCleanup && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) && !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol)) context.report({
+				if (refCurrentName && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentName)) context.report({
 					node: callbackToAnalyze,
-					message: buildRefCleanupMessage(refCurrentInCleanup.refCurrentName)
+					message: buildRefCleanupMessage(refCurrentName)
 				});
 			}
 			if (!depsArgumentRaw) {
@@ -8070,16 +8016,8 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				});
 				return;
 			}
-			const depsArgument = unwrapExpression$3(depsArgumentRaw);
-			if (isNodeOfType(depsArgument, "Identifier") && depsArgument.name === "undefined") {
-				if (isAutoDependenciesHook(hookName)) return;
-				if (HOOKS_REQUIRING_DEPS_ARRAY.has(hookName)) context.report({
-					node: depsArgument,
-					message: buildMissingDepArrayMessage(hookName)
-				});
-				return;
-			}
-			if (isNodeOfType(depsArgument, "Literal") && depsArgument.value === null) {
+			const depsArgument = unwrapExpression$2(depsArgumentRaw);
+			if (isNodeOfType(depsArgument, "Literal") && depsArgument.value === null || isNodeOfType(depsArgument, "Identifier") && depsArgument.name === "undefined") {
 				if (isAutoDependenciesHook(hookName)) return;
 				if (HOOKS_REQUIRING_DEPS_ARRAY.has(hookName)) {
 					context.report({
@@ -8088,6 +8026,19 @@ If the missing value is recreated every render, move it inside the hook or stabi
 					});
 					return;
 				}
+				const nonArrayCaptureKeys = callbackToAnalyze !== null ? new Set(collectCaptureDepKeys(callbackToAnalyze, context.scopes).keys) : /* @__PURE__ */ new Set();
+				for (const forcedCaptureKey of forcedCaptureKeys) nonArrayCaptureKeys.add(forcedCaptureKey);
+				if (nonArrayCaptureKeys.size > 0) {
+					context.report({
+						node: depsArgument,
+						message: buildNonArrayDepsMessage(hookName)
+					});
+					context.report({
+						node: depsArgument,
+						message: buildMissingDepMessage(hookName, [...nonArrayCaptureKeys].join(", "))
+					});
+				}
+				return;
 			}
 			if (!isNodeOfType(depsArgument, "ArrayExpression")) {
 				context.report({
@@ -8106,11 +8057,11 @@ If the missing value is recreated every render, move it inside the hook or stabi
 			for (const forcedCaptureKey of forcedCaptureKeys) captureKeys.add(forcedCaptureKey);
 			const hasLiteralDepElement = depsArgument.elements.some((element) => {
 				if (!element) return false;
-				return isLiteralOrEmptyTemplate(unwrapExpression$3(element));
+				return isLiteralOrEmptyTemplate(unwrapExpression$2(element));
 			});
 			const hasNonStringLiteralDep = depsArgument.elements.some((element) => {
 				if (!element) return false;
-				return isNonStringLiteral(unwrapExpression$3(element));
+				return isNonStringLiteral(unwrapExpression$2(element));
 			});
 			if (hasNonStringLiteralDep) context.report({
 				node: depsArgument,
@@ -8131,7 +8082,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 					});
 					continue;
 				}
-				const stripped = unwrapExpression$3(elementNode);
+				const stripped = unwrapExpression$2(elementNode);
 				if (isLiteralOrEmptyTemplate(stripped)) continue;
 				if (isNodeOfType(stripped, "Identifier")) {
 					const depSymbol = context.scopes.symbolFor(stripped);
@@ -8273,7 +8224,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (missingCaptureKeys.length > 0 && isOuterFunctionScopeDep(reportNode, callbackToAnalyze ?? callbackArgument, context.scopes)) continue;
 				const rootSymbol = getRootSymbol(reportNode, context.scopes);
 				if (rootSymbol && missingCaptureKeys.length > 0 && isRecursiveInitializerCapture(rootSymbol, callbackToAnalyze ?? callbackArgument)) continue;
-				if (isNodeOfType(unwrapExpression$3(reportNode), "CallExpression")) {
+				if (isNodeOfType(unwrapExpression$2(reportNode), "CallExpression")) {
 					context.report({
 						node: reportNode,
 						message: buildComplexDepMessage(hookName)
@@ -9297,9 +9248,9 @@ const resolveSettings$37 = (settings) => {
 	};
 };
 const isWordBoundary = (text, start, end) => {
-	const isWordCharacter = (charCode) => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || charCode === 45 || charCode === 95;
-	const startsBoundary = start === 0 || !isWordCharacter(text.charCodeAt(start - 1));
-	const endsBoundary = end === text.length || !isWordCharacter(text.charCodeAt(end));
+	const isAlphanumeric = (charCode) => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122;
+	const startsBoundary = start === 0 || !isAlphanumeric(text.charCodeAt(start - 1));
+	const endsBoundary = end === text.length || !isAlphanumeric(text.charCodeAt(end));
 	return startsBoundary && endsBoundary;
 };
 const containsRedundantWord = (altText, words) => {
@@ -9696,7 +9647,7 @@ const isAtomFromJotai = (callExpression) => {
 	if (!isImportedFromModule(callExpression, localName, "jotai")) return false;
 	return getImportedNameFromModule(callExpression, localName, "jotai") === "atom";
 };
-const isFunctionExpressionLike$2 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
+const isFunctionExpressionLike$1 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")));
 const getFirstParameterName = (fn) => {
 	const parameters = fn.params ?? [];
 	if (parameters.length !== 1) return null;
@@ -9829,7 +9780,7 @@ const jotaiDerivedAtomReturnsFreshObject = defineRule({
 		const args = node.arguments ?? [];
 		if (args.length === 0) return;
 		const reader = args[0];
-		if (!isFunctionExpressionLike$2(reader)) return;
+		if (!isFunctionExpressionLike$1(reader)) return;
 		const getParameterName = getFirstParameterName(reader);
 		if (!getParameterName) return;
 		const freshReturn = getFreshReturnForFunction(reader);
@@ -9927,14 +9878,14 @@ const getHandlerNamedBindingName = (functionNode) => {
 const containingFunctionIsComponentOrHook = (functionNode) => {
 	if (isNodeOfType(functionNode, "FunctionDeclaration") && functionNode.id) {
 		const declaredName = functionNode.id.name;
-		return COMPONENT_NAME_PATTERN.test(declaredName) || HOOK_NAME_PATTERN$1.test(declaredName);
+		return COMPONENT_NAME_PATTERN.test(declaredName) || HOOK_NAME_PATTERN.test(declaredName);
 	}
 	let cursor = functionNode.parent ?? null;
 	while (cursor && isNodeOfType(cursor, "CallExpression")) cursor = cursor.parent ?? null;
 	if (!cursor) return false;
 	if (!isNodeOfType(cursor, "VariableDeclarator")) return false;
 	if (!isNodeOfType(cursor.id, "Identifier")) return false;
-	return COMPONENT_NAME_PATTERN.test(cursor.id.name) || HOOK_NAME_PATTERN$1.test(cursor.id.name);
+	return COMPONENT_NAME_PATTERN.test(cursor.id.name) || HOOK_NAME_PATTERN.test(cursor.id.name);
 };
 const isBindingInvokedOnRenderPath = (root, bindingName) => {
 	let didFindRenderPathInvocation = false;
@@ -15648,7 +15599,6 @@ const nextjsMissingMetadata = defineRule({
 		const filename = normalizeFilename(context.filename ?? "");
 		if (!PAGE_FILE_PATTERN.test(filename)) return;
 		if (INTERNAL_PAGE_PATH_PATTERN.test(filename)) return;
-		if ((programNode.body ?? []).some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === "use client")) return;
 		if (programNode.body?.some((statement) => {
 			if (!isNodeOfType(statement, "ExportNamedDeclaration")) return false;
 			const declaration = statement.declaration;
@@ -17378,38 +17328,14 @@ const resolvesToRefFactoryCall = (identifier) => {
 	});
 	return found;
 };
-const unwrapExpression$2 = (node) => {
-	if (!node) return null;
-	if (isNodeOfType(node, "ChainExpression")) return unwrapExpression$2(node.expression);
-	if (isNodeOfType(node, "TSNonNullExpression")) return unwrapExpression$2(node.expression);
-	return node;
-};
-const resolvesToRefCurrentAlias = (identifier, visitedAliasNames) => {
-	if (visitedAliasNames.has(identifier.name)) return false;
-	const root = findProgramRoot(identifier);
-	if (!root) return false;
-	const nextVisited = new Set([...visitedAliasNames, identifier.name]);
-	let found = false;
-	walkAst(root, (child) => {
-		if (found) return false;
-		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.id.name === identifier.name) {
-			const init = unwrapExpression$2(child.init);
-			if (init && isNodeOfType(init, "MemberExpression") && isNodeOfType(init.property, "Identifier") && init.property.name === "current" && isRefLikeReceiver(init.object, nextVisited)) {
-				found = true;
-				return false;
-			}
-		}
-	});
-	return found;
-};
-const isRefLikeReceiver = (receiver, visitedAliasNames = /* @__PURE__ */ new Set()) => {
+const isRefLikeReceiver = (receiver) => {
 	if (!receiver) return false;
-	if (isNodeOfType(receiver, "ChainExpression")) return isRefLikeReceiver(receiver.expression, visitedAliasNames);
-	if (isNodeOfType(receiver, "TSNonNullExpression")) return isRefLikeReceiver(receiver.expression, visitedAliasNames);
-	if (isNodeOfType(receiver, "Identifier")) return hasRefLikeName(receiver.name) || resolvesToRefFactoryCall(receiver) || resolvesToRefCurrentAlias(receiver, visitedAliasNames);
+	if (isNodeOfType(receiver, "ChainExpression")) return isRefLikeReceiver(receiver.expression);
+	if (isNodeOfType(receiver, "TSNonNullExpression")) return isRefLikeReceiver(receiver.expression);
+	if (isNodeOfType(receiver, "Identifier")) return hasRefLikeName(receiver.name) || resolvesToRefFactoryCall(receiver);
 	if (isNodeOfType(receiver, "MemberExpression") && isNodeOfType(receiver.property, "Identifier")) {
 		if (hasRefLikeName(receiver.property.name)) return true;
-		if (receiver.property.name === "current") return isRefLikeReceiver(receiver.object, visitedAliasNames);
+		if (receiver.property.name === "current") return isRefLikeReceiver(receiver.object);
 	}
 	return false;
 };
@@ -17544,19 +17470,6 @@ const getScopeForNode = (node, manager) => {
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/ast.ts
 const getChildKeys = (node) => VISITOR_KEYS[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
-const HOOK_NAME_PATTERN = /^use[A-Z0-9]/;
-const isInsideCallbackArgumentOf = (identifier, initializer) => {
-	if (!isNodeOfType(initializer, "CallExpression") && !isNodeOfType(initializer, "NewExpression")) return false;
-	if (isNodeOfType(initializer, "CallExpression") && isNodeOfType(initializer.callee, "Identifier") && HOOK_NAME_PATTERN.test(initializer.callee.name)) return false;
-	const callbackArguments = (initializer.arguments ?? []).filter((argument) => isFunctionLike$1(argument));
-	if (callbackArguments.length === 0) return false;
-	let node = identifier;
-	while (node && node !== initializer) {
-		if (callbackArguments.includes(node)) return true;
-		node = node.parent;
-	}
-	return false;
-};
 const ascend = (analysis, ref, visit, visited = /* @__PURE__ */ new Set()) => {
 	if (visited.has(ref)) return;
 	const result = visit(ref);
@@ -17569,10 +17482,7 @@ const ascend = (analysis, ref, visit, visited = /* @__PURE__ */ new Set()) => {
 		const defNode = def.node;
 		const next = defNode.init ?? defNode.body;
 		if (!next) continue;
-		for (const innerRef of getDownstreamRefs(analysis, next)) {
-			if (isInsideCallbackArgumentOf(innerRef.identifier, next)) continue;
-			ascend(analysis, innerRef, visit, visited);
-		}
+		for (const innerRef of getDownstreamRefs(analysis, next)) ascend(analysis, innerRef, visit, visited);
 	}
 };
 const descend = (node, visit, visited = /* @__PURE__ */ new Set()) => {
@@ -18021,8 +17931,7 @@ const noAriaHiddenOnFocusable = defineRule({
 			if (isNodeOfType(value, "Literal") && value.value !== "true") return;
 			if (isNodeOfType(value, "JSXExpressionContainer")) {
 				const expression = value.expression;
-				if (!isNodeOfType(expression, "Literal")) return;
-				if (expression.value !== true && expression.value !== "true") return;
+				if (isNodeOfType(expression, "Literal") && !expression.value) return;
 			}
 		}
 		const tag = getElementType(node, context.settings);
@@ -18277,30 +18186,10 @@ const isArrayFromCall = (node) => {
 *
 * Used both for `<receiver>.map(...)` and for `Array.from(<length>, fn)`.
 */
-const isBindingReassigned = (referenceNode, bindingName) => {
-	const programRoot = findProgramRoot(referenceNode);
-	if (!programRoot) return false;
-	let didFindReassignment = false;
-	walkAst(programRoot, (child) => {
-		if (didFindReassignment) return false;
-		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.left, "Identifier") && child.left.name === bindingName) {
-			didFindReassignment = true;
-			return false;
-		}
-	});
-	return didFindReassignment;
-};
-const isStaticPlaceholderReceiver = (receiver, depth = 0) => {
+const isStaticPlaceholderReceiver = (receiver) => {
 	if (isArrayFromCall(receiver)) return true;
 	if (isArrayConstructorCallWithNumericLength(receiver)) return true;
 	if (isAllLiteralArrayExpression(receiver)) return true;
-	if (isNodeOfType(receiver, "Identifier")) {
-		if (depth >= TYPE_RESOLUTION_DEPTH_LIMIT) return false;
-		const binding = findVariableInitializer(receiver, receiver.name);
-		if (!binding?.initializer) return false;
-		if (isBindingReassigned(receiver, receiver.name)) return false;
-		return isStaticPlaceholderReceiver(binding.initializer, depth + 1);
-	}
 	if (isNodeOfType(receiver, "CallExpression")) {
 		const callee = receiver.callee;
 		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "fill" && isArrayConstructorCallWithNumericLength(callee.object)) return true;
@@ -18326,7 +18215,6 @@ const isArrayFromLengthObjectCall = (node) => {
 		if (!(isNodeOfType(key, "Identifier") && key.name === "length" || isNodeOfType(key, "Literal") && key.value === "length")) continue;
 		if (isNumericLiteralOrUndefined(prop.value)) return true;
 		if (isNodeOfType(prop.value, "Identifier")) return true;
-		if (isNodeOfType(prop.value, "MemberExpression") && isNodeOfType(prop.value.property, "Identifier") && prop.value.property.name === "length") return true;
 	}
 	return false;
 };
@@ -18435,11 +18323,10 @@ const isInsideStaticPlaceholderMap = (node) => isInsideIteratorMapMatching(node,
 /**
 * Walk up from a JSXAttribute node looking for the enclosing iterator
 * callback (`.map(cb)`, `.flatMap(cb)`, `.forEach(cb)`, `Array.from(_, cb)`)
-* and return the names bound by the first parameter — `item` in
-* `arr.map((item, index) => …)`, or every destructured field in
-* `arr.map(({ id, label }, index) => …)`.
+* and return the first parameter's name. The first param is the per-item
+* value, e.g. `item` in `arr.map((item, index) => …)`.
 */
-const findIteratorItemNames = (node) => {
+const findIteratorItemName$1 = (node) => {
 	let current = node;
 	while (current.parent) {
 		const parent = current.parent;
@@ -18449,20 +18336,18 @@ const findIteratorItemNames = (node) => {
 			const isArrayFromCallback = isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current;
 			if (isIteratorMethodCall || isArrayFromCallback) {
 				const first = (current.params ?? [])[0];
-				if (!first) return null;
-				const names = /* @__PURE__ */ new Set();
-				collectPatternNames(first, names);
-				return names.size > 0 ? names : null;
+				if (first && isNodeOfType(first, "Identifier")) return first.name;
+				return null;
 			}
 		}
 		current = parent;
 	}
 	return null;
 };
-const templateLiteralHasIteratorIdentity = (template, itemNames) => {
+const templateLiteralHasIteratorIdentity = (template, itemName) => {
 	for (const expression of template.expressions ?? []) {
-		const rootName = getRootIdentifierName(expression, { followCallChains: true });
-		if (rootName !== null && itemNames.has(rootName)) return true;
+		if (isNodeOfType(expression, "Identifier") && expression.name === itemName) return true;
+		if (isNodeOfType(expression, "MemberExpression") && isNodeOfType(expression.object, "Identifier") && expression.object.name === itemName) return true;
 	}
 	return false;
 };
@@ -18475,32 +18360,9 @@ const templateLiteralHasIteratorIdentity = (template, itemNames) => {
 const isCompositeKeyWithIteratorIdentity = (keyExpression, attributeNode) => {
 	if (!isNodeOfType(keyExpression, "TemplateLiteral")) return false;
 	if ((keyExpression.expressions ?? []).length < 2) return false;
-	const itemNames = findIteratorItemNames(attributeNode);
-	if (!itemNames) return false;
-	return templateLiteralHasIteratorIdentity(keyExpression, itemNames);
-};
-const forLoopTestReadsDataLength = (test) => {
-	let didFindLengthRead = false;
-	walkAst(test, (child) => {
-		if (didFindLengthRead) return false;
-		if (isNodeOfType(child, "MemberExpression") && isNodeOfType(child.property, "Identifier") && child.property.name === "length") {
-			didFindLengthRead = true;
-			return false;
-		}
-	});
-	return didFindLengthRead;
-};
-const isNumericForLoopCounter = (attributeNode, indexName) => {
-	const binding = findVariableInitializer(attributeNode, indexName);
-	if (!binding) return false;
-	const declarator = binding.bindingIdentifier.parent;
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return false;
-	const declaration = declarator.parent;
-	if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) return false;
-	const forStatement = declaration.parent;
-	if (!forStatement || !isNodeOfType(forStatement, "ForStatement") || forStatement.init !== declaration || !declarator.init || !isNodeOfType(declarator.init, "Literal") || typeof declarator.init.value !== "number") return false;
-	if (forStatement.test && forLoopTestReadsDataLength(forStatement.test)) return false;
-	return true;
+	const itemName = findIteratorItemName$1(attributeNode);
+	if (!itemName) return false;
+	return templateLiteralHasIteratorIdentity(keyExpression, itemName);
 };
 const noArrayIndexAsKey = defineRule({
 	id: "no-array-index-as-key",
@@ -18512,7 +18374,6 @@ const noArrayIndexAsKey = defineRule({
 		if (!node.value || !isNodeOfType(node.value, "JSXExpressionContainer")) return;
 		const indexName = extractIndexName(node.value.expression);
 		if (!indexName) return;
-		if (isNumericForLoopCounter(node, indexName)) return;
 		if (isInsideStaticPlaceholderMap(node)) return;
 		if (isInsideStringDerivedMap(node)) return;
 		if (isCompositeKeyWithIteratorIdentity(node.value.expression, node)) return;
@@ -20878,7 +20739,7 @@ const isStateMemberExpression = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/no-direct-mutation-state.ts
-const MESSAGE$24 = "Mutating `this.state` by hand never triggers a redraw on its own & a later setState can overwrite it, so use `this.setState` instead.";
+const MESSAGE$24 = "Your users see stale data because mutating `this.state` by hand never redraws & gets overwritten.";
 const shouldIgnoreMutation = (node) => {
 	let isConstructor = false;
 	let isInsideCallExpression = false;
@@ -20972,18 +20833,6 @@ const initializerMarksPlainState = (initializerArgument) => {
 	}
 	return producesPlainStateValue(unwrapped);
 };
-const collectCallbackRefSetterNames = (componentBody) => {
-	const callbackRefSetterNames = /* @__PURE__ */ new Set();
-	walkAst(componentBody, (node) => {
-		if (!isNodeOfType(node, "JSXAttribute")) return;
-		const attributeName = node.name;
-		if (isNodeOfType(attributeName, "JSXIdentifier") && attributeName.name === "ref" && node.value && isNodeOfType(node.value, "JSXExpressionContainer")) {
-			const expression = stripParenExpression(node.value.expression);
-			if (isNodeOfType(expression, "Identifier")) callbackRefSetterNames.add(expression.name);
-		}
-	});
-	return callbackRefSetterNames;
-};
 const collectFunctionLocalBindings = (functionNode) => {
 	const localBindings = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return localBindings;
@@ -21026,10 +20875,8 @@ const noDirectStateMutation = defineRule({
 			const bindings = collectUseStateBindings(componentBody);
 			if (bindings.length === 0) return;
 			const stateValueToSetter = new Map(bindings.map((binding) => [binding.valueName, binding.setterName]));
-			const callbackRefSetterNames = collectCallbackRefSetterNames(componentBody);
 			const plainObjectStateValueNames = /* @__PURE__ */ new Set();
 			for (const binding of bindings) {
-				if (callbackRefSetterNames.has(binding.setterName)) continue;
 				if (!isNodeOfType(binding.declarator.init, "CallExpression")) continue;
 				if (initializerMarksPlainState(binding.declarator.init.arguments?.[0])) plainObjectStateValueNames.add(binding.valueName);
 			}
@@ -21042,7 +20889,7 @@ const noDirectStateMutation = defineRule({
 					if (currentlyShadowed.has(rootName)) return;
 					context.report({
 						node: child,
-						message: `React can't tell you changed "${rootName}" in place, so this update can be skipped or lost.`
+						message: `Your screen won't update because you change "${rootName}" in place.`
 					});
 					return;
 				}
@@ -21058,7 +20905,7 @@ const noDirectStateMutation = defineRule({
 					if (currentlyShadowed.has(rootName)) return;
 					context.report({
 						node: child,
-						message: `React can't tell .${methodName}() changed "${rootName}" in place, so this update can be skipped or lost.`
+						message: `Your screen won't update because .${methodName}() changes "${rootName}" in place.`
 					});
 				}
 			});
@@ -22927,16 +22774,11 @@ const NON_DETERMINISTIC_ID_GENERATOR_NAMES = new Set([
 	"ulid",
 	"createId"
 ]);
-const isZeroArgDateConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Date" && (node.arguments?.length ?? 0) === 0;
 const containsNonDeterministicSource = (root) => {
 	let found = false;
 	walkAst(root, (child) => {
 		if (found) return false;
 		if (isFunctionLike$1(child)) return false;
-		if (isZeroArgDateConstruction(child)) {
-			found = true;
-			return false;
-		}
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const callee = child.callee;
 		if (isNodeOfType(callee, "Identifier") && NON_DETERMINISTIC_ID_GENERATOR_NAMES.has(callee.name)) {
@@ -22997,53 +22839,6 @@ const argumentReadsPostMountMeasurement = (argument, effectFn, visitedLocalNames
 	});
 	return found;
 };
-const isResourceLikeInitializer = (initializer) => {
-	if (isNodeOfType(initializer, "AwaitExpression")) return isResourceLikeInitializer(initializer.argument);
-	return isNodeOfType(initializer, "NewExpression") || isNodeOfType(initializer, "CallExpression");
-};
-const collectArgumentSourceLocalNames = (argument, effectFn, sourceLocalNames = /* @__PURE__ */ new Set()) => {
-	walkAst(argument, (child) => {
-		if (!isNodeOfType(child, "Identifier")) return;
-		if (sourceLocalNames.has(child.name)) return;
-		const localInitializer = findEffectLocalInitializer(effectFn, child.name);
-		if (!localInitializer || !isResourceLikeInitializer(localInitializer)) return;
-		sourceLocalNames.add(child.name);
-		collectArgumentSourceLocalNames(localInitializer, effectFn, sourceLocalNames);
-	});
-	return sourceLocalNames;
-};
-const isFunctionExpressionLike$1 = (node) => isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression");
-const findCleanupFunction = (effectFn) => {
-	if (!isNodeOfType(effectFn, "ArrowFunctionExpression") && !isNodeOfType(effectFn, "FunctionExpression")) return null;
-	const body = effectFn.body;
-	if (!isNodeOfType(body, "BlockStatement")) return null;
-	let cleanupFunction = null;
-	walkAst(body, (child) => {
-		if (cleanupFunction) return false;
-		if (isNodeOfType(child, "ReturnStatement")) {
-			if (child.argument && isFunctionExpressionLike$1(child.argument)) cleanupFunction = child.argument;
-			return false;
-		}
-		if (child !== body && isFunctionExpressionLike$1(child)) return false;
-		if (isNodeOfType(child, "FunctionDeclaration")) return false;
-	});
-	return cleanupFunction;
-};
-const cleanupDisposesArgumentSource = (argument, effectFn) => {
-	const cleanupFunction = findCleanupFunction(effectFn);
-	if (!cleanupFunction) return false;
-	const sourceLocalNames = collectArgumentSourceLocalNames(argument, effectFn);
-	if (sourceLocalNames.size === 0) return false;
-	let referencesSource = false;
-	walkAst(cleanupFunction, (child) => {
-		if (referencesSource) return false;
-		if (isNodeOfType(child, "Identifier") && sourceLocalNames.has(child.name)) {
-			referencesSource = true;
-			return false;
-		}
-	});
-	return referencesSource;
-};
 const noInitializeState = defineRule({
 	id: "no-initialize-state",
 	title: "State initialized from a mount effect",
@@ -23066,7 +22861,6 @@ const noInitializeState = defineRule({
 			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
 			if (callExpr.arguments?.some((argument) => Boolean(argument) && containsNonDeterministicSource(argument))) continue;
 			if (callExpr.arguments?.some((argument) => Boolean(argument) && argumentReadsPostMountMeasurement(argument, effectFn))) continue;
-			if (callExpr.arguments?.some((argument) => Boolean(argument) && cleanupDisposesArgumentSource(argument, effectFn))) continue;
 			const useStateDecl = getUseStateDecl(analysis, ref);
 			if (!useStateDecl || !isNodeOfType(useStateDecl, "VariableDeclarator")) continue;
 			if (!isNodeOfType(useStateDecl.id, "ArrayPattern")) continue;
@@ -24984,18 +24778,6 @@ const KEYBOARD_HANDLER_PROP_NAMES = [
 	"onKeyPress"
 ];
 const isKeyboardOperable = (node) => KEYBOARD_HANDLER_PROP_NAMES.some((propName) => Boolean(hasJsxPropIgnoreCase(node.attributes, propName)));
-const parseNumericBranch = (expression) => {
-	if (isNodeOfType(expression, "Literal") && typeof expression.value === "number") return expression.value;
-	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "-" && isNodeOfType(expression.argument, "Literal") && typeof expression.argument.value === "number") return -expression.argument.value;
-	return null;
-};
-const isRovingTabindexValue = (value) => {
-	if (!isNodeOfType(value, "JSXExpressionContainer")) return false;
-	const expression = value.expression;
-	if (!isNodeOfType(expression, "ConditionalExpression")) return false;
-	if (isNodeOfType(expression.test, "Literal")) return false;
-	return [parseNumericBranch(expression.consequent), parseNumericBranch(expression.alternate)].some((branchValue) => branchValue !== null && branchValue < 0);
-};
 const resolveSettings$14 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noNoninteractiveTabindex ?? {} : {};
@@ -25019,7 +24801,6 @@ const noNoninteractiveTabindex = defineRule({
 			if (!tabIndex) return;
 			const tabIndexValue = tabIndex.value;
 			if (!tabIndexValue) return;
-			if (isRovingTabindexValue(tabIndexValue)) return;
 			const numeric = parseJsxValue(tabIndexValue);
 			if (numeric === null) {
 				if (isNodeOfType(tabIndexValue, "JSXExpressionContainer") && !settings.allowExpressionValues && !isKeyboardOperable(node)) context.report({
@@ -26456,7 +26237,7 @@ const noRenderInRender = defineRule({
 	title: "Component rendered by inline function call",
 	severity: "warn",
 	tags: ["test-noise"],
-	recommendation: "Make it a named component rendered as JSX so React can track it and preserve its state.",
+	recommendation: "Make it a named component so React preserves its identity and does not remount its state.",
 	create: (context) => ({ JSXExpressionContainer(node) {
 		const expression = node.expression;
 		if (!isNodeOfType(expression, "CallExpression")) return;
@@ -26471,7 +26252,7 @@ const noRenderInRender = defineRule({
 		}
 		context.report({
 			node: expression,
-			message: `"${calleeName}()" hides a component behind an inline call, so pull it into its own component and render it as JSX so React can track it.`
+			message: `Your users lose state because "${calleeName}()" builds UI from an inline call that React remounts, so pull it into its own component instead.`
 		});
 	} })
 });
@@ -26574,8 +26355,8 @@ const countUseStates = (analysis, componentNode) => {
 	for (const ref of getDownstreamRefs(analysis, componentNode)) if (isState(analysis, ref)) stateVariables.add(ref.resolved);
 	return stateVariables.size;
 };
-const findPropUsedToResetAllState = (analysis, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
-	const stateSetterRefs = effectFnRefs.filter((ref) => isSyncStateSetterCall(analysis, ref, effectFn));
+const findPropUsedToResetAllState = (analysis, effectFnRefs, depsRefs, useEffectNode) => {
+	const stateSetterRefs = effectFnRefs.filter((ref) => isStateSetterCall(analysis, ref));
 	if (stateSetterRefs.length === 0) return null;
 	if (!stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, ref))) return null;
 	const containing = findContainingNode(analysis, useEffectNode);
@@ -26598,9 +26379,7 @@ const noResetAllStateOnPropChange = defineRule({
 		if (!effectFnRefs || !depsRefs) return;
 		const containing = findContainingNode(analysis, node);
 		if (containing && isCustomHook(containing)) return;
-		const effectFn = getEffectFn(analysis, node);
-		if (!effectFn) return;
-		if (!findPropUsedToResetAllState(analysis, effectFnRefs, depsRefs, node, effectFn)) return;
+		if (!findPropUsedToResetAllState(analysis, effectFnRefs, depsRefs, node)) return;
 		context.report({
 			node,
 			message: `Your users briefly see stale state when a prop changes because this useEffect clears all state.`
@@ -27468,7 +27247,6 @@ const noStaticElementInteractions = defineRule({
 			if (!hasNonBlockerHandler) return;
 			const elementType = getElementType(node, context.settings);
 			if (!HTML_TAGS.has(elementType)) return;
-			if (elementType === "svg") return;
 			if (isHiddenFromScreenReader(node, context.settings)) return;
 			if (isPresentationRole(node)) return;
 			if (isInteractiveElement(elementType, node)) return;
@@ -27482,8 +27260,7 @@ const noStaticElementInteractions = defineRule({
 				});
 				return;
 			}
-			let attributeValue = roleAttribute.value;
-			if (isNodeOfType(attributeValue, "JSXExpressionContainer") && isNodeOfType(attributeValue.expression, "Literal") && typeof attributeValue.expression.value === "string") attributeValue = attributeValue.expression;
+			const attributeValue = roleAttribute.value;
 			if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") {
 				const firstRole = attributeValue.value.toLowerCase().trim().split(/\s+/)[0];
 				if (firstRole && (isInteractiveRole(firstRole) || isNonInteractiveRole(firstRole))) return;
@@ -30282,7 +30059,7 @@ const containsVnodeFactoryCall = (root) => {
 };
 const isComponentLikeFunction = (functionNode) => {
 	const bindingName = getFunctionBindingName(functionNode);
-	if (bindingName && (isReactComponentName(bindingName) || HOOK_NAME_PATTERN$1.test(bindingName))) return true;
+	if (bindingName && (isReactComponentName(bindingName) || HOOK_NAME_PATTERN.test(bindingName))) return true;
 	const body = "body" in functionNode ? functionNode.body : null;
 	if (!body || !isAstNode(body)) return false;
 	return containsJsxElement(body) || containsVnodeFactoryCall(body);
@@ -31739,7 +31516,7 @@ const queryMutationMissingInvalidation = defineRule({
 		});
 		if (!hasCacheUpdate) context.report({
 			node,
-			message: "useMutation with no cache update here can leave your users looking at stale data after it runs."
+			message: "useMutation with no cache update leaves your users looking at stale data after it runs."
 		});
 	} })
 });
@@ -32388,7 +32165,6 @@ const renderingHydrationMismatchTime = defineRule({
 		return { JSXExpressionContainer(node) {
 			if (isTestlikeFile) return;
 			if (!node.expression) return;
-			if (isGeneratedImageRenderContext(context, findOpeningElementOfChild(node) ?? node)) return;
 			const matched = NONDETERMINISTIC_RENDER_PATTERNS.find((pattern) => pattern.matches(node.expression));
 			if (matched) {
 				if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
@@ -34204,7 +33980,7 @@ const rnNoDimensionsGet = defineRule({
 		if (binding !== null && !isBindingReactNativeDimensions(node, binding)) return;
 		if (isMemberProperty(node.callee, "get")) context.report({
 			node,
-			message: "Dimensions.get() reads the size once and never updates, so layouts built from it go stale on rotation or resize."
+			message: "Your users see a stale layout on rotation or resize because Dimensions.get() does not update."
 		});
 		if (isMemberProperty(node.callee, "addEventListener")) context.report({
 			node,
@@ -35026,10 +34802,7 @@ const isExpoUiComponentElement = (openingElement, contextNode, componentName) =>
 };
 //#endregion
 //#region src/plugin/rules/react-native/rn-no-raw-text.ts
-const truncateText = (text) => {
-	const collapsedText = text.replace(/\s+/g, " ");
-	return collapsedText.length > 30 ? `${collapsedText.slice(0, 30)}...` : collapsedText;
-};
+const truncateText = (text) => text.length > 30 ? `${text.slice(0, 30)}...` : text;
 const isRawTextContent = (child) => {
 	if (isNodeOfType(child, "JSXText")) return Boolean(child.value?.trim());
 	if (!isNodeOfType(child, "JSXExpressionContainer") || !child.expression) return false;
@@ -39298,7 +39071,7 @@ const isInsideClassComponent = (node) => {
 const hasShortCircuitAncestor = (descendant, ancestor) => {
 	let current = descendant.parent;
 	while (current && current !== ancestor) {
-		if (isNodeOfType(current, "ConditionalExpression") && (isWithinRange(descendant, current.consequent) || isWithinRange(descendant, current.alternate))) return true;
+		if (isNodeOfType(current, "ConditionalExpression")) return true;
 		if (isNodeOfType(current, "LogicalExpression") && (current.operator === "&&" || current.operator === "||" || current.operator === "??") && isWithinRange(descendant, current.right)) return true;
 		current = current.parent ?? null;
 	}
@@ -39424,7 +39197,6 @@ const rulesOfHooks = defineRule({
 						if (parentInfo.isComponentOrHook) isInsideComponentOrHook = true;
 					}
 					if (!isInsideComponentOrHook) {
-						if (!enclosing.hasResolvedName) return;
 						if (isLocalNonHookFunctionCallee(node, context.scopes, settings)) return;
 						context.report({
 							node: node.callee,
@@ -39999,14 +39771,6 @@ const objectExpressionHasCachingConfig = (objectExpression) => (objectExpression
 const objectExpressionHasSpread = (objectExpression) => (objectExpression.properties ?? []).some((property) => isNodeOfType(property, "SpreadElement"));
 const APP_ROUTER_FILE_PATTERN = new RegExp(`/app/(?:[^/]+/)*(?:route|page|layout|template|loading|error|default)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
 const NON_PROJECT_PATH_PATTERN = /\/(?:node_modules|dist|build|\.next)\//;
-const REMIX_IMPORT_SOURCE_PATTERN = /^(?:@remix-run\/|@react-router\/|react-router(?:-dom)?$)/;
-const programImportsRemixRouter = (programNode) => (programNode.body ?? []).some((statement) => isNodeOfType(statement, "ImportDeclaration") && !isTypeOnlyImport(statement) && typeof statement.source?.value === "string" && REMIX_IMPORT_SOURCE_PATTERN.test(statement.source.value));
-const isImportMetaUrlAssetArgument = (urlArg) => {
-	if (!isNodeOfType(urlArg, "NewExpression")) return false;
-	if (!isNodeOfType(urlArg.callee, "Identifier") || urlArg.callee.name !== "URL") return false;
-	const baseArg = urlArg.arguments?.[1];
-	return isNodeOfType(baseArg, "MemberExpression") && isNodeOfType(baseArg.object, "MetaProperty") && isNodeOfType(baseArg.property, "Identifier") && baseArg.property.name === "url";
-};
 const serverFetchWithoutRevalidate = defineRule({
 	id: "server-fetch-without-revalidate",
 	title: "Fetch without revalidate",
@@ -40026,7 +39790,7 @@ const serverFetchWithoutRevalidate = defineRule({
 					isServerSideFile = false;
 					return;
 				}
-				isServerSideFile = !(node.body ?? []).some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === "use client") && !programImportsRemixRouter(node);
+				isServerSideFile = !(node.body ?? []).some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === "use client");
 			},
 			CallExpression(node) {
 				if (!isServerSideFile) return;
@@ -40039,7 +39803,6 @@ const serverFetchWithoutRevalidate = defineRule({
 					if (objectExpressionHasSpread(optionsArg)) return;
 				}
 				const urlArg = node.arguments?.[0];
-				if (isImportMetaUrlAssetArgument(urlArg)) return;
 				const urlText = isNodeOfType(urlArg, "Literal") && typeof urlArg.value === "string" ? `"${urlArg.value}"` : "url";
 				context.report({
 					node,
@@ -40268,7 +40031,7 @@ const serverNoMutableModuleState = defineRule({
 					if (node.kind === "let" || node.kind === "var") {
 						context.report({
 							node: declarator,
-							message: `Module-scoped ${node.kind} "${variableName}" is shared by every request, so any write to it leaks state between your users.`
+							message: `Module-scoped ${node.kind} "${variableName}" leaks state between your users, since every request shares it.`
 						});
 						continue;
 					}
@@ -40329,29 +40092,25 @@ const GATE_LEADING_VERBS = new Set([
 	"authorize",
 	"authenticate"
 ]);
-const declarationAwaitsExistingPromise = (declaration) => {
-	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
-	for (const declarator of declaration.declarations ?? []) {
-		const init = declarator.init;
-		if (!isNodeOfType(init, "AwaitExpression")) continue;
-		const argument = init.argument;
-		if (isNodeOfType(argument, "Identifier") || isNodeOfType(argument, "MemberExpression")) return true;
+const isStartedPromiseBinding = (name, statements, beforeIndex) => {
+	for (let index = 0; index < beforeIndex; index++) {
+		const statement = statements[index];
+		if (!isNodeOfType(statement, "VariableDeclaration")) continue;
+		for (const declarator of statement.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			if (declarator.id.name !== name) continue;
+			if (declarator.init && !isNodeOfType(declarator.init, "AwaitExpression")) return true;
+		}
 	}
 	return false;
 };
-const REQUEST_SCOPED_IMPORT_SOURCES = ["next/headers", "next-intl/server"];
-const isRequestScopedCallee = (callee) => {
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	if (REQUEST_SCOPED_IMPORT_SOURCES.some((moduleSource) => getImportedNameFromModule(callee, callee.name, moduleSource) !== null)) return true;
-	return getImportedNameFromModule(callee, callee.name, "next/server") === "connection";
-};
-const declarationAwaitsRequestScopedCall = (declaration) => {
+const declarationAwaitsStartedPromise = (declaration, statements, declarationIndex) => {
 	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
 	for (const declarator of declaration.declarations ?? []) {
 		const init = declarator.init;
 		if (!isNodeOfType(init, "AwaitExpression")) continue;
 		const argument = init.argument;
-		if (isNodeOfType(argument, "CallExpression") && isRequestScopedCallee(argument.callee)) return true;
+		if (isNodeOfType(argument, "Identifier") && isStartedPromiseBinding(argument.name, statements, declarationIndex)) return true;
 	}
 	return false;
 };
@@ -40386,8 +40145,7 @@ const serverSequentialIndependentAwait = defineRule({
 				if (!isNodeOfType(nextStatement, "VariableDeclaration")) continue;
 				if (!declarationStartsWithAwait(nextStatement)) continue;
 				if (declarationReadsAnyName(nextStatement, declaredNames)) continue;
-				if (declarationAwaitsExistingPromise(nextStatement)) continue;
-				if (declarationAwaitsRequestScopedCall(currentStatement) || declarationAwaitsRequestScopedCall(nextStatement)) continue;
+				if (declarationAwaitsStartedPromise(nextStatement, statements, statementIndex + 1)) continue;
 				if (declarationAwaitsGate(currentStatement)) continue;
 				context.report({
 					node: nextStatement,
@@ -41340,7 +41098,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 			if (!isNodeOfType(callParent, "CallExpression")) return false;
 			if (callParent.callee === functionNode) return false;
 			if (isNodeOfType(callParent.callee, "MemberExpression") && !callParent.callee.computed && isNodeOfType(callParent.callee.property, "Identifier") && PROMISE_CONTINUATION_METHODS.has(callParent.callee.property.name)) return true;
-			return isNodeOfType(callParent.callee, "Identifier") && HOOK_NAME_PATTERN$1.test(callParent.callee.name) && !RENDER_SYNCHRONOUS_HOOK_NAMES.has(callParent.callee.name) && callParent.arguments?.[0] === functionNode;
+			return isNodeOfType(callParent.callee, "Identifier") && HOOK_NAME_PATTERN.test(callParent.callee.name) && !RENDER_SYNCHRONOUS_HOOK_NAMES.has(callParent.callee.name) && callParent.arguments?.[0] === functionNode;
 		};
 		const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && REACT_HANDLER_PROP_PATTERN.test(node.name.name);
 		const isEventHandlerNamedProperty = (node) => isNodeOfType(node, "Property") && (isNodeOfType(node.key, "Identifier") && typeof node.key.name === "string" && REACT_HANDLER_PROP_PATTERN.test(node.key.name) || isNodeOfType(node.key, "Literal") && typeof node.key.value === "string" && REACT_HANDLER_PROP_PATTERN.test(node.key.value));
@@ -41368,11 +41126,11 @@ const tanstackStartNoNavigateInRender = defineRule({
 			if (isNodeOfType(parent, "ReturnStatement")) {
 				const outerFunction = findEnclosingFunction(parent);
 				const hookName = outerFunction ? getFunctionBindingName(outerFunction) : null;
-				return Boolean(hookName && HOOK_NAME_PATTERN$1.test(hookName));
+				return Boolean(hookName && HOOK_NAME_PATTERN.test(hookName));
 			}
 			if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === functionNode) {
 				const hookName = getFunctionBindingName(parent);
-				return Boolean(hookName && HOOK_NAME_PATTERN$1.test(hookName));
+				return Boolean(hookName && HOOK_NAME_PATTERN.test(hookName));
 			}
 			return false;
 		};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.6.2-dev.173cc0a",
+  "version": "0.6.2-dev.59e8178",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",