oxlint-plugin-react-doctor 0.7.4-dev.2b5a18e → 0.7.4-dev.4a5d9bb

package/dist/index.js

@@ -9968,18 +9968,13 @@ const unwrapExpression$3 = (node) => {
 	return current;
 };
 /**
-* Get the hook name from a direct, wrapped, namespaced, or immutable
-* React import alias call.
+* Get the hook name from a call expression's callee, regardless of
+* whether the hook is called as `useFoo()` (Identifier) or
+* `React.useFoo()` (MemberExpression).
 */
-const getHookName = (callee, scopes) => {
-	const strippedCallee = unwrapExpression$3(callee);
-	if (isNodeOfType(strippedCallee, "Identifier")) {
-		const resolvedSymbol = scopes ? resolveConstIdentifierAlias(strippedCallee, scopes) : null;
-		const importDeclaration = resolvedSymbol?.declarationNode.parent;
-		if (resolvedSymbol?.kind === "import" && importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react") return getImportedName(resolvedSymbol.declarationNode) ?? strippedCallee.name;
-		return strippedCallee.name;
-	}
-	if (isNodeOfType(strippedCallee, "MemberExpression") && !strippedCallee.computed && isNodeOfType(strippedCallee.property, "Identifier")) return strippedCallee.property.name;
+const getHookName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
 	return null;
 };
 const FUNCTION_SCOPE_KINDS = new Set([
@@ -10164,7 +10159,7 @@ const STABLE_IDENTITY_WRAPPER_HOOK_NAMES = new Set([
 *   - primitive-literal local consts (the value never changes
 *     between renders unless the literal does)
 */
-const symbolHasStableHookOrigin = (symbol, scopes) => {
+const symbolHasStableHookOrigin = (symbol) => {
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
 	let declarator = symbol.declarationNode;
 	while (declarator && declarator.type !== "VariableDeclarator") declarator = declarator.parent ?? null;
@@ -10177,7 +10172,7 @@ const symbolHasStableHookOrigin = (symbol, scopes) => {
 		if (isNodeOfType(initializer, "TemplateLiteral") && getStaticTemplateLiteralValue(initializer) !== null) return true;
 	}
 	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const initializerHookName = getHookName(initializer.callee, scopes);
+	const initializerHookName = getHookName(initializer.callee);
 	if (!initializerHookName) return false;
 	if (initializerHookName === "useRef") return true;
 	if (initializerHookName === "useEffectEvent") return true;
@@ -10212,7 +10207,7 @@ const symbolHasStableMemoizedOrigin = (symbol, scopes, visitedSymbolIds) => {
 	if (!declarator.init) return false;
 	const initializer = unwrapExpression$3(declarator.init);
 	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const initializerHookName = getHookName(initializer.callee, scopes);
+	const initializerHookName = getHookName(initializer.callee);
 	if (!initializerHookName || !MEMOIZING_HOOK_NAMES.has(initializerHookName)) return false;
 	const depsArgument = initializer.arguments[1];
 	if (!depsArgument || !isAstNode(depsArgument)) return false;
@@ -10242,7 +10237,7 @@ const getObjectPropertyValue = (objectExpression, propertyName) => {
 	}
 	return null;
 };
-const isStableRefContainerCapture = (symbol, depKey, scopes) => {
+const isStableRefContainerCapture = (symbol, depKey) => {
 	if (symbol.kind !== "const") return false;
 	if (!depKey.startsWith(`${symbol.name}.`)) return false;
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
@@ -10256,7 +10251,7 @@ const isStableRefContainerCapture = (symbol, depKey, scopes) => {
 		if (!propertyValue) return false;
 		currentValue = propertyValue;
 	}
-	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee, scopes) === "useRef";
+	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee) === "useRef";
 };
 const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	if (visitedSymbolIds.has(symbol.id)) return true;
@@ -10274,13 +10269,7 @@ const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	}
 	return true;
 };
-const symbolHasStableImportedAlias = (symbol, scopes) => {
-	if (symbol.kind !== "const") return false;
-	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
-	const resolvedSymbol = resolveConstIdentifierAlias(symbol.bindingIdentifier, scopes);
-	return resolvedSymbol !== null && resolvedSymbol !== symbol && resolvedSymbol.kind === "import";
-};
-const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol, scopes) || symbolHasStableImportedAlias(symbol, scopes) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
+const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
 //#endregion
 //#region src/plugin/utils/symbol-has-react-use-effect-event-origin.ts
 const symbolHasReactUseEffectEventOrigin = (symbol, scopes) => {
@@ -10468,18 +10457,10 @@ const collectCaptureDepKeys = (callback, scopes) => {
 		}
 		const depKey = computeDepKey(reference);
 		if (!depKey) continue;
-		if (isStableRefContainerCapture(symbol, depKey, scopes)) {
+		if (isStableRefContainerCapture(symbol, depKey)) {
 			stableCapturedNames.add(depKey);
 			continue;
 		}
-		if (depKey === symbol.name) {
-			const identitySourceKeys = resolveReactiveIdentitySourceKeys(symbol, scopes);
-			if (identitySourceKeys) {
-				if (identitySourceKeys.size === 0) stableCapturedNames.add(depKey);
-				for (const identitySourceKey of identitySourceKeys) keys.add(identitySourceKey);
-				continue;
-			}
-		}
 		keys.add(depKey);
 	}
 	return {
@@ -10508,60 +10489,12 @@ const hasComputedMemberExpression = (node) => {
 	if (stripped.computed) return true;
 	return hasComputedMemberExpression(stripped.object);
 };
-const mergeIdentitySourceKeys = (expressions, scopes, visitedSymbolIds) => {
-	const identitySourceKeys = /* @__PURE__ */ new Set();
-	for (const expression of expressions) {
-		const expressionSourceKeys = resolveIdentitySourceKeysFromExpression(expression, scopes, visitedSymbolIds);
-		if (!expressionSourceKeys) return null;
-		for (const expressionSourceKey of expressionSourceKeys) identitySourceKeys.add(expressionSourceKey);
-	}
-	return identitySourceKeys;
-};
-const resolveIdentitySourceKeysFromExpression = (expression, scopes, visitedSymbolIds) => {
-	const stripped = unwrapExpression$3(expression);
-	if (isNodeOfType(stripped, "Literal") && (stripped.value === null || typeof stripped.value === "string" || typeof stripped.value === "number" || typeof stripped.value === "boolean") || isNodeOfType(stripped, "TemplateLiteral") && getStaticTemplateLiteralValue(stripped) !== null) return /* @__PURE__ */ new Set();
-	if (isNodeOfType(stripped, "Identifier")) {
-		const sourceSymbol = scopes.symbolFor(stripped);
-		if (!sourceSymbol) return null;
-		if (isOutsideAllFunctions(sourceSymbol) || symbolHasStableValue(sourceSymbol, scopes)) return /* @__PURE__ */ new Set();
-		if (sourceSymbol.kind === "const" && sourceSymbol.initializer && isNodeOfType(sourceSymbol.declarationNode, "VariableDeclarator") && sourceSymbol.declarationNode.id === sourceSymbol.bindingIdentifier && sourceSymbol.references.every((reference) => reference.flag === "read")) {
-			if (visitedSymbolIds.has(sourceSymbol.id)) return null;
-			visitedSymbolIds.add(sourceSymbol.id);
-			const sourceKeys = resolveIdentitySourceKeysFromExpression(sourceSymbol.initializer, scopes, visitedSymbolIds);
-			visitedSymbolIds.delete(sourceSymbol.id);
-			if (sourceKeys) return sourceKeys;
-		}
-		return new Set([sourceSymbol.name]);
-	}
-	if (isNodeOfType(stripped, "MemberExpression")) {
-		if (hasComputedMemberExpression(stripped)) return null;
-		const sourceKey = stringifyMemberChain(stripped);
-		const rootIdentifier = getMemberRootIdentifier(stripped);
-		const rootSymbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
-		if (!sourceKey || !rootSymbol) return null;
-		if (isOutsideAllFunctions(rootSymbol)) return /* @__PURE__ */ new Set();
-		if (isStableRefContainerCapture(rootSymbol, sourceKey, scopes)) return /* @__PURE__ */ new Set();
-		if (symbolHasStableValue(rootSymbol, scopes)) return /* @__PURE__ */ new Set();
-		return new Set([sourceKey]);
-	}
-	if (isNodeOfType(stripped, "LogicalExpression")) return mergeIdentitySourceKeys([stripped.left, stripped.right], scopes, visitedSymbolIds);
-	if (isNodeOfType(stripped, "ConditionalExpression")) return mergeIdentitySourceKeys([
-		stripped.test,
-		stripped.consequent,
-		stripped.alternate
-	], scopes, visitedSymbolIds);
-	return null;
-};
-const resolveReactiveIdentitySourceKeys = (symbol, scopes) => {
-	if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || symbol.references.some((reference) => reference.flag !== "read")) return null;
-	return resolveIdentitySourceKeysFromExpression(symbol.initializer, scopes, new Set([symbol.id]));
-};
 const isUseCallbackResultDep = (node, scopes) => {
 	const rootSymbol = getRootSymbol(node, scopes);
 	const initializer = rootSymbol?.initializer ? unwrapExpression$3(rootSymbol.initializer) : null;
-	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && getHookName(initializer.callee, scopes) === "useCallback");
+	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && getHookName(initializer.callee) === "useCallback");
 };
-const isExtraReactiveDepAllowed = (node, scopes) => {
+const isExtraEffectDepAllowed = (node, scopes) => {
 	const rootIdentifier = getMemberRootIdentifier(node);
 	if (!rootIdentifier) return false;
 	const symbol = scopes.symbolFor(rootIdentifier);
@@ -10589,78 +10522,12 @@ const isUnstableInitializer = (node) => {
 	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left) || isUnstableInitializer(stripped.right);
 	return isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "ArrayExpression") || isNodeOfType(stripped, "ClassExpression") || isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment") || isNodeOfType(stripped, "AssignmentExpression") || isNodeOfType(stripped, "NewExpression");
 };
-const isPotentiallyFreshComparedValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const candidate = unwrapExpression$3(node);
-	if (isUnstableInitializer(candidate)) return true;
-	if (isNodeOfType(candidate, "ConditionalExpression")) return isPotentiallyFreshComparedValue(candidate.consequent, scopes, visitedSymbolIds) || isPotentiallyFreshComparedValue(candidate.alternate, scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "LogicalExpression")) return isPotentiallyFreshComparedValue(candidate.left, scopes, visitedSymbolIds) || isPotentiallyFreshComparedValue(candidate.right, scopes, visitedSymbolIds);
-	if (!isNodeOfType(candidate, "Identifier")) return false;
-	const symbol = scopes.symbolFor(candidate);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	if (symbol.kind === "let" || symbol.kind === "var") return true;
-	if (symbol.kind !== "const" || !symbol.initializer) return false;
-	visitedSymbolIds.add(symbol.id);
-	return isPotentiallyFreshComparedValue(symbol.initializer, scopes, visitedSymbolIds);
-};
-const isExtraDepAllowedForHook = (hookName, node, scopes) => {
-	if (!isExtraReactiveDepAllowed(node, scopes)) return false;
-	if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName)) return true;
-	if (hookName !== "useMemo") return false;
-	const rootSymbol = getRootSymbol(node, scopes);
-	return Boolean(rootSymbol && !symbolHasStableValue(rootSymbol, scopes) && !isUnstableInitializer(rootSymbol.initializer));
-};
 const hasDirectIdentifierDeclarator = (symbol) => isNodeOfType(symbol.declarationNode, "VariableDeclarator") && isNodeOfType(symbol.declarationNode.id, "Identifier") || isNodeOfType(symbol.declarationNode, "ClassDeclaration");
 const isFunctionValueSymbol = (symbol) => getFunctionValueNode(symbol) !== null;
-const isStableSetterLikeSymbol = (symbol, scopes) => {
-	if (!symbolHasStableHookOrigin(symbol, scopes)) return false;
+const isStableSetterLikeSymbol = (symbol) => {
+	if (!symbolHasStableHookOrigin(symbol)) return false;
 	return symbol.name.startsWith("set") || symbol.name.startsWith("dispatch") || symbol.name.startsWith("startTransition");
 };
-const isConvergingFunctionalUpdater = (node, scopes) => {
-	const updater = unwrapExpression$3(node);
-	if (!isNodeOfType(updater, "ArrowFunctionExpression") && !isNodeOfType(updater, "FunctionExpression")) return false;
-	const previousValueParameter = updater.params?.[0];
-	if (!previousValueParameter || !isNodeOfType(previousValueParameter, "Identifier")) return false;
-	let returnedExpression = updater.body;
-	if (isNodeOfType(updater.body, "BlockStatement")) {
-		returnedExpression = null;
-		for (const statement of updater.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument) {
-			returnedExpression = statement.argument;
-			break;
-		}
-	}
-	const conditional = returnedExpression ? unwrapExpression$3(returnedExpression) : null;
-	if (!conditional || !isNodeOfType(conditional, "ConditionalExpression")) return false;
-	const test = unwrapExpression$3(conditional.test);
-	if (!isNodeOfType(test, "BinaryExpression") || ![
-		"===",
-		"!==",
-		"==",
-		"!="
-	].includes(test.operator)) return false;
-	const isPreviousValue = (expression) => {
-		const candidate = unwrapExpression$3(expression);
-		return isNodeOfType(candidate, "Identifier") && candidate.name === previousValueParameter.name;
-	};
-	let comparedValue = null;
-	if (isPreviousValue(test.left)) comparedValue = test.right;
-	else if (isPreviousValue(test.right)) comparedValue = test.left;
-	if (!comparedValue) return false;
-	if (isPotentiallyFreshComparedValue(comparedValue, scopes)) return false;
-	const isSameComparedValue = (expression) => {
-		const candidate = unwrapExpression$3(expression);
-		const compared = unwrapExpression$3(comparedValue);
-		if (isNodeOfType(candidate, "Identifier") && isNodeOfType(compared, "Identifier")) return candidate.name === compared.name;
-		if (isNodeOfType(candidate, "Literal") && isNodeOfType(compared, "Literal")) return candidate.value === compared.value;
-		return false;
-	};
-	return test.operator === "===" || test.operator === "==" ? isPreviousValue(conditional.consequent) && isSameComparedValue(conditional.alternate) : isSameComparedValue(conditional.consequent) && isPreviousValue(conditional.alternate);
-};
-const isGuardedStableSetterCall = (identifier, symbol, scopes) => {
-	const parent = identifier.parent;
-	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier || !isStableSetterLikeSymbol(symbol, scopes)) return false;
-	const writtenValue = parent.arguments?.[0];
-	return Boolean(writtenValue && isConvergingFunctionalUpdater(writtenValue, scopes));
-};
 const findStableSetterReference = (node, scopes) => {
 	let setterName = null;
 	const visit = (current) => {
@@ -10668,7 +10535,7 @@ const findStableSetterReference = (node, scopes) => {
 		if (current !== node && (isNodeOfType(current, "FunctionDeclaration") || isNodeOfType(current, "FunctionExpression") || isNodeOfType(current, "ArrowFunctionExpression"))) return;
 		if (isNodeOfType(current, "Identifier")) {
 			const symbol = scopes.referenceFor(current)?.resolvedSymbol;
-			if (symbol && isStableSetterLikeSymbol(symbol, scopes) && !isGuardedStableSetterCall(current, symbol, scopes)) {
+			if (symbol && isStableSetterLikeSymbol(symbol)) {
 				setterName = symbol.name;
 				return;
 			}
@@ -10784,11 +10651,11 @@ const hasRefCurrentAssignmentInComponent = (refSymbol) => {
 	}
 	return false;
 };
-const isSeededDataRefSymbol = (refSymbol, scopes) => {
+const isSeededDataRefSymbol = (refSymbol) => {
 	if (!refSymbol) return false;
 	const initializer = refSymbol.initializer ? unwrapExpression$3(refSymbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	if (getHookName(initializer.callee, scopes) !== "useRef") return false;
+	if (getHookName(initializer.callee) !== "useRef") return false;
 	const firstArgument = initializer.arguments[0];
 	if (!firstArgument || !isAstNode(firstArgument)) return false;
 	const strippedArgument = unwrapExpression$3(firstArgument);
@@ -10828,9 +10695,7 @@ const isOuterFunctionScopeDep = (node, callback, scopes) => {
 	const componentOrHookScope = componentOrHookFunction ? scopes.ownScopeFor(componentOrHookFunction) : null;
 	return Boolean(componentOrHookScope && !isDescendantScope(symbol.scope, componentOrHookScope));
 };
-const hasMemberCallForRoot = (node, rootName, scopes) => {
-	const rootSymbol = closureCaptures(node, scopes).find((reference) => reference.resolvedSymbol?.name === rootName)?.resolvedSymbol ?? null;
-	if (!rootSymbol) return false;
+const hasMemberCallForRoot = (node, rootName) => {
 	let didFindMemberCall = false;
 	const visit = (current) => {
 		if (didFindMemberCall) return;
@@ -10846,7 +10711,7 @@ const hasMemberCallForRoot = (node, rootName, scopes) => {
 					}
 					chainObject = unwrapExpression$3(chainObject.object);
 				}
-				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName && scopes.symbolFor(chainObject) === rootSymbol) {
+				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName) {
 					didFindMemberCall = true;
 					return;
 				}
@@ -10864,11 +10729,9 @@ const hasMemberCallForRoot = (node, rootName, scopes) => {
 	visit(node);
 	return didFindMemberCall;
 };
-const addAggregatePropsDependency = (captureKeys, declaredKeys, callback, scopes) => {
-	const propsCaptureKeys = [...captureKeys].filter((captureKey) => captureKey.startsWith("props."));
-	if (propsCaptureKeys.length < 2 || declaredKeys.has("props")) return;
-	if (propsCaptureKeys.every((captureKey) => [...declaredKeys].some((declaredKey) => isMatchingDepOrPrefix(declaredKey, captureKey)))) return;
-	if (hasMemberCallForRoot(callback, "props", scopes)) captureKeys.add("props");
+const addAggregatePropsDependency = (captureKeys, declaredKeys, callback) => {
+	if ([...captureKeys].filter((captureKey) => captureKey.startsWith("props.")).length < 2 || declaredKeys.has("props")) return;
+	if (hasMemberCallForRoot(callback, "props")) captureKeys.add("props");
 };
 const exhaustiveDeps = defineRule({
 	id: "exhaustive-deps",
@@ -10923,7 +10786,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 		};
 		const isAutoDependenciesHook = (hookName) => settings.experimental_autoDependenciesHooks.includes(hookName);
 		return { CallExpression(node) {
-			const hookName = getHookName(node.callee, context.scopes);
+			const hookName = getHookName(node.callee);
 			if (!hookName || !isHookOfInterest(hookName, node.callee)) return;
 			const callbackArgumentIndex = getCallbackArgumentIndex(hookName);
 			const depsArgumentIndex = getDepsArgumentIndex(hookName);
@@ -10980,7 +10843,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (outerAssignments.length > 0) return;
 				const refCurrentInCleanup = 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) && !isSeededDataRefSymbol(refCurrentInCleanup.refSymbol, context.scopes)) context.report({
+				if (refCurrentInCleanup && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) && !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol) && !isSeededDataRefSymbol(refCurrentInCleanup.refSymbol)) context.report({
 					node: callbackToAnalyze,
 					message: buildRefCleanupMessage(refCurrentInCleanup.refCurrentName)
 				});
@@ -11079,7 +10942,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				const fullChain = stringifyMemberChain(stripped);
 				if (fullChain && fullChain.endsWith(".current") && isNodeOfType(stripped, "MemberExpression") && isNodeOfType(stripped.object, "Identifier")) {
 					const refSymbol = context.scopes.symbolFor(stripped.object);
-					if (refSymbol && symbolHasStableHookOrigin(refSymbol, context.scopes)) {
+					if (refSymbol && symbolHasStableHookOrigin(refSymbol)) {
 						if (!didReportRefCurrentDep) {
 							context.report({
 								node: elementNode,
@@ -11117,7 +10980,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				declaredKeys.add(key);
 				declaredKeyToReportNode.set(key, elementNode);
 			}
-			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument, context.scopes);
+			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument);
 			const missingCaptureKeys = [];
 			for (const captureKey of captureKeys) {
 				let isCoveredByDeclared = false;
@@ -11203,7 +11066,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (stableCapturedNames.has(rootName) || stableCapturedNames.has(declaredKey)) continue;
 				if (outerFunctionCapturedNames.has(rootName)) continue;
 				const reportNode = declaredKeyToReportNode.get(declaredKey) ?? depsArgument;
-				if (isExtraDepAllowedForHook(hookName, reportNode, context.scopes)) continue;
+				if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) && isExtraEffectDepAllowed(reportNode, context.scopes)) continue;
 				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;
@@ -22429,26 +22292,6 @@ const isReactNamedImportReference = (ref, importedName) => Boolean(ref?.resolved
 	const importDeclaration = declarationNode.parent;
 	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
 }));
-const isReactNamespaceImportReference = (ref) => Boolean(ref?.resolved?.defs.some((def) => {
-	if (def.type !== "ImportBinding") return false;
-	const declarationNode = def.node;
-	if (!isNodeOfType(declarationNode, "ImportNamespaceSpecifier") && !isNodeOfType(declarationNode, "ImportDefaultSpecifier")) return false;
-	const importDeclaration = declarationNode.parent;
-	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
-}));
-const isGenuineReactHookDeclarator = (analysis, declarator, hookName) => {
-	if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) return false;
-	const callee = stripParenExpression(declarator.init.callee);
-	if (isNodeOfType(callee, "Identifier")) {
-		const reference = getRef(analysis, callee);
-		if (!reference?.resolved) return callee.name === hookName;
-		return isReactNamedImportReference(reference, hookName);
-	}
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== hookName) return false;
-	const namespaceReference = getRef(analysis, callee.object);
-	if (!namespaceReference?.resolved) return callee.object.name === "React";
-	return isReactNamespaceImportReference(namespaceReference);
-};
 const isHookCallee$1 = (analysis, node, hookName) => {
 	if (!node) return false;
 	if (isNodeOfType(node, "Identifier")) {
@@ -23503,20 +23346,6 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 	}
 	return evidence;
 };
-const collectRenderValueEvidence = (analysis, expression, componentFunction, currentFilename) => {
-	const evidence = collectValueEvidence(analysis, expression, {
-		functionNode: componentFunction,
-		invocation: null,
-		isDeferred: false,
-		introducedBindings: /* @__PURE__ */ new Set(),
-		substitutions: /* @__PURE__ */ new Map(),
-		currentFilename
-	}, 1);
-	return {
-		sourceReferences: evidence.sourceReferences,
-		isExclusivelyRenderKnown: evidence.sourceReferences.size > 0 && !evidence.hasUnknownSource && !evidence.hasDeferredIntroducedValue && !evidence.readsExternalValue
-	};
-};
 const findStateSetterReference = (analysis, callExpression) => {
 	if (!isNodeOfType(callExpression, "CallExpression")) return null;
 	const callee = stripParenExpression(callExpression.callee);
@@ -26569,6 +26398,57 @@ const noDefaultProps = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-derived-state.ts
+const getStateName$1 = (stateDeclarator) => {
+	if (!isNodeOfType(stateDeclarator, "VariableDeclarator")) return "<state>";
+	if (!isNodeOfType(stateDeclarator.id, "ArrayPattern")) return "<state>";
+	const stateBinding = stateDeclarator.id.elements?.[0];
+	if (stateBinding && isNodeOfType(stateBinding, "Identifier")) return stateBinding.name;
+	const setterBinding = stateDeclarator.id.elements?.[1];
+	if (!setterBinding || !isNodeOfType(setterBinding, "Identifier")) return "<state>";
+	if (!setterBinding.name.startsWith("set") || setterBinding.name.length <= 3) return setterBinding.name;
+	return setterBinding.name[3].toLowerCase() + setterBinding.name.slice(4);
+};
+const noDerivedState = defineRule({
+	id: "no-derived-state",
+	title: "Derived value copied into state",
+	severity: "warn",
+	tags: ["test-noise"],
+	recommendation: "Work out the value while rendering (or with useMemo if it's expensive) instead of copying it into useState through a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state",
+	create: (context) => ({ CallExpression(node) {
+		if (!isUseEffect(node)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
+			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
+			const stateName = getStateName$1(fact.stateDeclarator);
+			context.report({
+				node: fact.callExpression,
+				message: `Storing "${stateName}" in state when you can derive it from other values costs an extra render.`
+			});
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/rules/state-and-effects/no-derived-state-effect.ts
+const noDerivedStateEffect = defineRule({
+	id: "no-derived-state-effect",
+	title: "Derived state stored in an effect",
+	severity: "warn",
+	tags: ["test-noise"],
+	recommendation: "Work out derived values while rendering: `const x = fn(dep)`. To reset a component's state when a prop changes, give it a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
+	create: (context) => ({ CallExpression(node) {
+		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
+		context.report({
+			node,
+			message: "You pay an extra render for state you can derive from other values."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/utils/is-component-function.ts
 const isFunctionAssignedToComponent = (functionNode) => {
 	let cursor = functionNode.parent ?? null;
@@ -26702,236 +26582,6 @@ const createComponentPropStackTracker = (callbacks) => {
 	};
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/collect-render-state-write-facts.ts
-const findReferenceDeclarator = (reference) => {
-	for (const definition of reference.resolved?.defs ?? []) {
-		const definitionNode = definition.node;
-		if (isNodeOfType(definitionNode, "VariableDeclarator")) return definitionNode;
-	}
-	return null;
-};
-const resolveSimpleRenderSource = (analysis, expression, visitedBindings = /* @__PURE__ */ new Set()) => {
-	const node = stripParenExpression(expression);
-	if (!isNodeOfType(node, "Identifier")) return null;
-	const reference = getRef(analysis, node);
-	if (!reference?.resolved || visitedBindings.has(reference.resolved)) return null;
-	if (isProp(analysis, reference)) {
-		if (isWholePropsObjectReference(analysis, reference)) return null;
-		return { bindingIdentity: reference.resolved };
-	}
-	if (isState(analysis, reference)) {
-		const stateDeclarator = getUseStateDecl(analysis, reference);
-		if (!stateDeclarator || !isGenuineReactHookDeclarator(analysis, stateDeclarator, "useState") || isExternallyDrivenState(analysis, reference)) return null;
-		return { bindingIdentity: reference.resolved };
-	}
-	if (reference.resolved.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init)) return null;
-	const declarator = findReferenceDeclarator(reference);
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !declarator.init) return null;
-	const nextVisitedBindings = new Set(visitedBindings);
-	nextVisitedBindings.add(reference.resolved);
-	return resolveSimpleRenderSource(analysis, declarator.init, nextVisitedBindings);
-};
-const doesEvidenceMatchSource = (evidence, source) => evidence.isExclusivelyRenderKnown && evidence.sourceReferences.size > 0 && [...evidence.sourceReferences].every((sourceReference) => sourceReference.resolved === source.bindingIdentity);
-const getDirectBranchStatements = (branch) => {
-	if (isNodeOfType(branch, "BlockStatement")) return branch.body ?? [];
-	return [branch];
-};
-const getDirectCallExpression = (statement) => {
-	if (!isNodeOfType(statement, "ExpressionStatement")) return null;
-	const expression = stripParenExpression(statement.expression);
-	return isNodeOfType(expression, "CallExpression") ? expression : null;
-};
-const getDirectAssignmentExpression = (statement) => {
-	if (!isNodeOfType(statement, "ExpressionStatement")) return null;
-	const expression = stripParenExpression(statement.expression);
-	return isNodeOfType(expression, "AssignmentExpression") && expression.operator === "=" ? expression : null;
-};
-const findDirectStateSetterReference = (analysis, callExpression) => {
-	if (!isNodeOfType(callExpression, "CallExpression")) return null;
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "Identifier")) return null;
-	const reference = getRef(analysis, callee);
-	return reference && isStateSetter(analysis, reference) ? reference : null;
-};
-const getStaticRefCurrentReference = (analysis, expression) => {
-	const node = stripParenExpression(expression);
-	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.object, "Identifier") || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return null;
-	const reference = getRef(analysis, node.object);
-	if (!reference) return null;
-	const declarator = findReferenceDeclarator(reference);
-	return declarator && isGenuineReactHookDeclarator(analysis, declarator, "useRef") ? reference : null;
-};
-const getStateTracker = (analysis, expression) => {
-	const node = stripParenExpression(expression);
-	if (!isNodeOfType(node, "Identifier")) return null;
-	const reference = getRef(analysis, node);
-	if (!reference || !isState(analysis, reference)) return null;
-	const declarator = getUseStateDecl(analysis, reference);
-	if (!declarator || !isGenuineReactHookDeclarator(analysis, declarator, "useState")) return null;
-	return {
-		kind: "state",
-		declarator
-	};
-};
-const getRefTracker = (analysis, expression) => {
-	const reference = getStaticRefCurrentReference(analysis, expression);
-	return reference ? {
-		kind: "ref",
-		reference
-	} : null;
-};
-const getTrackerInitializer = (tracker) => {
-	const declarator = tracker.kind === "state" ? tracker.declarator : findReferenceDeclarator(tracker.reference);
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) return null;
-	const initializer = declarator.init.arguments?.[0];
-	return initializer ? initializer : null;
-};
-const isTrackerSynchronized = (analysis, guard) => {
-	for (const statement of guard.statements) {
-		if (guard.tracker.kind === "state") {
-			const callExpression = getDirectCallExpression(statement);
-			if (!callExpression || !isNodeOfType(callExpression, "CallExpression")) continue;
-			const setterReference = findDirectStateSetterReference(analysis, callExpression);
-			if (!setterReference || getUseStateDecl(analysis, setterReference) !== guard.tracker.declarator || (callExpression.arguments ?? []).length !== 1) continue;
-			const writtenValue = callExpression.arguments?.[0];
-			if (writtenValue && resolveSimpleRenderSource(analysis, writtenValue)?.bindingIdentity === guard.source.bindingIdentity) return true;
-			continue;
-		}
-		const assignmentExpression = getDirectAssignmentExpression(statement);
-		if (!assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression")) continue;
-		if (getStaticRefCurrentReference(analysis, assignmentExpression.left)?.resolved !== guard.tracker.reference.resolved) continue;
-		if (resolveSimpleRenderSource(analysis, assignmentExpression.right)?.bindingIdentity === guard.source.bindingIdentity) return true;
-	}
-	return false;
-};
-const parseRenderTrackerGuard = (analysis, statement) => {
-	if (!isNodeOfType(statement, "IfStatement") || statement.alternate || !isNodeOfType(statement.test, "BinaryExpression") || statement.test.operator !== "!==" || !isNodeOfType(statement.consequent, "BlockStatement")) return null;
-	const left = statement.test.left;
-	const right = statement.test.right;
-	const candidates = [{
-		sourceExpression: left,
-		trackerExpression: right
-	}, {
-		sourceExpression: right,
-		trackerExpression: left
-	}];
-	for (const candidate of candidates) {
-		const source = resolveSimpleRenderSource(analysis, candidate.sourceExpression);
-		if (!source) continue;
-		const tracker = getStateTracker(analysis, candidate.trackerExpression) ?? getRefTracker(analysis, candidate.trackerExpression);
-		if (!tracker) continue;
-		const trackerInitializer = getTrackerInitializer(tracker);
-		if (!trackerInitializer || resolveSimpleRenderSource(analysis, trackerInitializer)?.bindingIdentity !== source.bindingIdentity) continue;
-		const guard = {
-			source,
-			tracker,
-			statements: getDirectBranchStatements(statement.consequent)
-		};
-		return isTrackerSynchronized(analysis, guard) ? guard : null;
-	}
-	return null;
-};
-const isExclusiveDestinationSetterReference = (setterReference, callExpression) => {
-	if (!setterReference.resolved || !isNodeOfType(callExpression, "CallExpression")) return false;
-	const references = setterReference.resolved.references.filter((reference) => !reference.init);
-	if (references.length !== 1) return false;
-	return references[0].identifier === callExpression.callee;
-};
-const getStateInitializer = (stateDeclarator) => {
-	if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression")) return null;
-	const initializer = stateDeclarator.init.arguments?.[0];
-	return initializer ? initializer : null;
-};
-const collectRenderStateWriteFacts = (analysis, componentBody, currentFilename) => {
-	if (!isNodeOfType(componentBody, "BlockStatement") || !componentBody.parent || !isFunctionLike$1(componentBody.parent)) return [];
-	const componentFunction = componentBody.parent;
-	const facts = [];
-	for (const statement of componentBody.body ?? []) {
-		const guard = parseRenderTrackerGuard(analysis, statement);
-		if (!guard) continue;
-		for (const branchStatement of guard.statements) {
-			const callExpression = getDirectCallExpression(branchStatement);
-			if (!callExpression || !isNodeOfType(callExpression, "CallExpression")) continue;
-			const setterReference = findDirectStateSetterReference(analysis, callExpression);
-			if (!setterReference || (callExpression.arguments ?? []).length !== 1 || !isExclusiveDestinationSetterReference(setterReference, callExpression)) continue;
-			const stateDeclarator = getUseStateDecl(analysis, setterReference);
-			if (!stateDeclarator || !isGenuineReactHookDeclarator(analysis, stateDeclarator, "useState") || guard.tracker.kind === "state" && stateDeclarator === guard.tracker.declarator) continue;
-			const writtenValue = callExpression.arguments?.[0];
-			const initializer = getStateInitializer(stateDeclarator);
-			if (!writtenValue || !initializer || isFunctionLike$1(writtenValue) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, writtenValue, componentFunction, currentFilename), guard.source) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, initializer, componentFunction, currentFilename), guard.source)) continue;
-			facts.push({
-				callExpression,
-				stateDeclarator
-			});
-		}
-	}
-	return facts;
-};
-//#endregion
-//#region src/plugin/rules/state-and-effects/no-derived-state.ts
-const getStateName$1 = (stateDeclarator) => {
-	if (!isNodeOfType(stateDeclarator, "VariableDeclarator")) return "<state>";
-	if (!isNodeOfType(stateDeclarator.id, "ArrayPattern")) return "<state>";
-	const stateBinding = stateDeclarator.id.elements?.[0];
-	if (stateBinding && isNodeOfType(stateBinding, "Identifier")) return stateBinding.name;
-	const setterBinding = stateDeclarator.id.elements?.[1];
-	if (!setterBinding || !isNodeOfType(setterBinding, "Identifier")) return "<state>";
-	if (!setterBinding.name.startsWith("set") || setterBinding.name.length <= 3) return setterBinding.name;
-	return setterBinding.name[3].toLowerCase() + setterBinding.name.slice(4);
-};
-const noDerivedState = defineRule({
-	id: "no-derived-state",
-	title: "Derived value copied into state",
-	severity: "warn",
-	tags: ["test-noise"],
-	recommendation: "Work out the value while rendering (or with useMemo if it's expensive) instead of copying it into state and synchronizing it during render or through an effect. See https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state",
-	create: (context) => {
-		const reportStateWrite = (callExpression, stateDeclarator) => {
-			const stateName = getStateName$1(stateDeclarator);
-			context.report({
-				node: callExpression,
-				message: `Storing "${stateName}" in state when you can derive it from other values costs an extra render.`
-			});
-		};
-		return {
-			...createComponentPropStackTracker({ onComponentEnter: (componentBody) => {
-				if (!componentBody) return;
-				const analysis = getProgramAnalysis(componentBody);
-				if (!analysis) return;
-				for (const fact of collectRenderStateWriteFacts(analysis, componentBody, context.filename)) reportStateWrite(fact.callExpression, fact.stateDeclarator);
-			} }).visitors,
-			CallExpression(node) {
-				if (!isUseEffect(node)) return;
-				const analysis = getProgramAnalysis(node);
-				if (!analysis) return;
-				for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
-					if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
-					reportStateWrite(fact.callExpression, fact.stateDeclarator);
-				}
-			}
-		};
-	}
-});
-//#endregion
-//#region src/plugin/rules/state-and-effects/no-derived-state-effect.ts
-const noDerivedStateEffect = defineRule({
-	id: "no-derived-state-effect",
-	title: "Derived state stored in an effect",
-	severity: "warn",
-	tags: ["test-noise"],
-	recommendation: "Work out derived values while rendering: `const x = fn(dep)`. To reset a component's state when a prop changes, give it a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
-	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
-		context.report({
-			node,
-			message: "You pay an extra render for state you can derive from other values."
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/utils/is-initial-only-prop-name.ts
 const isInitialOnlyPropName = (propName) => {
 	if (propName === "initialValue" || propName === "defaultValue" || propName === "seedValue") return true;
@@ -30295,26 +29945,28 @@ const noGiantComponent = defineRule({
 			const lineCount = bodyNode.loc.end.line - bodyNode.loc.start.line + 1;
 			return lineCount > 300 ? lineCount : null;
 		};
-		const reportOversizedComponent = (nameNode, componentName) => {
+		const reportOversizedComponent = (nameNode, componentName, lineCount) => {
 			context.report({
 				node: nameNode,
-				message: `Component "${componentName}" is over 300 lines long, which is hard to read & change. Split it into a few smaller components.`
+				message: `Component "${componentName}" is ${lineCount} lines long, which is hard to read & change. Split it into a few smaller components.`
 			});
 		};
 		return {
 			FunctionDeclaration(node) {
 				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
-				if (getOversizedComponentLineCount(node) === null) return;
+				const lineCount = getOversizedComponentLineCount(node);
+				if (lineCount === null) return;
 				if (!functionContainsReactRenderOutput(node, context.scopes)) return;
-				reportOversizedComponent(node.id, node.id.name);
+				reportOversizedComponent(node.id, node.id.name, lineCount);
 			},
 			VariableDeclarator(node) {
 				if (!isNodeOfType(node.id, "Identifier") || !isUppercaseName(node.id.name)) return;
 				const functionNode = unwrapReactHocFunction(node.init);
 				if (!functionNode) return;
-				if (getOversizedComponentLineCount(functionNode) === null) return;
+				const lineCount = getOversizedComponentLineCount(functionNode);
+				if (lineCount === null) return;
 				if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
-				reportOversizedComponent(node.id, node.id.name);
+				reportOversizedComponent(node.id, node.id.name, lineCount);
 			}
 		};
 	}
@@ -30951,131 +30603,6 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-impure-state-updater.ts
-const TIMER_FUNCTION_NAMES = new Set([
-	"cancelAnimationFrame",
-	"clearInterval",
-	"clearTimeout",
-	"queueMicrotask",
-	"requestAnimationFrame",
-	"setInterval",
-	"setTimeout"
-]);
-const STORAGE_MUTATION_METHOD_NAMES = new Set([
-	"clear",
-	"removeItem",
-	"setItem"
-]);
-const STORAGE_RECEIVER_NAMES = new Set(["localStorage", "sessionStorage"]);
-const EXTERNAL_READ_METHOD_NAMES = new Set(["getBoundingClientRect", "getClientRects"]);
-const NOTIFICATION_RECEIVER_NAMES = new Set([
-	"message",
-	"notification",
-	"toast"
-]);
-const NOTIFICATION_METHOD_NAMES = new Set([
-	"error",
-	"info",
-	"loading",
-	"open",
-	"show",
-	"success",
-	"warning"
-]);
-const getMemberCall = (node) => {
-	if (!isNodeOfType(node, "CallExpression")) return null;
-	if (!isNodeOfType(node.callee, "MemberExpression") || node.callee.computed) return null;
-	if (!isNodeOfType(node.callee.property, "Identifier")) return null;
-	return {
-		methodName: node.callee.property.name,
-		receiver: stripParenExpression(node.callee.object)
-	};
-};
-const isNotificationReceiver = (receiver, scopes) => {
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (!NOTIFICATION_RECEIVER_NAMES.has(receiver.name)) return false;
-	const symbol = scopes.symbolFor(receiver);
-	if (symbol?.kind === "import") return true;
-	if (!isNodeOfType(symbol?.initializer, "CallExpression")) return false;
-	const callee = symbol.initializer.callee;
-	return isNodeOfType(callee, "Identifier") && /^use(?:Message|Notification|Toast)$/.test(callee.name);
-};
-const getKnownImpureCall = (callExpression, scopes) => {
-	if (isNodeOfType(callExpression.callee, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.name) && scopes.isGlobalReference(callExpression.callee)) return `${callExpression.callee.name}()`;
-	const memberCall = getMemberCall(callExpression);
-	if (!memberCall) return null;
-	const { methodName, receiver } = memberCall;
-	if (STORAGE_MUTATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && STORAGE_RECEIVER_NAMES.has(receiver.name) && scopes.isGlobalReference(receiver)) return `${receiver.name}.${methodName}()`;
-	if (EXTERNAL_READ_METHOD_NAMES.has(methodName)) return `.${methodName}()`;
-	if (NOTIFICATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && isNotificationReceiver(receiver, scopes)) return `${receiver.name}.${methodName}()`;
-	return null;
-};
-const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) => {
-	let rootIdentifier = null;
-	if (isNodeOfType(assignmentTarget, "Identifier")) rootIdentifier = assignmentTarget;
-	else if (isNodeOfType(assignmentTarget, "MemberExpression") && isNodeOfType(assignmentTarget.object, "Identifier")) rootIdentifier = assignmentTarget.object;
-	if (!rootIdentifier) return null;
-	const updaterScope = scopes.ownScopeFor(updater);
-	if (!updaterScope) return null;
-	const symbol = scopes.symbolFor(rootIdentifier);
-	if (!symbol) return `the external value "${rootIdentifier.name}"`;
-	if (symbol.kind === "parameter" && symbol.scope === updaterScope) return `the updater argument "${rootIdentifier.name}"`;
-	return isDescendantScope(symbol.scope, updaterScope) ? null : `the captured value "${rootIdentifier.name}"`;
-};
-const findImpureUpdaterOperation = (updater, scopes) => {
-	const analysis = getProgramAnalysis(updater);
-	let operation = null;
-	walkAst(updater, (child) => {
-		if (operation) return false;
-		if (child !== updater && isFunctionLike$1(child) && !executesDuringRender(child, scopes)) return false;
-		if (isNodeOfType(child, "CallExpression")) {
-			if (isNodeOfType(child.callee, "Identifier") && analysis) {
-				const calleeReference = getRef(analysis, child.callee);
-				if (calleeReference && isStateSetterCall(analysis, calleeReference)) {
-					operation = `the nested state update "${child.callee.name}()"`;
-					return false;
-				}
-			}
-			const impureCall = getKnownImpureCall(child, scopes);
-			if (impureCall) {
-				operation = impureCall;
-				return false;
-			}
-		}
-		if (isNodeOfType(child, "AssignmentExpression")) {
-			operation = getExternalAssignmentDescription(child.left, updater, scopes);
-			if (operation) return false;
-		}
-		if (isNodeOfType(child, "UpdateExpression")) {
-			operation = getExternalAssignmentDescription(child.argument, updater, scopes);
-			if (operation) return false;
-		}
-	});
-	return operation;
-};
-const noImpureStateUpdater = defineRule({
-	id: "no-impure-state-updater",
-	title: "State updater has side effects",
-	severity: "error",
-	recommendation: "Keep state updater callbacks pure and return only the next state. Move notifications, storage, timers, ref writes, and other external work into the event or effect that queues the update.",
-	create: (context) => ({ CallExpression(node) {
-		const updater = node.arguments?.[0];
-		if (!updater || !isFunctionLike$1(updater)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis || !isNodeOfType(node.callee, "Identifier")) return;
-		const calleeReference = getRef(analysis, node.callee);
-		if (!calleeReference || !isStateSetterCall(analysis, calleeReference)) return;
-		const stateDeclarator = getUseStateDecl(analysis, calleeReference);
-		if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression") || !isReactApiCall(stateDeclarator.init, "useState", context.scopes, { allowGlobalReactNamespace: true })) return;
-		const operation = findImpureUpdaterOperation(updater, context.scopes);
-		if (!operation) return;
-		context.report({
-			node: updater,
-			message: `This state updater performs ${operation}. React may run updater functions more than once, so side effects here can repeat or observe inconsistent external state.`
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/rules/correctness/no-indeterminate-attribute.ts
 const MESSAGE$21 = "The `indeterminate` HTML attribute does not set a checkbox's visual state. Assign the `HTMLInputElement.indeterminate` DOM property instead.";
 const REACT_USE_REF_OPTIONS = {
@@ -34244,166 +33771,6 @@ const isDirectParentCallbackRef = (analysis, ref) => {
 		return getDownstreamRefs(analysis, initializer).some((initializerRef) => getUpstreamRefs(analysis, initializerRef).some((upstreamRef) => isProp(analysis, upstreamRef)));
 	}));
 };
-const getDeclarationKind = (declarator) => {
-	const declaration = declarator.parent;
-	return declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : null;
-};
-const hasMutableBindingWrite = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
-const getDestructuredPropertyName = (bindingIdentifier) => {
-	const property = bindingIdentifier.parent;
-	if (!property || !isNodeOfType(property, "Property")) return null;
-	if (property.computed) return isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" ? String(property.key.value) : null;
-	return isNodeOfType(property.key, "Identifier") ? property.key.name : null;
-};
-const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @__PURE__ */ new Set()) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const callbackReference = getRef(analysis, unwrappedExpression);
-		const callbackVariable = callbackReference?.resolved;
-		if (!callbackReference || !callbackVariable || visitedVariables.has(callbackVariable)) return null;
-		if (isProp(analysis, callbackReference)) {
-			if (isWholePropsObjectReference(analysis, callbackReference)) return null;
-			const bindingIdentifier = callbackVariable.defs.find((definition) => definition.type === "Parameter")?.name;
-			return (bindingIdentifier && getDestructuredPropertyName(bindingIdentifier)) ?? unwrappedExpression.name;
-		}
-		if (hasMutableBindingWrite(callbackReference)) return null;
-		const definitions = callbackVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
-		if (definitions.length !== 1) return null;
-		const declarator = definitions[0];
-		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || getDeclarationKind(declarator) !== "const" || !declarator.init) return null;
-		visitedVariables.add(callbackVariable);
-		if (isNodeOfType(declarator.id, "ObjectPattern")) {
-			const bindingIdentifier = callbackVariable.defs[0]?.name;
-			const propertyName = bindingIdentifier ? getDestructuredPropertyName(bindingIdentifier) : null;
-			const propsReference = getDownstreamRefs(analysis, declarator.init).find((candidateReference) => isWholePropsObjectReference(analysis, candidateReference));
-			return propertyName && propsReference ? propertyName : null;
-		}
-		if (!isNodeOfType(declarator.id, "Identifier")) return null;
-		return getParentCallbackPropName(analysis, declarator.init, visitedVariables);
-	}
-	if (!isNodeOfType(unwrappedExpression, "MemberExpression")) return null;
-	const callbackName = getStaticMemberPropertyName(unwrappedExpression);
-	if (!callbackName) return null;
-	const receiver = stripParenExpression(unwrappedExpression.object);
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const receiverReference = getRef(analysis, receiver);
-	if (!receiverReference || !isWholePropsObjectReference(analysis, receiverReference)) return null;
-	return callbackName;
-};
-const isNullishRefInitializer = (initializer) => {
-	if (!initializer) return true;
-	const unwrappedInitializer = stripParenExpression(initializer);
-	if (isNodeOfType(unwrappedInitializer, "Literal")) return unwrappedInitializer.value === null;
-	if (!isNodeOfType(unwrappedInitializer, "Identifier")) return false;
-	return unwrappedInitializer.name === "undefined";
-};
-const getDirectComponentBodyStatement = (node, componentBody) => {
-	let current = node;
-	while (current?.parent && current.parent !== componentBody) current = current.parent;
-	return current?.parent === componentBody ? current : null;
-};
-const getVariableForDeclarator = (analysis, declarator) => {
-	for (const scope of analysis.scopeManager.scopes) {
-		const variable = scope.variables.find((candidateVariable) => candidateVariable.defs.some((definition) => definition.node === declarator));
-		if (variable) return variable;
-	}
-	return null;
-};
-const getRefMember = (identifier) => {
-	const receiver = findTransparentExpressionRoot(identifier);
-	const member = receiver.parent;
-	if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== receiver) return null;
-	return member;
-};
-const getRefMemberAssignment = (identifier) => {
-	const member = getRefMember(identifier);
-	if (!member) return null;
-	const memberRoot = findTransparentExpressionRoot(member);
-	const assignment = memberRoot.parent;
-	if (!assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.left !== memberRoot) return null;
-	return assignment;
-};
-const getRefAliasDeclarator = (identifier) => {
-	const initializer = findTransparentExpressionRoot(identifier);
-	const declarator = initializer.parent;
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== initializer || !isNodeOfType(declarator.id, "Identifier") || getDeclarationKind(declarator) !== "const") return null;
-	return declarator;
-};
-const getRefBindingProvenance = (analysis, receiver, isReactUseRefCall) => {
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const receiverReference = getRef(analysis, receiver);
-	if (!receiverReference?.resolved || hasMutableBindingWrite(receiverReference)) return null;
-	const variables = /* @__PURE__ */ new Set();
-	let currentVariable = receiverReference.resolved;
-	let refCall = null;
-	while (currentVariable && !variables.has(currentVariable)) {
-		variables.add(currentVariable);
-		const definitions = currentVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
-		if (definitions.length !== 1) return null;
-		const declarator = definitions[0];
-		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.id, "Identifier") || !declarator.init) return null;
-		if (isNodeOfType(declarator.init, "CallExpression") && isReactUseRefCall(declarator.init)) {
-			refCall = declarator.init;
-			break;
-		}
-		if (getDeclarationKind(declarator) !== "const" || !isNodeOfType(stripParenExpression(declarator.init), "Identifier")) return null;
-		const upstreamReference = getRef(analysis, stripParenExpression(declarator.init));
-		if (!upstreamReference?.resolved || hasMutableBindingWrite(upstreamReference)) return null;
-		currentVariable = upstreamReference.resolved;
-	}
-	if (!refCall) return null;
-	const pendingVariables = [...variables];
-	while (pendingVariables.length > 0) {
-		const variable = pendingVariables.pop();
-		if (!variable) continue;
-		for (const candidateReference of variable.references) {
-			const aliasDeclarator = getRefAliasDeclarator(candidateReference.identifier);
-			if (!aliasDeclarator) continue;
-			const aliasVariable = getVariableForDeclarator(analysis, aliasDeclarator);
-			if (!aliasVariable || variables.has(aliasVariable)) continue;
-			if (aliasVariable.references.some((aliasReference) => aliasReference.isWrite() && !aliasReference.init)) return null;
-			variables.add(aliasVariable);
-			pendingVariables.push(aliasVariable);
-		}
-	}
-	return {
-		refCall,
-		variables
-	};
-};
-const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactUseRefCall) => {
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || getStaticMemberPropertyName(callee) !== "current") return null;
-	const bindingProvenance = getRefBindingProvenance(analysis, stripParenExpression(callee.object), isReactUseRefCall);
-	if (!bindingProvenance) return null;
-	const { refCall, variables } = bindingProvenance;
-	const componentFunction = findEnclosingFunction(effectCall);
-	if (!componentFunction || !isFunctionLike$1(componentFunction) || !isComponentFunction$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
-	if (!getDirectComponentBodyStatement(effectCall, componentFunction.body)) return null;
-	const callbackPropNames = /* @__PURE__ */ new Set();
-	const initializer = refCall.arguments?.[0];
-	const initializerCallbackName = initializer ? getParentCallbackPropName(analysis, initializer) : null;
-	if (initializerCallbackName) callbackPropNames.add(initializerCallbackName);
-	else if (!isNullishRefInitializer(initializer)) return null;
-	for (const variable of variables) for (const candidateReference of variable.references) {
-		if (candidateReference.init) continue;
-		if (candidateReference.isWrite()) return null;
-		const identifier = candidateReference.identifier;
-		if (getRefAliasDeclarator(identifier)) continue;
-		const member = getRefMember(identifier);
-		if (!member || getStaticMemberPropertyName(member) !== "current") return null;
-		const memberParent = findTransparentExpressionRoot(member).parent;
-		if (memberParent && (isNodeOfType(memberParent, "UpdateExpression") || isNodeOfType(memberParent, "UnaryExpression") && memberParent.operator === "delete")) return null;
-		const assignment = getRefMemberAssignment(identifier);
-		if (!assignment) continue;
-		const assignmentStatement = findTransparentExpressionRoot(assignment).parent;
-		if (assignment.operator !== "=" || !assignmentStatement || !isNodeOfType(assignmentStatement, "ExpressionStatement") || assignmentStatement.parent !== componentFunction.body) return null;
-		const assignedCallbackName = getParentCallbackPropName(analysis, assignment.right);
-		if (!assignedCallbackName) return null;
-		callbackPropNames.add(assignedCallbackName);
-	}
-	return callbackPropNames.size > 0 ? { callbackPropNames } : null;
-};
 const isWrapperHookCallbackRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
@@ -34459,79 +33826,71 @@ const noPassDataToParent = defineRule({
 	severity: "warn",
 	tags: ["test-noise"],
 	recommendation: "Fetch the data in the parent and pass it down as a prop (or return it from the hook), instead of handing it back up through a prop callback in a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#passing-data-to-the-parent",
-	create: (context) => {
-		const isReactUseRefCall = (node) => isReactApiCall(node, "useRef", context.scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true
-		});
-		return { CallExpression(node) {
-			if (!isUseEffect(node)) return;
-			const analysis = getProgramAnalysis(node);
-			if (!analysis) return;
-			if (hasCleanup(analysis, node)) return;
-			const effectFnRefs = getEffectFnRefs(analysis, node);
-			if (!effectFnRefs) return;
-			const effectFn = getEffectFn(analysis, node);
-			if (!effectFn) return;
-			for (const ref of effectFnRefs) {
-				const callExpr = getCallExpr(ref);
-				if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
-				const callbackRefProvenance = getCallbackRefProvenance(analysis, node, callExpr, isReactUseRefCall);
-				if (isRefCall(analysis, ref) && !callbackRefProvenance) continue;
-				if (!isSynchronous(ref.identifier, effectFn)) continue;
-				const calleeNode = unwrapChainExpression$1(callExpr.callee);
-				const identifier = ref.identifier;
-				if (callbackRefProvenance) {
-					if ([...callbackRefProvenance.callbackPropNames].some((callbackPropName) => COMMAND_PROP_NAME_PATTERN.test(callbackPropName))) continue;
-				} else if (calleeNode === identifier) {
-					if (!isDirectParentCallbackRef(analysis, ref)) continue;
-					if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
-				} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
-					if (!isWholePropsObjectReference(analysis, ref)) continue;
-					if (isCustomHookParameter(ref)) continue;
-				} else continue;
-				const methodName = getCallMethodName(calleeNode);
-				const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
-				if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
-				if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
-				if (!callbackRefProvenance && isNamespacedApiCallee(calleeNode)) continue;
-				const isSetterNamedCallee = callbackRefProvenance ? [...callbackRefProvenance.callbackPropNames].every((callbackPropName) => SETTER_NAMED_PROP_PATTERN.test(callbackPropName)) : Boolean((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) && SETTER_NAMED_PROP_PATTERN.test((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) ?? ""));
-				const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
-				const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
-					if (isFunctionLike$1(argument)) {
-						if (!isSetterNamedCallee) return [];
-						return getFunctionalUpdaterDataRefs(analysis, argument);
-					}
-					if (isHandlerBagArgument(analysis, argument)) return [];
-					if (isParentWiredHookResultArgument(analysis, argument)) return [];
-					if (isNodeOfType(argument, "Identifier")) {
-						const argumentRef = getRef(analysis, argument);
-						if (argumentRef && resolveToFunction(argumentRef)) return [];
-					}
-					return getDownstreamRefs(analysis, argument);
-				}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
-				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
-				if (!argsUpstreamRefs.some((argRef) => {
-					if (isUseStateIdentifier(argRef.identifier)) return false;
-					if (isProp(analysis, argRef)) return false;
-					if (isUseRefIdentifier(argRef.identifier)) return false;
-					if (isRefCurrent(argRef)) return false;
-					if (isConstant(argRef)) return false;
-					if (isParentWiredHookResultRef(analysis, argRef)) return false;
-					if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
-					if (resolvesToFunctionBinding(argRef)) return false;
-					const argIdentifier = argRef.identifier;
-					if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
-					if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
-					return true;
-				})) continue;
-				context.report({
-					node: callExpr,
-					message: "Handing data back to a parent from a useEffect costs your users an extra render."
-				});
-			}
-		} };
-	}
+	create: (context) => ({ CallExpression(node) {
+		if (!isUseEffect(node)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		if (hasCleanup(analysis, node)) return;
+		const effectFnRefs = getEffectFnRefs(analysis, node);
+		if (!effectFnRefs) return;
+		const effectFn = getEffectFn(analysis, node);
+		if (!effectFn) return;
+		for (const ref of effectFnRefs) {
+			const callExpr = getCallExpr(ref);
+			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
+			if (isRefCall(analysis, ref)) continue;
+			if (!isSynchronous(ref.identifier, effectFn)) continue;
+			const calleeNode = unwrapChainExpression$1(callExpr.callee);
+			const identifier = ref.identifier;
+			if (calleeNode === identifier) {
+				if (!isDirectParentCallbackRef(analysis, ref)) continue;
+				if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
+			} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
+				if (!isWholePropsObjectReference(analysis, ref)) continue;
+				if (isCustomHookParameter(ref)) continue;
+			} else continue;
+			const methodName = getCallMethodName(calleeNode);
+			const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
+			if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
+			if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
+			if (isNamespacedApiCallee(calleeNode)) continue;
+			const calleeName = isNodeOfType(identifier, "Identifier") ? identifier.name : methodName;
+			const isSetterNamedCallee = Boolean(calleeName && SETTER_NAMED_PROP_PATTERN.test(calleeName));
+			const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
+			const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
+				if (isFunctionLike$1(argument)) {
+					if (!isSetterNamedCallee) return [];
+					return getFunctionalUpdaterDataRefs(analysis, argument);
+				}
+				if (isHandlerBagArgument(analysis, argument)) return [];
+				if (isParentWiredHookResultArgument(analysis, argument)) return [];
+				if (isNodeOfType(argument, "Identifier")) {
+					const argumentRef = getRef(analysis, argument);
+					if (argumentRef && resolveToFunction(argumentRef)) return [];
+				}
+				return getDownstreamRefs(analysis, argument);
+			}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
+			if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
+			if (!argsUpstreamRefs.some((argRef) => {
+				if (isUseStateIdentifier(argRef.identifier)) return false;
+				if (isProp(analysis, argRef)) return false;
+				if (isUseRefIdentifier(argRef.identifier)) return false;
+				if (isRefCurrent(argRef)) return false;
+				if (isConstant(argRef)) return false;
+				if (isParentWiredHookResultRef(analysis, argRef)) return false;
+				if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
+				if (resolvesToFunctionBinding(argRef)) return false;
+				const argIdentifier = argRef.identifier;
+				if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
+				if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
+				return true;
+			})) continue;
+			context.report({
+				node: callExpr,
+				message: "Handing data back to a parent from a useEffect costs your users an extra render."
+			});
+		}
+	} })
 });
 //#endregion
 //#region src/plugin/utils/is-call-result-consumed-as-argument.ts
@@ -35085,66 +34444,6 @@ const noPropCallbackInEffect = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-prop-callback-in-render.ts
-const isPreservedThroughConciseArrow = (callExpression, scopes) => {
-	let node = callExpression;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "ChainExpression")) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "SequenceExpression")) {
-			const expressions = parent.expressions ?? [];
-			if (expressions[expressions.length - 1] !== node) return false;
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (!isNodeOfType(parent, "ArrowFunctionExpression") || parent.body !== node) return !isResultDiscardedCall(node);
-		const invocation = parent.parent;
-		if (!isNodeOfType(invocation, "CallExpression") || !executesDuringRender(parent, scopes)) return true;
-		if (invocation.arguments?.[0] === parent || invocation.arguments?.[1] === parent) {
-			const callee = stripParenExpression(invocation.callee);
-			return !(isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "forEach" && invocation.arguments[0] === parent);
-		}
-		node = invocation;
-		parent = node.parent;
-	}
-	return false;
-};
-const noPropCallbackInRender = defineRule({
-	id: "no-prop-callback-in-render",
-	title: "Prop callback invoked during render",
-	severity: "error",
-	recommendation: "Invoke the callback from the event or asynchronous operation that produced the value, or from an effect when synchronizing with an external system. Render must stay pure because React can replay or discard it.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isResultDiscardedCall(node)) return;
-		if (isPreservedThroughConciseArrow(node, context.scopes)) return;
-		if (!findRenderPhaseComponentOrHook(node, context.scopes)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		const callee = stripParenExpression(node.callee);
-		if (isFunctionLike$1(callee)) return;
-		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference))) return;
-		context.report({
-			node,
-			message: "This prop callback runs during render. React can replay or discard render work, so the callback can fire more than once or for UI that never commits."
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/rules/architecture/no-prop-types.ts
 const PROP_TYPES_PROPERTY = "propTypes";
 const isPropTypesKey = (key, computed) => {
@@ -35839,63 +35138,6 @@ const noRedundantShouldComponentUpdate = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
-const resolveReactRefSymbol = (memberExpression, scopes) => {
-	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
-	if (!isNodeOfType(memberExpression, "MemberExpression") || memberExpression.computed || !isNodeOfType(memberExpression.property, "Identifier") || memberExpression.property.name !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
-	const symbol = resolveConstIdentifierAlias(receiver, scopes);
-	if (!symbol?.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
-};
-const isSameRefCurrentMember = (node, refSymbol, scopes) => {
-	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return false;
-	const receiver = stripParenExpression(node.object);
-	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
-};
-const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
-	if (assignmentExpression.operator !== "=" || !isNodeOfType(assignmentExpression.right, "NewExpression")) return false;
-	let descendant = assignmentExpression;
-	let ancestor = descendant.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant && isNodeOfType(ancestor.test, "BinaryExpression") && (ancestor.test.operator === "===" || ancestor.test.operator === "==")) {
-			const { left, right } = ancestor.test;
-			if (isSameRefCurrentMember(left, refSymbol, scopes) && isNodeOfType(right, "Literal") && right.value === null || isSameRefCurrentMember(right, refSymbol, scopes) && isNodeOfType(left, "Literal") && left.value === null) return true;
-		}
-		descendant = ancestor;
-		ancestor = descendant.parent;
-	}
-	return false;
-};
-const noRefCurrentInRender = defineRule({
-	id: "no-ref-current-in-render",
-	title: "Ref mutated during render",
-	severity: "error",
-	recommendation: "Move ref writes into an event handler or effect. Render must stay pure because React can replay or discard it. The predictable null-guarded lazy initialization pattern remains supported.",
-	create: (context) => {
-		const report = (memberExpression) => {
-			if (!resolveReactRefSymbol(memberExpression, context.scopes)) return;
-			if (!findRenderPhaseComponentOrHook(memberExpression, context.scopes)) return;
-			context.report({
-				node: memberExpression,
-				message: "This ref is mutated during render. React can replay or discard render work, so the mutation can leak from UI that never commits."
-			});
-		};
-		return {
-			AssignmentExpression(node) {
-				const refSymbol = resolveReactRefSymbol(node.left, context.scopes);
-				if (!refSymbol) return;
-				if (isDocumentedLazyInitialization(node, refSymbol, context.scopes)) return;
-				report(node.left);
-			},
-			UpdateExpression(node) {
-				report(node.argument);
-			}
-		};
-	}
-});
-//#endregion
 //#region src/plugin/rules/architecture/no-render-in-render.ts
 const isInsideComponentContext = (node) => {
 	let cursor = node.parent;
@@ -56858,18 +56100,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noImgLazyWithHighFetchpriority.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-impure-state-updater",
-		id: "no-impure-state-updater",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noImpureStateUpdater,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noImpureStateUpdater.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-indeterminate-attribute",
 		id: "no-indeterminate-attribute",
@@ -57286,18 +56516,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noPropCallbackInEffect.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-prop-callback-in-render",
-		id: "no-prop-callback-in-render",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noPropCallbackInRender,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noPropCallbackInRender.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-prop-types",
 		id: "no-prop-types",
@@ -57389,18 +56607,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noRedundantShouldComponentUpdate.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-ref-current-in-render",
-		id: "no-ref-current-in-render",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noRefCurrentInRender,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noRefCurrentInRender.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-render-in-render",
 		id: "no-render-in-render",