oxlint-plugin-react-doctor 0.7.9-dev.2979a9b → 0.7.9-dev.44d3ad8

package/dist/index.js

@@ -836,21 +836,130 @@ const getImportedName = (importSpecifier) => {
 	if (isNodeOfType(imported, "Literal") && typeof imported.value === "string") return imported.value;
 };
 //#endregion
-//#region src/plugin/utils/get-callee-name.ts
-const getCalleeName$2 = (node) => {
-	if (!isNodeOfType(node, "CallExpression") && !isNodeOfType(node, "NewExpression")) return null;
-	if (isNodeOfType(node.callee, "Identifier")) return node.callee.name;
-	if (isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier")) return node.callee.property.name;
+//#region src/plugin/utils/get-static-property-key-name.ts
+const getStaticPropertyKeyName = (node, options = {}) => {
+	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition") && !isNodeOfType(node, "MemberExpression")) return null;
+	const key = isNodeOfType(node, "MemberExpression") ? node.property : node.key;
+	if (node.computed) {
+		if (options.allowComputedString && isNodeOfType(key, "Literal") && typeof key.value === "string") return key.value;
+		if (options.allowComputedString && isNodeOfType(key, "TemplateLiteral") && key.expressions.length === 0) return key.quasis[0]?.value.cooked ?? key.quasis[0]?.value.raw ?? null;
+		return null;
+	}
+	if (isNodeOfType(key, "Identifier")) return key.name;
+	if (isNodeOfType(key, "Literal")) {
+		if (typeof key.value === "string") return key.value;
+		if (options.stringifyNonStringLiterals) return String(key.value);
+	}
 	return null;
 };
 //#endregion
-//#region src/plugin/utils/is-hook-call.ts
-const isHookCall$2 = (node, hookName) => {
+//#region src/plugin/utils/get-static-property-name.ts
+const getStaticPropertyName = (memberExpression) => {
+	const property = memberExpression.property;
+	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
+	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
+	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/strip-paren-expression.ts
+const TRANSPARENT_EXPRESSION_WRAPPER_TYPES = new Set([
+	"ParenthesizedExpression",
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion",
+	"TSNonNullExpression",
+	"TSInstantiationExpression",
+	"ChainExpression"
+]);
+const stripParenExpression = (node) => {
+	let current = node;
+	while (TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(current.type) && "expression" in current && current.expression) current = current.expression;
+	return current;
+};
+//#endregion
+//#region src/plugin/utils/resolve-const-identifier-alias.ts
+const resolveConstIdentifierAlias = (identifier, scopes, allowPatternBinding = false) => {
+	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let symbol = scopes.symbolFor(identifier);
+	while (symbol?.kind === "const") {
+		if (visitedSymbolIds.has(symbol.id) || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return null;
+		if (symbol.declarationNode.id !== symbol.bindingIdentifier) return allowPatternBinding ? symbol : null;
+		visitedSymbolIds.add(symbol.id);
+		const initializer = stripParenExpression(symbol.initializer);
+		if (!isNodeOfType(initializer, "Identifier")) return symbol;
+		symbol = scopes.symbolFor(initializer);
+	}
+	return symbol;
+};
+//#endregion
+//#region src/plugin/utils/is-react-api-call.ts
+const includesApiName = (apiNames, apiName) => typeof apiNames === "string" ? apiNames === apiName : apiNames.has(apiName);
+const isImportedFromReact = (symbol) => {
+	if (symbol.kind !== "import") return false;
+	const importDeclaration = symbol.declarationNode.parent;
+	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && typeof importDeclaration.source.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(importDeclaration.source.value));
+};
+const isNamedReactApiImport = (identifier, apiNames, scopes, resolveAliases) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const symbol = resolveAliases ? resolveConstIdentifierAlias(identifier, scopes) : scopes.symbolFor(identifier);
+	if (!symbol || !isImportedFromReact(symbol)) return false;
+	const importedName = getImportedName(symbol.declarationNode);
+	return Boolean(importedName && includesApiName(apiNames, importedName));
+};
+const isReactNamespaceImport = (identifier, scopes) => {
+	const symbol = resolveConstIdentifierAlias(identifier, scopes);
+	if (!symbol || !isImportedFromReact(symbol)) return false;
+	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier") || getImportedName(symbol.declarationNode) === "default";
+};
+const isReactNamespaceReceiver$1 = (receiver, scopes, options) => {
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	if (isReactNamespaceImport(receiver, scopes)) return true;
+	return Boolean(options.allowGlobalReactNamespace && receiver.name === "React" && scopes.isGlobalReference(receiver));
+};
+const isDestructuredReactApiBinding = (identifier, apiNames, scopes, options) => {
+	const symbol = scopes.symbolFor(identifier);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
+	const pattern = symbol.declarationNode.id;
+	if (!isNodeOfType(pattern, "ObjectPattern")) return false;
+	for (const property of pattern.properties) {
+		if (!isNodeOfType(property, "Property") || property.value !== symbol.bindingIdentifier) continue;
+		const propertyName = getStaticPropertyKeyName(property);
+		return Boolean(propertyName && includesApiName(apiNames, propertyName) && isReactNamespaceReceiver$1(stripParenExpression(symbol.initializer), scopes, options));
+	}
+	return false;
+};
+const isReactApiCall = (node, apiNames, scopes, options = {}) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	const calleeName = getCalleeName$2(node);
-	if (!calleeName) return false;
-	return typeof hookName === "string" ? calleeName === hookName : hookName.has(calleeName);
+	return isReactApiCallee(node.callee, apiNames, scopes, options, /* @__PURE__ */ new Set());
 };
+const isReactApiCallee = (rawCallee, apiNames, scopes, options, visitedSymbolIds) => {
+	const callee = stripParenExpression(rawCallee);
+	if (options.resolveConditionalAliases && isNodeOfType(callee, "ConditionalExpression")) return isReactApiCallee(callee.consequent, apiNames, scopes, options, new Set(visitedSymbolIds)) && isReactApiCallee(callee.alternate, apiNames, scopes, options, new Set(visitedSymbolIds));
+	if (isNodeOfType(callee, "Identifier")) {
+		if (isNamedReactApiImport(callee, apiNames, scopes, Boolean(options.resolveNamedAliases))) return true;
+		if (options.resolveNamedAliases && isDestructuredReactApiBinding(callee, apiNames, scopes, options)) return true;
+		if (options.resolveConditionalAliases) {
+			const symbol = scopes.symbolFor(callee);
+			if (symbol?.kind === "const" && symbol.initializer && !visitedSymbolIds.has(symbol.id)) {
+				visitedSymbolIds.add(symbol.id);
+				return isReactApiCallee(symbol.initializer, apiNames, scopes, options, visitedSymbolIds);
+			}
+		}
+		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
+	}
+	if (!isNodeOfType(callee, "MemberExpression") || !includesApiName(apiNames, getStaticPropertyName(callee) ?? "")) return false;
+	return isReactNamespaceReceiver$1(stripParenExpression(callee.object), scopes, options);
+};
+//#endregion
+//#region src/plugin/utils/is-react-hook-call.ts
+const isReactHookCall = (node, hookNames, scopes) => isReactApiCall(node, hookNames, scopes, {
+	allowGlobalReactNamespace: true,
+	allowUnboundBareCalls: true,
+	resolveConditionalAliases: true,
+	resolveNamedAliases: true
+});
 //#endregion
 //#region src/plugin/utils/is-ast-node.ts
 const isAstNode = (value) => value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
@@ -921,12 +1030,12 @@ const collectChildComponentNames = (element, into) => {
 		into.add(name);
 	});
 };
-const countEffectHookCalls = (body) => {
+const countEffectHookCalls = (body, scopes) => {
 	if (!body) return 0;
 	let count = 0;
 	walkAst(body, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isHookCall$2(child, EFFECT_HOOK_NAMES$1)) count++;
+		if (isReactHookCall(child, EFFECT_HOOK_NAMES$1, scopes)) count++;
 	});
 	return count;
 };
@@ -952,11 +1061,11 @@ const getComponentEffectIndex = (programRoot) => {
 	componentEffectIndexCache.set(programRoot, index);
 	return index;
 };
-const getSameFileComponentEffectCount = (programRoot, componentName) => {
+const getSameFileComponentEffectCount = (programRoot, componentName, scopes) => {
 	const index = getComponentEffectIndex(programRoot);
 	const cachedCount = index.effectCountByName.get(componentName);
 	if (cachedCount !== void 0) return cachedCount;
-	const count = countEffectHookCalls(index.bodyByName.get(componentName) ?? null);
+	const count = countEffectHookCalls(index.bodyByName.get(componentName) ?? null, scopes);
 	index.effectCountByName.set(componentName, count);
 	return count;
 };
@@ -1016,7 +1125,7 @@ const activityWrapsEffectHeavySubtree = defineRule({
 				let totalEffects = 0;
 				const effectfulChildren = [];
 				for (const componentName of childComponentNames) {
-					const effectCount = getSameFileComponentEffectCount(programRoot, componentName);
+					const effectCount = getSameFileComponentEffectCount(programRoot, componentName, context.scopes);
 					if (effectCount === 0) continue;
 					totalEffects += effectCount;
 					effectfulChildren.push(`<${componentName}>`);
@@ -1207,6 +1316,14 @@ const findVariableInitializer = (referenceNode, bindingName) => {
 	return best;
 };
 //#endregion
+//#region src/plugin/utils/get-callee-name.ts
+const getCalleeName$1 = (node) => {
+	if (!isNodeOfType(node, "CallExpression") && !isNodeOfType(node, "NewExpression")) return null;
+	if (isNodeOfType(node.callee, "Identifier")) return node.callee.name;
+	if (isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier")) return node.callee.property.name;
+	return null;
+};
+//#endregion
 //#region src/plugin/utils/is-function-like.ts
 /**
 * Type-guard for the three "function-like" ESTree node shapes:
@@ -1220,37 +1337,6 @@ const findVariableInitializer = (referenceNode, bindingName) => {
 */
 const isFunctionLike$1 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
 //#endregion
-//#region src/plugin/utils/strip-paren-expression.ts
-const TRANSPARENT_EXPRESSION_WRAPPER_TYPES = new Set([
-	"ParenthesizedExpression",
-	"TSAsExpression",
-	"TSSatisfiesExpression",
-	"TSTypeAssertion",
-	"TSNonNullExpression",
-	"TSInstantiationExpression",
-	"ChainExpression"
-]);
-const stripParenExpression = (node) => {
-	let current = node;
-	while (TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(current.type) && "expression" in current && current.expression) current = current.expression;
-	return current;
-};
-//#endregion
-//#region src/plugin/utils/resolve-const-identifier-alias.ts
-const resolveConstIdentifierAlias = (identifier, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	let symbol = scopes.symbolFor(identifier);
-	while (symbol?.kind === "const") {
-		if (visitedSymbolIds.has(symbol.id) || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
-		visitedSymbolIds.add(symbol.id);
-		const initializer = stripParenExpression(symbol.initializer);
-		if (!isNodeOfType(initializer, "Identifier")) return symbol;
-		symbol = scopes.symbolFor(initializer);
-	}
-	return symbol;
-};
-//#endregion
 //#region src/plugin/utils/resolve-exact-local-function.ts
 const resolveExactLocalFunction = (expression, scopes) => {
 	const unwrappedExpression = stripParenExpression(expression);
@@ -1296,9 +1382,17 @@ const getRootIdentifier$1 = (node, options) => {
 //#region src/plugin/utils/get-root-identifier-name.ts
 const getRootIdentifierName = (node, options) => getRootIdentifier$1(node, options)?.name ?? null;
 //#endregion
+//#region src/plugin/utils/is-hook-call.ts
+const isHookCall$2 = (node, hookName) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const calleeName = getCalleeName$1(node);
+	if (!calleeName) return false;
+	return typeof hookName === "string" ? calleeName === hookName : hookName.has(calleeName);
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/advanced-event-handler-refs.ts
-const STABLE_HANDLER_HOOK_NAMES = new Set([
-	"useCallback",
+const REACT_STABLE_HANDLER_HOOK_NAMES = new Set(["useCallback", "useEffectEvent"]);
+const CUSTOM_STABLE_HANDLER_HOOK_NAMES = new Set([
 	"useEffectEvent",
 	"useEvent",
 	"useEventCallback",
@@ -1307,21 +1401,21 @@ const STABLE_HANDLER_HOOK_NAMES = new Set([
 ]);
 const THROTTLED_HANDLER_HOOK_PATTERN = /^use\w*(?:Throttle|Debounce)/i;
 const isThrottledHandlerHookCall = (callNode) => {
-	const calleeName = getCalleeName$2(callNode);
+	const calleeName = getCalleeName$1(callNode);
 	return calleeName !== null && THROTTLED_HANDLER_HOOK_PATTERN.test(calleeName);
 };
-const isEmptyDepsUseMemoCall = (callNode) => {
-	if (!isHookCall$2(callNode, "useMemo")) return false;
+const isEmptyDepsUseMemoCall = (callNode, scopes) => {
+	if (!isReactHookCall(callNode, "useMemo", scopes)) return false;
 	const memoDepsNode = callNode.arguments?.[1];
 	return isNodeOfType(memoDepsNode, "ArrayExpression") && (memoDepsNode.elements?.length ?? 0) === 0;
 };
-const isStableHandlerInitializer = (initializer) => {
-	if (isNodeOfType(initializer, "CallExpression")) return isHookCall$2(initializer, STABLE_HANDLER_HOOK_NAMES) || isEmptyDepsUseMemoCall(initializer) || isThrottledHandlerHookCall(initializer);
+const isStableHandlerInitializer = (initializer, scopes) => {
+	if (isNodeOfType(initializer, "CallExpression")) return isReactHookCall(initializer, REACT_STABLE_HANDLER_HOOK_NAMES, scopes) || isHookCall$2(initializer, CUSTOM_STABLE_HANDLER_HOOK_NAMES) || isEmptyDepsUseMemoCall(initializer, scopes) || isThrottledHandlerHookCall(initializer);
 	return isNodeOfType(initializer, "MemberExpression") && isNodeOfType(initializer.property, "Identifier") && initializer.property.name === "current";
 };
-const isStableRefReceiverDep = (referenceNode, receiverDepName) => {
+const isStableRefReceiverDep = (referenceNode, receiverDepName, scopes) => {
 	const receiverBinding = findVariableInitializer(referenceNode, receiverDepName);
-	return Boolean(receiverBinding?.initializer && isHookCall$2(receiverBinding.initializer, "useRef"));
+	return Boolean(receiverBinding?.initializer && isReactHookCall(receiverBinding.initializer, "useRef", scopes));
 };
 const advancedEventHandlerRefs = defineRule({
 	id: "advanced-event-handler-refs",
@@ -1331,7 +1425,7 @@ const advancedEventHandlerRefs = defineRule({
 	category: "Performance",
 	recommendation: "Store the handler in a ref and have the listener read `handlerRef.current()`. The subscription stays put while the latest handler still runs.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
+		if (!isReactHookCall(node, EFFECT_HOOK_NAMES$1, context.scopes)) return;
 		if ((node.arguments?.length ?? 0) < 2) return;
 		const callback = getEffectCallback(node);
 		if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
@@ -1355,8 +1449,8 @@ const advancedEventHandlerRefs = defineRule({
 		});
 		if (!registeredHandlerName) return;
 		const handlerBinding = findVariableInitializer(node, registeredHandlerName);
-		if (handlerBinding?.initializer && isStableHandlerInitializer(handlerBinding.initializer)) return;
-		if ([...depIdentifierNames].some((depName) => depName !== registeredHandlerName && subscriptionReceiverNames.has(depName) && !isStableRefReceiverDep(node, depName))) return;
+		if (handlerBinding?.initializer && isStableHandlerInitializer(handlerBinding.initializer, context.scopes)) return;
+		if ([...depIdentifierNames].some((depName) => depName !== registeredHandlerName && subscriptionReceiverNames.has(depName) && !isStableRefReceiverDep(node, depName, context.scopes))) return;
 		context.report({
 			node,
 			message: `useEffect re-adds the "${registeredHandlerName}" listener every time the handler changes.`
@@ -1843,15 +1937,6 @@ const flattenJsxName$1 = (node) => {
 	return null;
 };
 //#endregion
-//#region src/plugin/utils/get-static-property-name.ts
-const getStaticPropertyName = (memberExpression) => {
-	const property = memberExpression.property;
-	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
-	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
-	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/is-generated-image-renderer-call.ts
 const GENERATED_IMAGE_RENDERER_MODULES = [
 	"next/og",
@@ -4859,23 +4944,6 @@ const containsDirectAwait = (node) => {
 	return foundAwait;
 };
 //#endregion
-//#region src/plugin/utils/get-static-property-key-name.ts
-const getStaticPropertyKeyName = (node, options = {}) => {
-	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition") && !isNodeOfType(node, "MemberExpression")) return null;
-	const key = isNodeOfType(node, "MemberExpression") ? node.property : node.key;
-	if (node.computed) {
-		if (options.allowComputedString && isNodeOfType(key, "Literal") && typeof key.value === "string") return key.value;
-		if (options.allowComputedString && isNodeOfType(key, "TemplateLiteral") && key.expressions.length === 0) return key.quasis[0]?.value.cooked ?? key.quasis[0]?.value.raw ?? null;
-		return null;
-	}
-	if (isNodeOfType(key, "Identifier")) return key.name;
-	if (isNodeOfType(key, "Literal")) {
-		if (typeof key.value === "string") return key.value;
-		if (options.stringifyNonStringLiterals) return String(key.value);
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/get-destructured-binding-property-name.ts
 const getDestructuredBindingPropertyName = (bindingIdentifier) => {
 	let bindingNode = bindingIdentifier;
@@ -8940,65 +9008,6 @@ const hasVisibleBindingNamed = (node, bindingName, scopes) => {
 	}
 };
 //#endregion
-//#region src/plugin/utils/is-react-api-call.ts
-const includesApiName = (apiNames, apiName) => typeof apiNames === "string" ? apiNames === apiName : apiNames.has(apiName);
-const isImportedFromReact = (symbol) => {
-	if (symbol.kind !== "import") return false;
-	const importDeclaration = symbol.declarationNode.parent;
-	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && typeof importDeclaration.source.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(importDeclaration.source.value));
-};
-const isNamedReactApiImport = (identifier, apiNames, scopes, resolveAliases) => {
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const symbol = resolveAliases ? resolveConstIdentifierAlias(identifier, scopes) : scopes.symbolFor(identifier);
-	if (!symbol || !isImportedFromReact(symbol)) return false;
-	const importedName = getImportedName(symbol.declarationNode);
-	return Boolean(importedName && includesApiName(apiNames, importedName));
-};
-const isReactNamespaceImport = (identifier, scopes) => {
-	const symbol = resolveConstIdentifierAlias(identifier, scopes);
-	if (!symbol || !isImportedFromReact(symbol)) return false;
-	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier") || getImportedName(symbol.declarationNode) === "default";
-};
-const isReactNamespaceReceiver$1 = (receiver, scopes, options) => {
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (isReactNamespaceImport(receiver, scopes)) return true;
-	return Boolean(options.allowGlobalReactNamespace && receiver.name === "React" && scopes.isGlobalReference(receiver));
-};
-const isDestructuredReactApiBinding = (identifier, apiNames, scopes, options) => {
-	const symbol = scopes.symbolFor(identifier);
-	if (!symbol || symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
-	const pattern = symbol.declarationNode.id;
-	if (!isNodeOfType(pattern, "ObjectPattern")) return false;
-	for (const property of pattern.properties) {
-		if (!isNodeOfType(property, "Property") || property.value !== symbol.bindingIdentifier) continue;
-		const propertyName = getStaticPropertyKeyName(property);
-		return Boolean(propertyName && includesApiName(apiNames, propertyName) && isReactNamespaceReceiver$1(stripParenExpression(symbol.initializer), scopes, options));
-	}
-	return false;
-};
-const isReactApiCall = (node, apiNames, scopes, options = {}) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	return isReactApiCallee(node.callee, apiNames, scopes, options, /* @__PURE__ */ new Set());
-};
-const isReactApiCallee = (rawCallee, apiNames, scopes, options, visitedSymbolIds) => {
-	const callee = stripParenExpression(rawCallee);
-	if (options.resolveConditionalAliases && isNodeOfType(callee, "ConditionalExpression")) return isReactApiCallee(callee.consequent, apiNames, scopes, options, new Set(visitedSymbolIds)) && isReactApiCallee(callee.alternate, apiNames, scopes, options, new Set(visitedSymbolIds));
-	if (isNodeOfType(callee, "Identifier")) {
-		if (isNamedReactApiImport(callee, apiNames, scopes, Boolean(options.resolveNamedAliases))) return true;
-		if (options.resolveNamedAliases && isDestructuredReactApiBinding(callee, apiNames, scopes, options)) return true;
-		if (options.resolveConditionalAliases) {
-			const symbol = scopes.symbolFor(callee);
-			if (symbol?.kind === "const" && symbol.initializer && !visitedSymbolIds.has(symbol.id)) {
-				visitedSymbolIds.add(symbol.id);
-				return isReactApiCallee(symbol.initializer, apiNames, scopes, options, visitedSymbolIds);
-			}
-		}
-		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
-	}
-	if (!isNodeOfType(callee, "MemberExpression") || !includesApiName(apiNames, getStaticPropertyName(callee) ?? "")) return false;
-	return isReactNamespaceReceiver$1(stripParenExpression(callee.object), scopes, options);
-};
-//#endregion
 //#region src/plugin/utils/is-proven-browser-api-receiver.ts
 const DOM_EVENT_TARGET_TYPE_NAMES = new Set([
 	"AbortSignal",
@@ -13652,7 +13661,7 @@ const getPromiseChainCallForCallback = (candidate) => {
 	if (!callbackContainer.arguments?.some((argument) => stripParenExpression(argument) === candidate)) return null;
 	return isPromiseChainCall(stripParenExpression(callbackContainer.callee)) ? callbackContainer : null;
 };
-const collectEffectInvokedFunctions = (effectCallback) => {
+const collectInvokedFunctions = (effectCallback, includePromiseCallbacks) => {
 	const invokedFunctions = new Set([effectCallback]);
 	const localFunctionBindings = /* @__PURE__ */ new Map();
 	const calledBindingNames = /* @__PURE__ */ new Set();
@@ -13686,12 +13695,14 @@ const collectEffectInvokedFunctions = (effectCallback) => {
 				calledBindingNames.add(callee.name);
 				return;
 			}
-			if (isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
+			if (includePromiseCallbacks && isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
 		});
 		for (const calledName of calledBindingNames) enqueue(localFunctionBindings.get(calledName));
 	}
 	return invokedFunctions;
 };
+const collectEffectInvokedFunctions = (effectCallback) => collectInvokedFunctions(effectCallback, true);
+const collectSynchronouslyEffectInvokedFunctions = (effectCallback) => collectInvokedFunctions(effectCallback, false);
 //#endregion
 //#region src/plugin/utils/is-react-hook-name.ts
 const isReactHookName = (name) => {
@@ -13850,15 +13861,19 @@ const resolveReactRefSymbol = (memberExpression, scopes) => {
 	if (!isNodeOfType(initializer, "CallExpression")) return null;
 	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
 };
-const hasReactRefCurrentOrigin = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+const resolveReactRefCurrentOriginSymbol = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(node);
-	if (resolveReactRefSymbol(expression, scopes)) return true;
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = resolveConstIdentifierAlias(expression, scopes);
-	if (!symbol?.initializer || visitedSymbolIds.has(symbol.id)) return false;
+	const refSymbol = resolveReactRefSymbol(expression, scopes);
+	if (refSymbol) return refSymbol;
+	if (!isNodeOfType(expression, "Identifier")) return null;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return null;
+	const initializer = getDirectUnreassignedInitializer(symbol);
+	if (!initializer) return null;
 	visitedSymbolIds.add(symbol.id);
-	return hasReactRefCurrentOrigin(symbol.initializer, scopes, visitedSymbolIds);
+	return resolveReactRefCurrentOriginSymbol(initializer, scopes, visitedSymbolIds);
 };
+const hasReactRefCurrentOrigin = (node, scopes) => resolveReactRefCurrentOriginSymbol(node, scopes) !== null;
 //#endregion
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
@@ -13876,6 +13891,7 @@ const walkInsideStatementBlocks = (node, visitor) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/is-subscribe-like-call-expression.ts
+const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
 const getSubscribeLikeMethodName = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	if (!isNodeOfType(node.callee, "MemberExpression")) return null;
@@ -13886,6 +13902,11 @@ const isSubscribeLikeCallExpression = (node) => {
 	const methodName = getSubscribeLikeMethodName(node);
 	return methodName !== null && SUBSCRIPTION_METHOD_NAMES.has(methodName);
 };
+const getSubscribeOrObserveMethodName = (node) => {
+	const methodName = getSubscribeLikeMethodName(node);
+	return methodName !== null && (SUBSCRIPTION_METHOD_NAMES.has(methodName) || methodName === "observe") ? methodName : null;
+};
+const isSubscribeOrObserveCallExpression = (node) => getSubscribeOrObserveMethodName(node) !== null;
 const isCleanupReturningSubscribeLikeCallExpression = (node) => {
 	const methodName = getSubscribeLikeMethodName(node);
 	if (methodName === null || !CLEANUP_RETURNING_SUBSCRIPTION_METHOD_NAMES.has(methodName)) return false;
@@ -13938,7 +13959,6 @@ const isNodeReachableWithinFunction = (node, context) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
-const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
 const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
 const REPLAYABLE_ITERATOR_COLLECTION_CACHE = /* @__PURE__ */ new WeakMap();
 const REACT_REF_EFFECT_ANALYSIS_CACHE = /* @__PURE__ */ new WeakMap();
@@ -13948,10 +13968,6 @@ const RESOURCE_NOUN_BY_KIND = {
 	socket: "connection"
 };
 const isSocketConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP.has(node.callee.name);
-const isSubscribeOrObserveCall = (node) => {
-	if (isSubscribeLikeCallExpression(node)) return true;
-	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME;
-};
 const resolveExpressionKey = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	if (!expression) return null;
 	const unwrappedExpression = stripParenExpression(expression);
@@ -14053,12 +14069,13 @@ const findSubscribeLikeUsages = (callback, context) => {
 			});
 			return;
 		}
-		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) {
+		const subscribeOrObserveMethodName = getSubscribeOrObserveMethodName(child);
+		if (subscribeOrObserveMethodName !== null) {
 			const registrationDetails = getCallRegistrationDetails(child, context);
 			usages.push({
 				kind: "subscribe",
 				node: child,
-				resourceName: child.callee.property.name,
+				resourceName: subscribeOrObserveMethodName,
 				handleKey: findAssignedResourceKey(child, context),
 				...registrationDetails
 			});
@@ -14340,6 +14357,39 @@ const findContainingCollectionKey = (resourceNode, context) => {
 	}
 	return null;
 };
+const findPushedResourceCollectionKey = (usage, context) => {
+	if (!isNodeOfType(usage.node, "CallExpression")) return null;
+	const registrationCallee = stripParenExpression(usage.node.callee);
+	if (!isNodeOfType(registrationCallee, "MemberExpression") || registrationCallee.computed) return null;
+	const resourceIdentifier = stripParenExpression(registrationCallee.object);
+	if (!isPrivatePlainConstIdentifier(resourceIdentifier, context)) return null;
+	const resourceSymbol = context.scopes.symbolFor(resourceIdentifier);
+	if (!resourceSymbol) return null;
+	const pushCalls = resourceSymbol.references.flatMap((reference) => {
+		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+		const callNode = referenceRoot.parent;
+		if (!isNodeOfType(callNode, "CallExpression") || !callNode.arguments?.some((argument) => argument === referenceRoot)) return [];
+		const pushCallee = stripParenExpression(callNode.callee);
+		return isNodeOfType(pushCallee, "MemberExpression") && !pushCallee.computed && isNodeOfType(pushCallee.object, "Identifier") && isNodeOfType(pushCallee.property, "Identifier") && pushCallee.property.name === "push" ? [callNode] : [];
+	});
+	if (pushCalls.length !== 1) return null;
+	const pushCall = pushCalls[0];
+	if (findEnclosingFunction$1(pushCall) !== findEnclosingFunction$1(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [pushCall], context)) return null;
+	const pushCallee = stripParenExpression(pushCall.callee);
+	if (!isNodeOfType(pushCallee, "MemberExpression") || !isNodeOfType(pushCallee.object, "Identifier") || !isPrivatePlainConstIdentifier(pushCallee.object, context)) return null;
+	const collectionSymbol = context.scopes.symbolFor(pushCallee.object);
+	const collectionInitializer = collectionSymbol?.initializer ? stripParenExpression(collectionSymbol.initializer) : null;
+	if (!collectionSymbol || !isNodeOfType(collectionInitializer, "ArrayExpression") || (collectionInitializer.elements?.length ?? 0) !== 0 || findEnclosingFunction$1(collectionSymbol.declarationNode) !== findEnclosingFunction$1(usage.node)) return null;
+	return collectionSymbol.references.every((reference) => {
+		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+		const forOfStatement = referenceRoot.parent;
+		if (isNodeOfType(forOfStatement, "ForOfStatement") && forOfStatement.right === referenceRoot && forOfStatement.await !== true) return true;
+		const memberNode = referenceRoot.parent;
+		const callNode = memberNode?.parent;
+		if (!isNodeOfType(memberNode, "MemberExpression") || memberNode.object !== referenceRoot || memberNode.computed || !isNodeOfType(memberNode.property, "Identifier") || !isNodeOfType(callNode, "CallExpression") || callNode.callee !== memberNode) return false;
+		return memberNode.property.name === "forEach" || memberNode.property.name === "push";
+	}) ? resolveExpressionKey(pushCallee.object, context) : null;
+};
 const isWithinAssignmentTarget = (identifier) => {
 	let currentNode = identifier;
 	let parentNode = currentNode.parent;
@@ -14398,6 +14448,14 @@ const isSynchronousIteratorCallback = (functionNode) => {
 	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from") return callNode.arguments?.[1] === functionNode;
 	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$2.has(callee.property.name) && callNode.arguments?.[0] === functionNode;
 };
+const findEnclosingForEachCall = (node) => {
+	const callbackNode = findEnclosingFunction$1(node);
+	if (!callbackNode) return null;
+	const callNode = callbackNode.parent;
+	if (!isNodeOfType(callNode, "CallExpression") || callNode.arguments?.[0] !== callbackNode) return null;
+	const callee = stripParenExpression(callNode.callee);
+	return isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "forEach" ? callNode : null;
+};
 const findDirectCallForReference = (identifier) => {
 	const expressionRoot = findTransparentExpressionRoot(identifier);
 	const callNode = expressionRoot.parent;
@@ -14412,7 +14470,7 @@ const findSingleDirectInvocation = (functionNode, caller, context) => {
 		const callNode = findDirectCallForReference(reference.identifier);
 		return callNode ? [callNode] : [];
 	});
-	if (invocationCalls.length !== 1) return null;
+	if (invocationCalls.length !== 1 || symbol.references.length !== 1) return null;
 	const invocationCall = invocationCalls[0];
 	return findEnclosingFunction$1(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
 };
@@ -14446,7 +14504,15 @@ const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visite
 		if (cleanupChild !== cleanupFunction.body && isFunctionLike$1(cleanupChild) && !isSynchronousIteratorCallback(cleanupChild)) return false;
 		const cleanupCall = isNodeOfType(cleanupChild, "ChainExpression") ? cleanupChild.expression : cleanupChild;
 		if (doesReleaseCallMatchUsage(cleanupChild, usage, context)) {
-			const cleanupForOfStatement = findForOfStatementForIteratorExpression(isNodeOfType(cleanupCall, "CallExpression") ? cleanupCall.arguments?.[0] : null, context);
+			const cleanupForEachCall = findEnclosingForEachCall(cleanupChild);
+			const cleanupCallee = isNodeOfType(cleanupCall, "CallExpression") ? stripParenExpression(cleanupCall.callee) : null;
+			const cleanupReceiverForOfStatement = isNodeOfType(cleanupCallee, "MemberExpression") ? findForOfStatementForIteratorExpression(cleanupCallee.object, context) : null;
+			const cleanupReceiverCollectionKey = cleanupReceiverForOfStatement ? resolveExpressionKey(cleanupReceiverForOfStatement.right, context) : isNodeOfType(cleanupCallee, "MemberExpression") ? resolveIteratorCollectionKey(cleanupCallee.object, context) : null;
+			if (cleanupReceiverCollectionKey !== null && findEnclosingFunction$1(cleanupChild) !== cleanupFunction) {
+				if (cleanupForEachCall && findPushedResourceCollectionKey(usage, context) === cleanupReceiverCollectionKey) matchingLoopOrHelperAnchors.push(cleanupForEachCall);
+				return;
+			}
+			const cleanupForOfStatement = findForOfStatementForIteratorExpression(isNodeOfType(cleanupCall, "CallExpression") ? cleanupCall.arguments?.[0] : null, context) ?? cleanupReceiverForOfStatement;
 			if (!cleanupForOfStatement) {
 				didCleanupFunctionMatch = true;
 				return false;
@@ -14490,28 +14556,28 @@ const callbackReturnsCleanupForUsage = (callback, usage, context) => {
 	});
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
 };
-const findDirectHandleGuardForRelease = (releaseCall, owner, usage, context) => {
-	if (usage.handleKey === null) return null;
-	const doesTestRequireLiveHandle = (test) => {
-		if (resolveExpressionKey(test, context) === usage.handleKey) return true;
-		const unwrappedTest = stripParenExpression(test);
-		if (!isNodeOfType(unwrappedTest, "BinaryExpression") || unwrappedTest.operator !== "!=" && unwrappedTest.operator !== "!==") return false;
-		const isNullishOperand = (operand) => {
-			const unwrappedOperand = stripParenExpression(operand);
-			return isNodeOfType(unwrappedOperand, "Literal") && unwrappedOperand.value === null || isNodeOfType(unwrappedOperand, "Identifier") && unwrappedOperand.name === "undefined" && context.scopes.isGlobalReference(unwrappedOperand);
-		};
-		return resolveExpressionKey(unwrappedTest.left, context) === usage.handleKey && isNullishOperand(unwrappedTest.right) || resolveExpressionKey(unwrappedTest.right, context) === usage.handleKey && isNullishOperand(unwrappedTest.left);
+const doesTestRequireLiveExpressionKey = (test, expressionKey, context) => {
+	if (resolveExpressionKey(test, context) === expressionKey) return true;
+	const unwrappedTest = stripParenExpression(test);
+	if (!isNodeOfType(unwrappedTest, "BinaryExpression") || unwrappedTest.operator !== "!=" && unwrappedTest.operator !== "!==") return false;
+	const isNullishOperand = (operand) => {
+		const unwrappedOperand = stripParenExpression(operand);
+		return isNodeOfType(unwrappedOperand, "Literal") && unwrappedOperand.value === null || isNodeOfType(unwrappedOperand, "Identifier") && unwrappedOperand.name === "undefined" && context.scopes.isGlobalReference(unwrappedOperand);
 	};
+	return resolveExpressionKey(unwrappedTest.left, context) === expressionKey && isNullishOperand(unwrappedTest.right) || resolveExpressionKey(unwrappedTest.right, context) === expressionKey && isNullishOperand(unwrappedTest.left);
+};
+const findLiveExpressionGuardForRelease = (releaseCall, owner, expressionKey, context) => {
 	let ancestor = releaseCall.parent;
 	while (ancestor && ancestor !== owner) {
 		if (isNodeOfType(ancestor, "IfStatement")) {
-			if (ancestor.alternate !== null || !doesTestRequireLiveHandle(ancestor.test) || !doMatchingNodesCoverEveryPathAfterUsage(ancestor.consequent, [releaseCall], context)) return null;
+			if (ancestor.alternate !== null || !doesTestRequireLiveExpressionKey(ancestor.test, expressionKey, context) || !doMatchingNodesCoverEveryPathAfterUsage(ancestor.consequent, [releaseCall], context)) return null;
 			return ancestor;
 		}
 		ancestor = ancestor.parent;
 	}
 	return null;
 };
+const findDirectHandleGuardForRelease = (releaseCall, owner, usage, context) => usage.handleKey === null ? null : findLiveExpressionGuardForRelease(releaseCall, owner, usage.handleKey, context);
 const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") || !isNodeOfType(callback.body, "BlockStatement")) return false;
 	const functionCfg = context.cfg.cfgFor(callback);
@@ -14540,7 +14606,7 @@ const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	walkAst(componentFunction.body, (child) => {
 		if (didFindUnmountCleanup) return false;
 		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction) return;
-		if (!isHookCall$2(child, CLEANUP_EFFECT_HOOK_NAMES)) return;
+		if (!isReactHookCall(child, CLEANUP_EFFECT_HOOK_NAMES, context.scopes)) return;
 		const dependencyList = child.arguments?.[1];
 		if (!isNodeOfType(dependencyList, "ArrayExpression") || dependencyList.elements.length > 0) return;
 		const cleanupCallback = getEffectCallback(child);
@@ -14699,7 +14765,108 @@ const hasPotentialInterruptionAfterGuard = (callback, guardState, usageNode, con
 	});
 	return hasPotentialInterruption;
 };
+const getNumericReactRefCurrentKey = (expression, context) => {
+	const refSymbol = resolveReactRefSymbol(stripParenExpression(expression), context.scopes);
+	const initializer = refSymbol?.initializer ? stripParenExpression(refSymbol.initializer) : null;
+	if (!isNodeOfType(initializer, "CallExpression")) return null;
+	const initialValue = initializer.arguments?.[0] ? stripParenExpression(initializer.arguments[0]) : null;
+	if (!isNodeOfType(initialValue, "Literal") || typeof initialValue.value !== "number") return null;
+	return resolveExpressionKey(expression, context);
+};
+const getBlockingGenerationKey = (expression, context) => {
+	const test = stripParenExpression(expression);
+	if (isNodeOfType(test, "LogicalExpression") && test.operator === "||") return getBlockingGenerationKey(test.left, context) ?? getBlockingGenerationKey(test.right, context);
+	if (!isNodeOfType(test, "BinaryExpression") || test.operator !== "!==" && test.operator !== "!=") return null;
+	const leftKey = getNumericReactRefCurrentKey(test.left, context);
+	const rightKey = getNumericReactRefCurrentKey(test.right, context);
+	const snapshotExpression = leftKey ? stripParenExpression(test.right) : stripParenExpression(test.left);
+	const key = leftKey ?? rightKey;
+	return key && isNodeOfType(snapshotExpression, "Identifier") ? key : null;
+};
+const findGenerationGuardKeyForDeferredUsage = (usageFunction, usageNode, context) => {
+	if (!isFunctionLike$1(usageFunction)) return null;
+	let generationKey = null;
+	walkAst(usageFunction.body, (child) => {
+		if (generationKey) return false;
+		if (child !== usageFunction.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "IfStatement") || child.alternate) return;
+		const key = getBlockingGenerationKey(child.test, context);
+		if (!key || canNodeReachLaterNodeWithinFunction(child.consequent, usageNode, usageFunction, context) || !doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], usageFunction, context)) return;
+		generationKey = key;
+	});
+	return generationKey;
+};
+const isGenerationAdvance = (node, generationKey, context) => {
+	if (isNodeOfType(node, "UpdateExpression") && resolveExpressionKey(node.argument, context) === generationKey) return true;
+	if (!isNodeOfType(node, "AssignmentExpression") || resolveExpressionKey(node.left, context) !== generationKey || node.operator !== "+=" && node.operator !== "-=") return false;
+	const amount = stripParenExpression(node.right);
+	return isNodeOfType(amount, "Literal") && typeof amount.value === "number" && amount.value !== 0;
+};
+const functionAdvancesGeneration = (owner, generationKey, context) => {
+	if (!isFunctionLike$1(owner)) return false;
+	let didAdvanceGeneration = false;
+	walkAst(owner.body, (child) => {
+		if (didAdvanceGeneration) return false;
+		if (child !== owner.body && isFunctionLike$1(child)) return false;
+		if (isGenerationAdvance(child, generationKey, context)) {
+			didAdvanceGeneration = true;
+			return false;
+		}
+	});
+	return didAdvanceGeneration;
+};
+const cleanupReturnsReleaseUsage = (cleanupReturns, usage, context) => cleanupReturns.length > 0 && cleanupReturns.every((cleanupReturn) => {
+	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
+	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
+	return Boolean(cleanupFunction && isFunctionLike$1(cleanupFunction) && doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context));
+});
+const getOwnedFunctionReference = (reference, usageFunction, usageNode, callback, cleanupReturns, context) => {
+	const directCall = findDirectCallForReference(reference);
+	if (directCall) {
+		const referenceOwner = findEnclosingFunction$1(directCall);
+		if (referenceOwner && referenceOwner !== usageFunction && collectSynchronouslyEffectInvokedFunctions(callback).has(referenceOwner)) return { generationKey: null };
+		const generationKey = referenceOwner ? findGenerationGuardKeyForDeferredUsage(referenceOwner, directCall, context) : null;
+		return generationKey ? { generationKey } : null;
+	}
+	const referenceRoot = findTransparentExpressionRoot(reference);
+	const schedulerCall = referenceRoot.parent;
+	if (!isNodeOfType(schedulerCall, "CallExpression") || !schedulerCall.arguments.some((argument) => argument === referenceRoot) || !isNodeOfType(schedulerCall.callee, "Identifier") || schedulerCall.callee.name !== "setTimeout" || !context.scopes.isGlobalReference(schedulerCall.callee)) return null;
+	const schedulerUsage = {
+		kind: "timer",
+		node: schedulerCall,
+		resourceName: schedulerCall.callee.name,
+		handleKey: findAssignedResourceKey(schedulerCall, context),
+		receiverKey: null,
+		registrationVerbName: schedulerCall.callee.name,
+		eventKey: null,
+		handlerKey: null
+	};
+	const generationKey = findGenerationGuardKeyForDeferredUsage(usageFunction, usageNode, context);
+	return schedulerUsage.handleKey !== null && cleanupReturnsReleaseUsage(cleanupReturns, schedulerUsage, context) && generationKey ? { generationKey } : null;
+};
+const hasGuardedRefOwnedNestedCleanup = (callback, usage, cleanupReturns, context) => {
+	const usageFunction = findEnclosingFunction$1(usage.node);
+	const usageExpression = findTransparentExpressionRoot(usage.node);
+	const usageAssignment = usageExpression.parent;
+	if (usage.kind !== "subscribe" && usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !resolveReactRefSymbol(stripParenExpression(usageAssignment.left), context.scopes) || !collectSynchronouslyEffectInvokedFunctions(callback).has(usageFunction) || !cleanupReturnsReleaseUsage(cleanupReturns, usage, context) || !doMatchingNodesCoverEveryPathFromFunctionEntry(callback, cleanupReturns, context)) return false;
+	const cleanupFunctions = cleanupReturns.flatMap((cleanupReturn) => {
+		if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return [];
+		const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
+		return cleanupFunction && isFunctionLike$1(cleanupFunction) ? [cleanupFunction] : [];
+	});
+	const bindingIdentifier = getFunctionBindingIdentifier$1(usageFunction);
+	const functionSymbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
+	if (!functionSymbol || functionSymbol.references.length === 0) return false;
+	const ownedReferences = functionSymbol.references.map((reference) => getOwnedFunctionReference(reference.identifier, usageFunction, usage.node, callback, cleanupReturns, context));
+	if (ownedReferences.some((reference) => reference === null)) return false;
+	const generationKeys = new Set(ownedReferences.flatMap((reference) => reference?.generationKey ? [reference.generationKey] : []));
+	if (generationKeys.size !== 1) return false;
+	const generationKey = generationKeys.values().next().value;
+	if (typeof generationKey !== "string") return false;
+	return [...collectSynchronouslyEffectInvokedFunctions(callback), ...cleanupFunctions].some((owner) => functionAdvancesGeneration(owner, generationKey, context));
+};
 const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
+	if (hasGuardedRefOwnedNestedCleanup(callback, usage, cleanupReturns, context)) return true;
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
 	if (usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usage.node, "CallExpression") || !isNodeOfType(usage.node.callee, "Identifier") || !context.scopes.isGlobalReference(usage.node.callee) || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
@@ -14870,7 +15037,7 @@ const getReleaseVerbName = (node) => {
 const isRetainedAbortControllerRefRelease = (releaseReceiver, usage, context) => {
 	const releaseFunction = findEnclosingFunction$1(releaseReceiver);
 	const usageFunction = findEnclosingFunction$1(usage.node);
-	if (!releaseFunction || !usageFunction || !isFunctionLike$1(usageFunction) || !isReturnedEffectCleanupFunction(releaseFunction) || !hasReactRefCurrentOrigin(releaseReceiver, context.scopes)) return false;
+	if (!releaseFunction || !usageFunction || !isFunctionLike$1(usageFunction) || !isReturnedEffectCleanupFunction(releaseFunction, context) || !resolveReactRefCurrentOriginSymbol(releaseReceiver, context.scopes)) return false;
 	const controllerKey = getListenerAbortControllerKey(usage, context);
 	const refCurrentKey = resolveExpressionKey(releaseReceiver, context);
 	if (controllerKey === null || refCurrentKey === null) return false;
@@ -14890,6 +15057,62 @@ const isRetainedAbortControllerRefRelease = (releaseReceiver, usage, context) =>
 	const safeOwnershipAssignments = ownershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, previousAbortCalls, usageFunction, context));
 	return doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
 };
+const isJsxRefAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && node.name.name === "ref";
+const isFunctionForwardedToReactRef = (functionNode, context) => {
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
+	if (!bindingIdentifier) return false;
+	const symbol = context.scopes.symbolFor(bindingIdentifier);
+	if (!symbol) return false;
+	return symbol.references.some((reference) => {
+		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+		const expressionContainer = referenceRoot.parent;
+		return Boolean(isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === referenceRoot && isJsxRefAttribute(expressionContainer.parent));
+	});
+};
+const isFunctionReturnedFromReactHook = (functionNode, context, requireRefPropertyName) => {
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
+	if (!bindingIdentifier) return false;
+	const symbol = context.scopes.symbolFor(bindingIdentifier);
+	if (!symbol) return false;
+	return symbol.references.some((reference) => {
+		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+		const property = referenceRoot.parent;
+		const propertyName = isNodeOfType(property, "Property") ? getStaticPropertyKeyName(property) : null;
+		if (!isNodeOfType(property, "Property") || property.value !== referenceRoot || !isNodeOfType(property.parent, "ObjectExpression") || requireRefPropertyName && propertyName !== "ref" && !propertyName?.endsWith("Ref")) return false;
+		const returnedObject = findTransparentExpressionRoot(property.parent);
+		const returnStatement = returnedObject.parent;
+		if (!isNodeOfType(returnStatement, "ReturnStatement") || returnStatement.argument !== returnedObject) return false;
+		const ownerFunction = findEnclosingFunction$1(returnStatement);
+		return Boolean(ownerFunction && isReactHookName(getFunctionBindingIdentifier$1(ownerFunction)?.name ?? ""));
+	});
+};
+const isFunctionUsedAsReactRef = (functionNode, context) => isFunctionForwardedToReactRef(functionNode, context) || isFunctionReturnedFromReactHook(functionNode, context, true);
+const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
+	if (!isNodeOfType(usage.node, "CallExpression")) return false;
+	const usageFunction = findEnclosingFunction$1(usage.node);
+	if (!usageFunction || !isFunctionLike$1(usageFunction) || usageFunction !== findEnclosingFunction$1(releaseCall) || !isFunctionUsedAsReactRef(usageFunction, context)) return false;
+	const registrationCallee = stripParenExpression(usage.node.callee);
+	const releaseCallee = stripParenExpression(releaseCall.callee);
+	const releaseRefSymbol = isNodeOfType(releaseCallee, "MemberExpression") ? resolveReactRefCurrentOriginSymbol(releaseCallee.object, context.scopes) : null;
+	if (!isNodeOfType(registrationCallee, "MemberExpression") || registrationCallee.computed || !isNodeOfType(registrationCallee.property, "Identifier") || registrationCallee.property.name !== "addEventListener" || !isNodeOfType(releaseCallee, "MemberExpression") || releaseCallee.computed || !isNodeOfType(releaseCallee.property, "Identifier") || releaseCallee.property.name !== "removeEventListener" || !releaseRefSymbol) return false;
+	const registrationReceiverKey = resolveExpressionKey(stripParenExpression(registrationCallee.object), context);
+	const nodeParameterKey = resolveExpressionKey(usageFunction.params?.[0], context);
+	const releaseReceiverKey = resolveExpressionKey(releaseCallee.object, context);
+	if (registrationReceiverKey === null || registrationReceiverKey !== nodeParameterKey || releaseReceiverKey === null || usage.eventKey === null || usage.eventKey !== resolveExpressionKey(releaseCall.arguments?.[0], context) || usage.handlerKey === null || usage.handlerKey !== resolveExpressionKey(releaseCall.arguments?.[1], context)) return false;
+	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
+	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
+	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
+	const releaseStart = getRangeStart(releaseCall);
+	const matchingOwnershipAssignments = [];
+	const usageFunctionBody = usageFunction.body;
+	walkAst(usageFunctionBody, (child) => {
+		if (child !== usageFunctionBody && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "AssignmentExpression") && child.operator === "=" && resolveReactRefSymbol(stripParenExpression(child.left), context.scopes)?.id === releaseRefSymbol.id && resolveExpressionKey(child.right, context) === registrationReceiverKey && releaseStart !== null && (getRangeStart(child) ?? -1) > releaseStart) matchingOwnershipAssignments.push(child);
+	});
+	const releaseAnchor = findLiveExpressionGuardForRelease(releaseCall, usageFunction, releaseReceiverKey, context) ?? releaseCall;
+	const safeOwnershipAssignments = matchingOwnershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, [releaseAnchor], usageFunction, context));
+	return doMatchingNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
+};
 const doesReleaseCallMatchUsage = (node, usage, context) => {
 	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
 	if (!isNodeOfType(callNode, "CallExpression")) return false;
@@ -14906,14 +15129,21 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (!releaseVerbName) return false;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
 	const releaseReceiverKey = resolveExpressionKey(callee.object, context);
+	const releaseEventKey = resolveExpressionKey(callNode.arguments?.[0], context);
+	const pairedReleaseVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
+	const pushedResourceCollectionKey = findPushedResourceCollectionKey(usage, context);
+	const releaseReceiverForOfStatement = findForOfStatementForIteratorExpression(callee.object, context);
+	const releaseReceiverCollectionKey = releaseReceiverForOfStatement ? resolveExpressionKey(releaseReceiverForOfStatement.right, context) : resolveIteratorCollectionKey(callee.object, context);
+	if (pairedReleaseVerbNames && matchesPairedReleaseVerb(releaseVerbName, pairedReleaseVerbNames) && pushedResourceCollectionKey !== null && pushedResourceCollectionKey === releaseReceiverCollectionKey && (releaseVerbName !== "unobserve" || usage.eventKey !== null && releaseEventKey === usage.eventKey)) return true;
+	if (isReactRefListenerReplacementRelease(callNode, usage, context)) return true;
 	if (usage.kind === "socket") return usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (SOCKET_RELEASE_VERB_NAMES.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName));
 	if (usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub" || releaseVerbName === "close" || releaseVerbName === "unwatch" || releaseVerbName === "unlisten" || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(releaseVerbName))) return true;
 	if (releaseVerbName === "abort" && releaseReceiverKey === getListenerAbortControllerKey(usage, context)) return true;
 	if (releaseVerbName === "abort" && isRetainedAbortControllerRefRelease(callee.object, usage, context)) return true;
 	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) return false;
+	if (usage.registrationVerbName === "subscribe" && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub") && usage.handleKey !== null && resolveExpressionKey(callNode.arguments?.[0], context) === usage.handleKey) return true;
 	const pairedVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
 	if (!pairedVerbNames || !matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return false;
-	const releaseEventKey = resolveExpressionKey(callNode.arguments?.[0], context);
 	const usageEventArgument = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[0] : null;
 	const releaseEventArgument = callNode.arguments?.[0];
 	if (isAssignmentFormForOfIteratorReference(usageEventArgument, context) || isAssignmentFormForOfIteratorReference(releaseEventArgument, context)) return false;
@@ -14947,13 +15177,14 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 		const releaseHandler = usesUnaryListenerSignature ? callNode.arguments?.[0] : callNode.arguments?.[1];
 		if (!releaseHandler) return releaseVerbName === "off";
 		const expectedHandlerKey = usesUnaryListenerSignature ? usage.eventKey : usage.handlerKey;
-		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey;
+		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignature ? 0 : 1] : null;
+		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
 	}
 	if (releaseVerbName === "unobserve" && usage.eventKey !== null) return releaseEventKey === usage.eventKey;
 	return true;
 };
 const matchesPairedReleaseVerb = (releaseVerbName, pairedVerbNames) => pairedVerbNames.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName);
-const isReturnedEffectCleanupFunction = (functionNode) => {
+const isReturnedEffectCleanupFunction = (functionNode, context) => {
 	let currentNode = functionNode;
 	let parentNode = currentNode.parent;
 	while (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
@@ -14962,23 +15193,175 @@ const isReturnedEffectCleanupFunction = (functionNode) => {
 	}
 	const effectCallback = isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode ? findEnclosingFunction$1(parentNode) : isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode ? parentNode : null;
 	const effectCall = effectCallback?.parent;
-	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isHookCall$2(effectCall, CLEANUP_EFFECT_HOOK_NAMES));
+	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isReactHookCall(effectCall, CLEANUP_EFFECT_HOOK_NAMES, context.scopes));
 };
 const isPotentiallyReachableFunction = (functionNode, context) => {
-	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode)) return true;
+	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode, context)) return true;
 	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) return false;
 	const symbol = context.scopes.symbolFor(bindingIdentifier);
 	if (!symbol) return false;
 	return symbol.references.some((reference) => findEnclosingFunction$1(reference.identifier) !== functionNode);
 };
+const findRetainedDisposerStorages = (disposerFunction, usage, context) => {
+	if (!isFunctionLike$1(disposerFunction) || disposerFunction.async || disposerFunction.generator) return [];
+	const usageFunction = findEnclosingFunction$1(usage.node);
+	if (!usageFunction || !isFunctionLike$1(usageFunction)) return [];
+	const assignments = /* @__PURE__ */ new Map();
+	const collectAssignment = (expression) => {
+		const expressionRoot = findTransparentExpressionRoot(expression);
+		const assignment = expressionRoot.parent;
+		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.right !== expressionRoot) return;
+		const refSymbol = resolveReactRefSymbol(stripParenExpression(assignment.left), context.scopes);
+		const refCurrentKey = resolveExpressionKey(assignment.left, context);
+		const retainedFunction = findEnclosingFunction$1(assignment);
+		const assignmentStart = getRangeStart(assignment);
+		if (!refSymbol || !refCurrentKey || !retainedFunction || retainedFunction !== usageFunction || assignmentStart === null) return;
+		assignments.set(assignmentStart, {
+			assignmentNode: assignment,
+			refCurrentKey,
+			retainedFunction
+		});
+	};
+	collectAssignment(disposerFunction);
+	const bindingIdentifier = getFunctionBindingIdentifier$1(disposerFunction);
+	const symbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
+	for (const reference of symbol?.references ?? []) collectAssignment(reference.identifier);
+	walkAst(usageFunction.body, (child) => {
+		if (child !== usageFunction.body && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "AssignmentExpression") && resolveStableValue(child.right, context) === disposerFunction) collectAssignment(child.right);
+	});
+	return [...assignments.values()];
+};
+const isRetainedDisposerStorageEstablished = (storage, usage, context) => doMatchingNodesCoverEveryPathBeforeUsage(usage.node, [storage.assignmentNode], storage.retainedFunction, context) || doMatchingNodesCoverEveryPathAfterUsage(usage.node, [storage.assignmentNode], context);
+const hasUnsafeRetainedDisposerOverwrite = (storage, usage, context) => {
+	let hasUnsafeOverwrite = false;
+	walkAst(storage.retainedFunction.body, (child) => {
+		if (hasUnsafeOverwrite) return false;
+		if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "AssignmentExpression") || child === storage.assignmentNode || resolveExpressionKey(child.left, context) !== storage.refCurrentKey || !canNodeReachLaterNodeWithinFunction(usage.node, child, storage.retainedFunction, context)) return;
+		const storedValue = resolveStableValue(child.right, context);
+		if (!storedValue || !isFunctionLike$1(storedValue) || !doesCleanupFunctionReleaseUsage(storedValue, usage, context)) {
+			hasUnsafeOverwrite = true;
+			return false;
+		}
+	});
+	return hasUnsafeOverwrite;
+};
+const hasEffectCleanupInvocation = (storage, usage, context) => {
+	const componentFunction = findEnclosingFunction$1(storage.retainedFunction);
+	if (!componentFunction || !isFunctionLike$1(componentFunction)) return false;
+	const cleanupFunctionInvokesRef = (cleanupFunction) => {
+		if (!isFunctionLike$1(cleanupFunction)) return false;
+		let didFindCleanupCall = false;
+		walkAst(cleanupFunction.body, (child) => {
+			if (didFindCleanupCall) return false;
+			if (child !== cleanupFunction.body && isFunctionLike$1(child)) return false;
+			if (isNodeOfType(child, "CallExpression") && resolveExpressionKey(child.callee, context) === storage.refCurrentKey) {
+				const callRoot = findTransparentExpressionRoot(child);
+				const callStatement = callRoot.parent;
+				const isDirectBlockStatement = isNodeOfType(cleanupFunction.body, "BlockStatement") && isNodeOfType(callStatement, "ExpressionStatement") && callStatement.parent === cleanupFunction.body;
+				const isConciseBody = cleanupFunction.body === callRoot;
+				if ((isDirectBlockStatement || isConciseBody) && !hasUnprovenReturnBeforeRefOwnedRelease(cleanupFunction, child, storage.refCurrentKey, context)) {
+					didFindCleanupCall = true;
+					return false;
+				}
+			}
+		});
+		return didFindCleanupCall;
+	};
+	const effectReturnsCleanup = (effectCallback) => {
+		if (!isFunctionLike$1(effectCallback)) return false;
+		if (!isNodeOfType(effectCallback.body, "BlockStatement")) {
+			const cleanupFunction = resolveRefOwnedCleanupFunction(effectCallback.body, context);
+			return Boolean(cleanupFunction && cleanupFunctionInvokesRef(cleanupFunction));
+		}
+		const matchingReturns = [];
+		walkInsideStatementBlocks(effectCallback.body, (child) => {
+			if (!isNodeOfType(child, "ReturnStatement") || !child.argument) return;
+			const cleanupFunction = resolveRefOwnedCleanupFunction(child.argument, context);
+			if (!cleanupFunction || !cleanupFunctionInvokesRef(cleanupFunction)) return;
+			matchingReturns.push(child);
+		});
+		return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+	};
+	let didFindInvocation = false;
+	walkAst(componentFunction.body, (child) => {
+		if (didFindInvocation) return false;
+		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
+		const effectCallback = getEffectCallback(child);
+		if (effectCallback && effectReturnsCleanup(effectCallback)) {
+			didFindInvocation = true;
+			return false;
+		}
+	});
+	return didFindInvocation;
+};
+const hasCallbackRefReplacementInvocation = (storage, usage, context) => {
+	const isReturnedCallbackRefShape = () => {
+		if (!isFunctionLike$1(storage.retainedFunction)) return false;
+		const callbackCall = findTransparentExpressionRoot(storage.retainedFunction).parent;
+		if (!isNodeOfType(callbackCall, "CallExpression") || !isReactApiCall(callbackCall, "useCallback", context.scopes)) return false;
+		const nodeParameter = storage.retainedFunction.params?.[0];
+		const nodeParameterKey = resolveExpressionKey(nodeParameter, context);
+		if (!nodeParameterKey || usage.receiverKey !== nodeParameterKey) return false;
+		if (!isFunctionReturnedFromReactHook(storage.retainedFunction, context, false)) return false;
+		const usageStart = getRangeStart(usage.node);
+		if (usageStart === null) return false;
+		let hasNullExit = false;
+		walkAst(storage.retainedFunction.body, (child) => {
+			if (hasNullExit) return false;
+			if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
+			if (!isNodeOfType(child, "IfStatement") || (getRangeStart(child) ?? usageStart) >= usageStart) return;
+			const test = stripParenExpression(child.test);
+			if (!isNodeOfType(test, "UnaryExpression") || test.operator !== "!" || resolveExpressionKey(test.argument, context) !== nodeParameterKey) return;
+			const consequent = child.consequent;
+			hasNullExit = isNodeOfType(consequent, "ReturnStatement") || isNodeOfType(consequent, "BlockStatement") && consequent.body.some((statement) => isNodeOfType(statement, "ReturnStatement"));
+			if (hasNullExit) return false;
+		});
+		return hasNullExit;
+	};
+	if (!isFunctionForwardedToReactRef(storage.retainedFunction, context) && !isReturnedCallbackRefShape()) return false;
+	const cleanupCalls = [];
+	walkAst(storage.retainedFunction.body, (child) => {
+		if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "CallExpression") && resolveExpressionKey(child.callee, context) === storage.refCurrentKey) cleanupCalls.push(child);
+	});
+	return doMatchingNodesCoverEveryPathBeforeUsage(usage.node, cleanupCalls, storage.retainedFunction, context);
+};
+const isRetainedDisposerRefRelease = (releaseNode, usage, context) => {
+	const disposerFunction = findEnclosingFunction$1(releaseNode);
+	if (!disposerFunction) return false;
+	return findRetainedDisposerStorages(disposerFunction, usage, context).some((storage) => isRetainedDisposerStorageEstablished(storage, usage, context) && !hasUnsafeRetainedDisposerOverwrite(storage, usage, context) && (hasEffectCleanupInvocation(storage, usage, context) || hasCallbackRefReplacementInvocation(storage, usage, context)));
+};
+const isSelfReleasingListenerRelease = (releaseNode, releaseFunction, usage, context) => {
+	if (usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.receiverKey === null || usage.eventKey === null || !isNodeOfType(usage.node, "CallExpression") || !isFunctionLike$1(releaseFunction) || releaseFunction.async || releaseFunction.generator || !isNodeOfType(releaseFunction.body, "BlockStatement") || !doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
+	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
+	const releaseCall = isNodeOfType(releaseNode, "ChainExpression") ? releaseNode.expression : releaseNode;
+	if (!isNodeOfType(releaseCall, "CallExpression")) return false;
+	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
+	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
+	const ownerFunction = findEnclosingFunction$1(releaseFunction);
+	if (!ownerFunction || !isFunctionLike$1(ownerFunction)) return false;
+	const triggerRegistrations = [];
+	walkAst(ownerFunction.body, (child) => {
+		if (child !== ownerFunction.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const registrationDetails = getCallRegistrationDetails(child, context);
+		if (registrationDetails.registrationVerbName === "addEventListener" && registrationDetails.receiverKey === usage.receiverKey && resolveStableValue(child.arguments?.[1], context) === releaseFunction) triggerRegistrations.push(child);
+	});
+	if (triggerRegistrations.some((triggerRegistration) => triggerRegistration === usage.node)) return true;
+	return doMatchingNodesCoverEveryPathAfterUsage(usage.node, triggerRegistrations, context) || doMatchingNodesCoverEveryPathBeforeUsage(usage.node, triggerRegistrations, ownerFunction, context);
+};
 const isReleaseReachableForUsage = (releaseNode, usage, context) => {
 	if (!isNodeReachableWithinFunction(releaseNode, context)) return false;
 	const releaseFunction = findEnclosingFunction$1(releaseNode);
 	if (!releaseFunction) return true;
 	if (releaseFunction === findEnclosingFunction$1(usage.node)) return true;
+	if (isRetainedDisposerRefRelease(releaseNode, usage, context)) return true;
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	if (usageFunction && isFunctionLike$1(usageFunction) && getAssignedReactRefSymbol(usageFunction, context) && isCleanupFunctionReferencedByReturn(usageFunction, releaseFunction, context)) return isReactRefCallbackCleanupOwnedByEffect(usageFunction, releaseFunction, usage, context);
+	if (isSelfReleasingListenerRelease(releaseNode, releaseFunction, usage, context)) return true;
 	return isPotentiallyReachableFunction(releaseFunction, context);
 };
 const fileContainsReleaseForUsage = (usage, context) => {
@@ -15310,7 +15693,7 @@ const findRetainedFunctionLeak = (retainedFunction, context, options) => {
 				return false;
 			}
 		}
-		if (isSubscribeOrObserveCall(child) && (!doesResourceResultEscape(child, allowReturnedResourceEscape, allowReturnedResourceEscape, context) || options?.requireCallableReturnedResource === true && !isCleanupReturningSubscribeLikeCallExpression(child))) {
+		if (isSubscribeOrObserveCallExpression(child) && (!doesResourceResultEscape(child, allowReturnedResourceEscape, allowReturnedResourceEscape, context) || options?.requireCallableReturnedResource === true && !isCleanupReturningSubscribeLikeCallExpression(child))) {
 			const registrationDetails = getCallRegistrationDetails(child, context);
 			const subscriptionUsage = {
 				kind: "subscribe",
@@ -15518,7 +15901,7 @@ const isInlineRetainedHandlerFunction = (functionNode, context) => {
 	if (!isFunctionLike$1(functionNode)) return false;
 	const functionRoot = findTransparentExpressionRoot(functionNode);
 	const callbackCall = functionRoot.parent;
-	if (isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments?.[0] === functionRoot && isHookCall$2(callbackCall, "useCallback") && isDirectJsxEventHandlerValue(callbackCall)) return true;
+	if (isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments?.[0] === functionRoot && isReactHookCall(callbackCall, "useCallback", context.scopes) && isDirectJsxEventHandlerValue(callbackCall)) return true;
 	const parentNode = functionNode.parent;
 	if (isDirectJsxEventHandlerValue(functionNode)) return true;
 	if (!isNodeOfType(parentNode, "Property") || parentNode.value !== functionNode || parentNode.computed) return false;
@@ -15554,12 +15937,12 @@ const effectNeedsCleanup = defineRule({
 		};
 		return {
 			CallExpression(node) {
-				if (isHookCall$2(node, "useCallback")) {
+				if (isReactHookCall(node, "useCallback", context.scopes)) {
 					const retainedCallback = getEffectCallback(node);
 					if (retainedCallback && !isInlineRetainedHandlerFunction(retainedCallback, context)) reportRetainedLeak(retainedCallback);
 					return;
 				}
-				if (!isHookCall$2(node, CLEANUP_EFFECT_HOOK_NAMES)) return;
+				if (!isReactHookCall(node, CLEANUP_EFFECT_HOOK_NAMES, context.scopes)) return;
 				const callback = getEffectCallback(node);
 				if (!callback) return;
 				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback, context), context);
@@ -15567,7 +15950,7 @@ const effectNeedsCleanup = defineRule({
 				const firstUsage = findFirstUsageWithoutCleanup(callback, usages, context);
 				if (!firstUsage) return;
 				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
-				const hookName = getCalleeName$2(node) ?? "effect";
+				const hookName = getCalleeName$1(node) ?? "effect";
 				context.report({
 					node,
 					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without guaranteed cleanup. Return a cleanup function that owns every allocation so it does not leak after unmount.`
@@ -16910,7 +17293,38 @@ const symbolHasStableImportedAlias = (symbol, scopes) => {
 	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 isAssignmentTarget = (node) => {
+	let currentNode = findTransparentExpressionRoot(node);
+	while (currentNode.parent) {
+		const parentNode = currentNode.parent;
+		if (isNodeOfType(parentNode, "AssignmentExpression")) return parentNode.left === currentNode;
+		if (isNodeOfType(parentNode, "UpdateExpression")) return parentNode.argument === currentNode;
+		if (isNodeOfType(parentNode, "UnaryExpression")) return parentNode.operator === "delete" && parentNode.argument === currentNode;
+		if (isNodeOfType(parentNode, "ForInStatement") || isNodeOfType(parentNode, "ForOfStatement")) return parentNode.left === currentNode;
+		if (isNodeOfType(parentNode, "ArrayPattern") && parentNode.elements.some((element) => element === currentNode) || isNodeOfType(parentNode, "ObjectPattern") && parentNode.properties.some((property) => property === currentNode) || isNodeOfType(parentNode, "RestElement") && parentNode.argument === currentNode || isNodeOfType(parentNode, "AssignmentPattern") && parentNode.left === currentNode || isNodeOfType(parentNode, "Property") && parentNode.value === currentNode && isNodeOfType(parentNode.parent, "ObjectPattern")) {
+			currentNode = parentNode;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
+const symbolHasStableRefLazyInitialization = (symbol, scopes) => {
+	if (symbol.kind !== "const" || symbol.references.some((reference) => reference.flag !== "read")) return false;
+	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
+	if (!isNodeOfType(initializer, "AssignmentExpression") || initializer.operator !== "??=") return false;
+	const refSymbol = resolveReactRefSymbol(unwrapExpression$3(initializer.left), scopes);
+	if (!refSymbol) return false;
+	return refSymbol.references.every((reference) => {
+		const memberExpression = findTransparentExpressionRoot(reference.identifier).parent;
+		if (!isNodeOfType(memberExpression, "MemberExpression") || unwrapExpression$3(memberExpression.object) !== reference.identifier || getStaticPropertyName(memberExpression) !== "current") return false;
+		const referenceRoot = findTransparentExpressionRoot(memberExpression);
+		const parentNode = referenceRoot.parent;
+		if (isNodeOfType(parentNode, "AssignmentExpression") && parentNode.left === referenceRoot) return parentNode === initializer;
+		return !isAssignmentTarget(referenceRoot);
+	});
+};
+const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol, scopes) || symbolHasStableRefLazyInitialization(symbol, scopes) || symbolHasStableImportedAlias(symbol, scopes) || 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) => {
@@ -17112,7 +17526,7 @@ const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys, allow
 				keys.add(depKey);
 				continue;
 			}
-			const identitySourceKeys = resolveReactiveIdentitySourceKeys(symbol, scopes);
+			const identitySourceKeys = resolvePureCalledFunctionSourceKeys(reference, symbol, scopes) ?? resolveRenderDerivedMutableSourceKeys(reference, symbol, scopes) ?? resolveReactiveIdentitySourceKeys(symbol, scopes);
 			if (identitySourceKeys) {
 				if (identitySourceKeys.size === 0) stableCapturedNames.add(depKey);
 				for (const identitySourceKey of identitySourceKeys) keys.add(identitySourceKey);
@@ -17195,6 +17609,161 @@ 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 isPureDerivedExpression = (expression) => {
+	const candidate = unwrapExpression$3(expression);
+	if (isNodeOfType(candidate, "Literal") || isNodeOfType(candidate, "Identifier")) return true;
+	if (isNodeOfType(candidate, "MemberExpression")) return isPureDerivedExpression(candidate.object) && (!candidate.computed || isPureDerivedExpression(candidate.property));
+	if (isNodeOfType(candidate, "BinaryExpression") || isNodeOfType(candidate, "LogicalExpression")) return isPureDerivedExpression(candidate.left) && isPureDerivedExpression(candidate.right);
+	if (isNodeOfType(candidate, "UnaryExpression")) return candidate.operator !== "delete" && isPureDerivedExpression(candidate.argument);
+	if (isNodeOfType(candidate, "ConditionalExpression")) return isPureDerivedExpression(candidate.test) && isPureDerivedExpression(candidate.consequent) && isPureDerivedExpression(candidate.alternate);
+	if (isNodeOfType(candidate, "TemplateLiteral")) return candidate.expressions.every((nestedExpression) => isPureDerivedExpression(nestedExpression));
+	return false;
+};
+const isPureDerivedStatement = (statement) => {
+	if (isNodeOfType(statement, "BlockStatement")) return statement.body.every((nestedStatement) => isPureDerivedStatement(nestedStatement));
+	if (isNodeOfType(statement, "ReturnStatement")) return !statement.argument || isPureDerivedExpression(statement.argument);
+	if (isNodeOfType(statement, "IfStatement")) return isPureDerivedExpression(statement.test) && isPureDerivedStatement(statement.consequent) && (!statement.alternate || isPureDerivedStatement(statement.alternate));
+	return false;
+};
+const isPureDerivedFunction = (functionNode) => {
+	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return false;
+	if (functionNode.async || functionNode.generator) return false;
+	return isNodeOfType(functionNode.body, "BlockStatement") ? isPureDerivedStatement(functionNode.body) : isPureDerivedExpression(functionNode.body);
+};
+const resolvePureCalledFunctionSourceKeys = (reference, symbol, scopes) => {
+	if (symbol.references.some((symbolReference) => symbolReference.flag !== "read")) return null;
+	const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+	const callExpression = referenceRoot.parent;
+	if (!isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== referenceRoot) return null;
+	const functionNode = getFunctionValueNode(symbol);
+	if (!functionNode || !isPureDerivedFunction(functionNode)) return null;
+	const sourceKeys = /* @__PURE__ */ new Set();
+	for (const capturedReference of closureCaptures(functionNode, scopes)) {
+		const capturedSymbol = capturedReference.resolvedSymbol;
+		if (!capturedSymbol || capturedSymbol.id === symbol.id) continue;
+		if (isOutsideAllFunctions(capturedSymbol) || symbolHasStableValue(capturedSymbol, scopes)) continue;
+		const capturedKey = computeDepKey(capturedReference);
+		if (!capturedKey) return null;
+		if (capturedKey === capturedSymbol.name) {
+			const nestedSourceKeys = resolveReactiveIdentitySourceKeys(capturedSymbol, scopes);
+			if (nestedSourceKeys) {
+				for (const nestedSourceKey of nestedSourceKeys) sourceKeys.add(nestedSourceKey);
+				continue;
+			}
+		}
+		sourceKeys.add(capturedKey);
+	}
+	return sourceKeys.size > 0 ? sourceKeys : null;
+};
+const mergeDerivedExpressionSourceKeys = (expressions, scopes, visitedSymbolIds) => {
+	const sourceKeys = /* @__PURE__ */ new Set();
+	for (const expression of expressions) {
+		const expressionSourceKeys = resolveDerivedExpressionSourceKeys(expression, scopes, visitedSymbolIds);
+		if (!expressionSourceKeys) return null;
+		for (const expressionSourceKey of expressionSourceKeys) sourceKeys.add(expressionSourceKey);
+	}
+	return sourceKeys;
+};
+const resolveDerivedExpressionSourceKeys = (expression, scopes, visitedSymbolIds) => {
+	const candidate = unwrapExpression$3(expression);
+	if (isNodeOfType(candidate, "Literal")) return /* @__PURE__ */ new Set();
+	if (isNodeOfType(candidate, "Identifier")) {
+		if (scopes.isGlobalReference(candidate)) return /* @__PURE__ */ new Set();
+		const sourceSymbol = scopes.symbolFor(candidate);
+		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((sourceReference) => sourceReference.flag === "read") && !visitedSymbolIds.has(sourceSymbol.id)) {
+			visitedSymbolIds.add(sourceSymbol.id);
+			const sourceKeys = resolveDerivedExpressionSourceKeys(sourceSymbol.initializer, scopes, visitedSymbolIds);
+			visitedSymbolIds.delete(sourceSymbol.id);
+			if (sourceKeys) return sourceKeys;
+		}
+		return new Set([sourceSymbol.name]);
+	}
+	if (isNodeOfType(candidate, "MemberExpression")) {
+		if (hasComputedMemberExpression(candidate)) return null;
+		const sourceKey = stringifyMemberChain(candidate);
+		const rootIdentifier = getMemberRootIdentifier(candidate);
+		const rootSymbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
+		if (!sourceKey || !rootSymbol) return null;
+		if (isOutsideAllFunctions(rootSymbol) || symbolHasStableValue(rootSymbol, scopes)) return /* @__PURE__ */ new Set();
+		return new Set([sourceKey]);
+	}
+	if (isNodeOfType(candidate, "BinaryExpression") || isNodeOfType(candidate, "LogicalExpression")) return mergeDerivedExpressionSourceKeys([candidate.left, candidate.right], scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator !== "delete") return resolveDerivedExpressionSourceKeys(candidate.argument, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "ConditionalExpression")) return mergeDerivedExpressionSourceKeys([
+		candidate.test,
+		candidate.consequent,
+		candidate.alternate
+	], scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "TemplateLiteral")) return mergeDerivedExpressionSourceKeys(candidate.expressions, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "NewExpression")) {
+		const callee = unwrapExpression$3(candidate.callee);
+		if (!isNodeOfType(callee, "Identifier") || callee.name !== "Error" || !scopes.isGlobalReference(callee)) return null;
+		const argumentsToAnalyze = [];
+		for (const argument of candidate.arguments) {
+			if (!isAstNode(argument) || isNodeOfType(argument, "SpreadElement")) return null;
+			argumentsToAnalyze.push(argument);
+		}
+		return mergeDerivedExpressionSourceKeys(argumentsToAnalyze, scopes, visitedSymbolIds);
+	}
+	return null;
+};
+const resolveWriteControlSourceKeys = (assignment, boundaryFunction, scopes) => {
+	const sourceKeys = /* @__PURE__ */ new Set();
+	let currentNode = assignment;
+	while (currentNode.parent && currentNode.parent !== boundaryFunction) {
+		const parentNode = currentNode.parent;
+		if (isNodeOfType(parentNode, "IfStatement")) {
+			if (parentNode.test === currentNode) return null;
+			const testSourceKeys = resolveDerivedExpressionSourceKeys(parentNode.test, scopes, /* @__PURE__ */ new Set());
+			if (!testSourceKeys) return null;
+			for (const testSourceKey of testSourceKeys) sourceKeys.add(testSourceKey);
+		} else if (!isNodeOfType(parentNode, "ExpressionStatement") && !isNodeOfType(parentNode, "BlockStatement")) return null;
+		currentNode = parentNode;
+	}
+	return currentNode.parent === boundaryFunction ? sourceKeys : null;
+};
+const isReadOnlyInitialStateUse = (referenceNode, scopes) => {
+	const referenceRoot = findTransparentExpressionRoot(referenceNode);
+	const callExpression = referenceRoot.parent;
+	return isNodeOfType(callExpression, "CallExpression") && callExpression.arguments.some((argument) => argument === referenceRoot) && isReactApiCall(callExpression, "useState", scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: true,
+		resolveNamedAliases: true
+	});
+};
+const resolveRenderDerivedMutableSourceKeys = (capturedReference, symbol, scopes) => {
+	if (symbol.kind !== "let" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
+	const boundaryFunction = findEnclosingFunction$1(symbol.bindingIdentifier);
+	if (!boundaryFunction) return null;
+	const capturingFunction = findEnclosingFunction$1(capturedReference.identifier);
+	if (!capturingFunction || capturingFunction === boundaryFunction) return null;
+	const sourceKeys = /* @__PURE__ */ new Set();
+	if (symbol.initializer) {
+		const initializerSourceKeys = resolveDerivedExpressionSourceKeys(symbol.initializer, scopes, new Set([symbol.id]));
+		if (!initializerSourceKeys) return null;
+		for (const initializerSourceKey of initializerSourceKeys) sourceKeys.add(initializerSourceKey);
+	}
+	let writeCount = 0;
+	for (const symbolReference of symbol.references) {
+		if (symbolReference.flag === "read") {
+			if (findEnclosingFunction$1(symbolReference.identifier) !== capturingFunction && !isReadOnlyInitialStateUse(symbolReference.identifier, scopes)) return null;
+			continue;
+		}
+		if (symbolReference.flag !== "write") return null;
+		const referenceRoot = findTransparentExpressionRoot(symbolReference.identifier);
+		const assignment = referenceRoot.parent;
+		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== referenceRoot || findEnclosingFunction$1(referenceRoot) !== boundaryFunction) return null;
+		const assignmentSourceKeys = resolveDerivedExpressionSourceKeys(assignment.right, scopes, new Set([symbol.id]));
+		const controlSourceKeys = resolveWriteControlSourceKeys(assignment, boundaryFunction, scopes);
+		if (!assignmentSourceKeys || !controlSourceKeys) return null;
+		for (const assignmentSourceKey of assignmentSourceKeys) sourceKeys.add(assignmentSourceKey);
+		for (const controlSourceKey of controlSourceKeys) sourceKeys.add(controlSourceKey);
+		writeCount += 1;
+	}
+	return writeCount > 0 && sourceKeys.size > 0 ? sourceKeys : null;
+};
 const isUseCallbackResultDep = (node, scopes) => {
 	const rootSymbol = getRootSymbol(node, scopes);
 	const initializer = rootSymbol?.initializer ? unwrapExpression$3(rootSymbol.initializer) : null;
@@ -17938,7 +18507,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (!isUsed) continue;
 				const reportNode = declaredKeyToReportNode.get(declaredKey) ?? depsArgument;
 				const rootSymbol = getRootSymbol(reportNode, context.scopes);
-				if (!rootSymbol || !hasDirectIdentifierDeclarator(rootSymbol) || !isUnstableInitializer(rootSymbol.initializer)) continue;
+				if (!rootSymbol || !hasDirectIdentifierDeclarator(rootSymbol) || symbolHasStableValue(rootSymbol, context.scopes) || !isUnstableInitializer(rootSymbol.initializer)) continue;
 				context.report({
 					node: reportNode,
 					message: buildUnstableDepMessage(hookName, declaredKey)
@@ -18254,7 +18823,7 @@ const flattenCalleeName = (callee) => {
 const PRAGMA = "React";
 const isReactFunctionCall = (node, expectedCall) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	if (getCalleeName$2(node) !== expectedCall) return false;
+	if (getCalleeName$1(node) !== expectedCall) return false;
 	if (isNodeOfType(node.callee, "MemberExpression")) {
 		const receiver = stripParenExpression(node.callee.object);
 		return isNodeOfType(receiver, "Identifier") && receiver.name === PRAGMA;
@@ -18563,8 +19132,8 @@ const hooksNoNanInDeps = defineRule({
 	severity: "warn",
 	recommendation: "Remove `NaN` (or `Number.NaN`) from the dependency array. If a value can be NaN at runtime, normalise it (`Number.isNaN(x) ? 0 : x`) before passing it.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, HOOKS_WITH_DEP_ARRAY)) return;
-		const depsIndex = getCalleeName$2(node) === "useImperativeHandle" ? 2 : 1;
+		if (!isReactHookCall(node, HOOKS_WITH_DEP_ARRAY, context.scopes)) return;
+		const depsIndex = isReactHookCall(node, "useImperativeHandle", context.scopes) ? 2 : 1;
 		const depsArgument = node.arguments[depsIndex];
 		if (!depsArgument || !isNodeOfType(depsArgument, "ArrayExpression")) return;
 		for (const element of depsArgument.elements) {
@@ -19735,7 +20304,7 @@ const isImportedSelectAtom = (callExpression) => {
 const isDeferredCallbackPosition$1 = (functionNode) => {
 	const parent = functionNode.parent;
 	if (isNodeOfType(parent, "CallExpression") && parent.arguments?.[0] === functionNode) {
-		const hookName = getCalleeName$2(parent);
+		const hookName = getCalleeName$1(parent);
 		if (hookName && MEMOIZING_HOOK_NAMES$1.has(hookName)) return true;
 		if (hookName && EFFECT_HOOK_NAMES$1.has(hookName) && Boolean(parent.arguments?.[1])) return true;
 	}
@@ -29806,7 +30375,7 @@ const DEFERRING_CALLEE_NAMES$1 = new Set([
 	"on",
 	"once"
 ]);
-const getCalleeName$1 = (callee) => {
+const getCalleeName = (callee) => {
 	if (!callee) return null;
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
 	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
@@ -29818,11 +30387,11 @@ const isDeferredCallbackPosition = (expression) => {
 	const parent = parentOf(expression);
 	if (!parent) return false;
 	if (isNodeOfType(parent, "CallExpression") && argumentsInclude(parent.arguments, expression)) {
-		const name = getCalleeName$1(parent.callee);
+		const name = getCalleeName(parent.callee);
 		if (name && DEFERRING_CALLEE_NAMES$1.has(name)) return true;
 	}
 	if (isNodeOfType(parent, "NewExpression") && argumentsInclude(parent.arguments, expression)) {
-		const name = getCalleeName$1(parent.callee);
+		const name = getCalleeName(parent.callee);
 		if (name && (name.endsWith("Observer") || name === "Promise")) return true;
 	}
 	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === expression && isNodeOfType(parent.left, "MemberExpression") && isNodeOfType(parent.left.property, "Identifier") && parent.left.property.name.startsWith("on")) return true;
@@ -30242,14 +30811,6 @@ const isHookCallee$1 = (analysis, node, hookName) => {
 	if (isNodeOfType(node, "MemberExpression")) return isReactNamespaceReceiver(analysis, node.object) && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
 	return false;
 };
-const isUseEffect = (node) => {
-	if (!node || !isNodeOfType(node, "CallExpression")) return false;
-	const callee = node.callee;
-	if (isNodeOfType(callee, "Identifier") && callee.name === "useEffect") return true;
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && receiver.name === "React" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useEffect";
-};
 const getEffectFn = (analysis, node) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	const fn = node.arguments?.[0];
@@ -30347,7 +30908,27 @@ const isRefCurrent = (ref) => {
 	if (!isNodeOfType(parent.property, "Identifier")) return false;
 	return parent.property.name === "current";
 };
-const isStateSetterCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isStateSetter(analysis, innerRef));
+const resolveStateSetterReference = (analysis, ref) => {
+	const visitedReferences = /* @__PURE__ */ new Set();
+	let currentReference = ref;
+	while (currentReference && !visitedReferences.has(currentReference)) {
+		if (isStateSetter(analysis, currentReference)) return currentReference;
+		visitedReferences.add(currentReference);
+		const definitions = currentReference.resolved?.defs ?? [];
+		if (definitions.length !== 1) return null;
+		const definitionNode = definitions[0].node;
+		if (!isNodeOfType(definitionNode, "VariableDeclarator")) return null;
+		if (!isNodeOfType(definitionNode.id, "Identifier")) return null;
+		const declaration = definitionNode.parent;
+		if (!isNodeOfType(declaration, "VariableDeclaration") || declaration.kind !== "const") return null;
+		if (!definitionNode.init) return null;
+		const initializer = stripParenExpression(definitionNode.init);
+		if (!isNodeOfType(initializer, "Identifier")) return null;
+		currentReference = getRef(analysis, initializer);
+	}
+	return null;
+};
+const isStateSetterCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => resolveStateSetterReference(analysis, innerRef) !== null);
 const isSyncStateSetterCall = (analysis, ref, effectFn) => isStateSetterCall(analysis, ref) && isSynchronous(ref.identifier, effectFn) && !resolvesToAsyncFunction(ref);
 const HANDLER_NAMED_METHOD_PATTERN = /^(on|handle)[A-Z]/;
 const SYNCHRONOUS_CALLBACK_ARGUMENT_INDEX_BY_METHOD = new Map([
@@ -30498,9 +31079,11 @@ const isPropCallbackInvocationRef = (analysis, ref, options = {}) => {
 };
 const isRefCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isRefCurrent(innerRef) || isRef(analysis, innerRef));
 const getUseStateDecl = (analysis, ref) => {
-	let node = getUpstreamRefs(analysis, ref).find((upRef) => isHookCallee$1(analysis, upRef.identifier, "useState"))?.identifier;
-	while (node && !isNodeOfType(node, "VariableDeclarator")) node = node.parent;
-	return node ?? null;
+	const definition = getUpstreamRefs(analysis, ref).find((upstreamReference) => isState(analysis, upstreamReference) || isStateSetter(analysis, upstreamReference))?.resolved?.defs.find((candidateDefinition) => {
+		const definitionNode = candidateDefinition.node;
+		return isNodeOfType(definitionNode, "VariableDeclarator") && isNodeOfType(definitionNode.init, "CallExpression") && isHookCallee$1(analysis, definitionNode.init.callee, "useState");
+	});
+	return definition ? definition.node : null;
 };
 const isCleanupReturnArgument = (analysis, node) => {
 	if (isFunctionLike$1(node)) return true;
@@ -31689,6 +32272,7 @@ const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFile
 			sourceReferences,
 			isDeferred: frame.isDeferred,
 			isRenderKnownCopy,
+			isSynchronousRenderValue: !frame.isDeferred && !valueEvidence.hasUnknownSource && !valueEvidence.hasDeferredIntroducedValue && !valueEvidence.readsExternalValue,
 			matchesStateInitializer: doesMatchStateInitializer,
 			resetsSourceState: false
 		});
@@ -31704,22 +32288,71 @@ const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFile
 	});
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/has-deferred-or-external-effect-work.ts
+const DEFERRED_MEMBER_NAMES = new Set([
+	"catch",
+	"finally",
+	"then"
+]);
+const hasDeferredOrExternalEffectWork = (analysis, effectNode, scopes) => {
+	const effectFunction = getEffectFn(analysis, effectNode);
+	if (!effectFunction) return false;
+	if (containsFetchCall(effectFunction, { stopAtFunctionBoundary: true })) return true;
+	const effectInvokedFunctions = collectEffectInvokedFunctions(effectFunction);
+	let didFindDeferredOrExternalWork = false;
+	walkAst(effectFunction, (child) => {
+		if (didFindDeferredOrExternalWork) return false;
+		if (child !== effectFunction && isFunctionLike$1(child) && !effectInvokedFunctions.has(child)) return false;
+		if (isNodeOfType(child, "AssignmentExpression")) {
+			const assignmentTarget = child.left;
+			if ((isNodeOfType(assignmentTarget, "MemberExpression") ? getStaticPropertyName(assignmentTarget) : null)?.startsWith("on") && isFunctionLike$1(child.right)) {
+				didFindDeferredOrExternalWork = true;
+				return false;
+			}
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (isSubscribeOrObserveCallExpression(child)) {
+			didFindDeferredOrExternalWork = true;
+			return false;
+		}
+		const localFunction = resolveExactLocalFunction(child.callee, scopes);
+		if (isFunctionLike$1(localFunction) && localFunction.async) {
+			didFindDeferredOrExternalWork = true;
+			return false;
+		}
+		const callee = child.callee;
+		if (isNodeOfType(callee, "Identifier") && TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES.has(callee.name)) {
+			didFindDeferredOrExternalWork = true;
+			return false;
+		}
+		const memberName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : null;
+		if (memberName && DEFERRED_MEMBER_NAMES.has(memberName)) {
+			didFindDeferredOrExternalWork = true;
+			return false;
+		}
+	});
+	return didFindDeferredOrExternalWork;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-adjust-state-on-prop-change.ts
 const noAdjustStateOnPropChange = defineRule({
 	id: "no-adjust-state-on-prop-change",
-	title: "State synced to a prop inside an effect",
+	title: "State adjusted after a prop changes",
 	severity: "warn",
 	tags: ["test-noise"],
-	recommendation: "Adjust the state inline during render with a `prev`-prop comparison (`if (prop !== prevProp) { setPrevProp(prop); setX(...); }`), or refactor to remove the duplicated state. Routing the adjustment through a useEffect forces an extra render with a stale UI between the two commits. See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes",
+	recommendation: "Remove the adjustment effect by deriving values during render, resetting the component with a key, or updating related state in the event that changes the prop. Avoid tracking the previous prop in more state, which preserves the duplication. See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes",
 	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
+		if (!isReactHookCall(node, "useEffect", context.scopes)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const dependencyReferences = getEffectDepsRefs(analysis, node);
 		if (!dependencyReferences) return;
 		if (!dependencyReferences.flatMap((reference) => isState(analysis, reference) ? [] : getUpstreamRefs(analysis, reference)).some((reference) => isProp(analysis, reference))) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
-			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
+		const facts = collectEffectStateWriteFacts(analysis, context, node, context.filename);
+		if (hasCleanup(analysis, node) || hasDeferredOrExternalEffectWork(analysis, node, context.scopes) || facts.some((fact) => fact.isDeferred)) return;
+		for (const fact of facts) {
+			if (!fact.isSynchronousRenderValue || fact.resetsSourceState) continue;
+			if (fact.sourceReferences.flatMap((reference) => getUpstreamRefs(analysis, reference)).some((reference) => isProp(analysis, reference))) continue;
 			context.report({
 				node: fact.callExpression,
 				message: "This effect adjusts state after a prop changes, so users briefly see the stale value."
@@ -33732,7 +34365,7 @@ const declarationBodyContainsHookCall = (symbol) => {
 	walkAst(componentFunction, (descendant) => {
 		if (didFindHookCall) return false;
 		if (!isNodeOfType(descendant, "CallExpression")) return;
-		const calleeName = getCalleeName$2(descendant);
+		const calleeName = getCalleeName$1(descendant);
 		if (calleeName && isReactHookName(calleeName)) {
 			didFindHookCall = true;
 			return false;
@@ -33757,7 +34390,7 @@ const isReturnedFromUseCallbackAdapter = (callNode) => {
 		if (isNodeOfType(parent, "ArrowFunctionExpression")) {
 			if (parent.body !== current) return false;
 			const grandparent = parent.parent;
-			return isNodeOfType(grandparent, "CallExpression") && getCalleeName$2(grandparent) === "useCallback" && grandparent.arguments.some((argumentNode) => argumentNode === parent);
+			return isNodeOfType(grandparent, "CallExpression") && getCalleeName$1(grandparent) === "useCallback" && grandparent.arguments.some((argumentNode) => argumentNode === parent);
 		}
 		if (!isNodeOfType(parent, "ConditionalExpression") && !isNodeOfType(parent, "LogicalExpression")) return false;
 		current = parent;
@@ -34439,7 +35072,7 @@ const noChainStateUpdates = defineRule({
 			if (!callExpr) continue;
 			if (!isReachableFromStateTrigger(callExpr)) continue;
 			if (!readsPostMountValueThroughLocals(callExpr, effectFn, { ignoreBareRefCurrent: true })) continue;
-			const declarator = getUseStateDeclarator(ref);
+			const declarator = getUseStateDeclarator(resolveStateSetterReference(analysis, ref) ?? ref);
 			if (declarator) domSyncedStateDeclarators.add(declarator);
 		}
 		for (const ref of effectFnRefs) {
@@ -34448,7 +35081,7 @@ const noChainStateUpdates = defineRule({
 			if (!callExpr) continue;
 			if (!isReachableFromStateTrigger(callExpr)) continue;
 			if (getArgsUpstreamRefs(analysis, ref).some((argRef) => isState(analysis, argRef))) continue;
-			const setterDeclarator = getUseStateDeclarator(ref);
+			const setterDeclarator = getUseStateDeclarator(resolveStateSetterReference(analysis, ref) ?? ref);
 			if (setterDeclarator && domSyncedStateDeclarators.has(setterDeclarator)) continue;
 			const isSelfTargeting = setterDeclarator !== null && stateDepDeclarators.has(setterDeclarator);
 			const setterArguments = isNodeOfType(callExpr, "CallExpression") ? callExpr.arguments ?? [] : [];
@@ -36289,7 +36922,7 @@ const noDerivedState = defineRule({
 				for (const fact of collectRenderStateWriteFacts(analysis, componentBody, context.filename)) reportStateWrite(fact.callExpression, fact.stateDeclarator);
 			} }).visitors,
 			CallExpression(node) {
-				if (!isUseEffect(node)) return;
+				if (!isReactHookCall(node, "useEffect", context.scopes)) return;
 				const analysis = getProgramAnalysis(node);
 				if (!analysis) return;
 				for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
@@ -36309,7 +36942,7 @@ const noDerivedStateEffect = defineRule({
 	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;
+		if (!isReactHookCall(node, EFFECT_HOOK_NAMES$1, context.scopes)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		if (!collectEffectStateWriteFacts(analysis, context, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
@@ -36432,7 +37065,7 @@ const getEnclosingEffectHookCallback = (node, componentFunction) => {
 		if (isFunctionLike$1(cursor)) {
 			const parent = cursor.parent ?? null;
 			if (parent && isNodeOfType(parent, "CallExpression")) {
-				const calleeName = getCalleeName$2(parent);
+				const calleeName = getCalleeName$1(parent);
 				if (calleeName !== null && EFFECT_HOOK_NAME_PATTERN.test(calleeName) && (parent.arguments ?? []).some((argument) => argument === cursor)) return cursor;
 			}
 		}
@@ -36503,7 +37136,7 @@ const isNonHandlerHookCallback = (functionNode) => {
 	const parent = functionNode.parent ?? null;
 	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
 	if (!(parent.arguments ?? []).some((argument) => argument === functionNode)) return false;
-	const calleeName = getCalleeName$2(parent);
+	const calleeName = getCalleeName$1(parent);
 	return calleeName !== null && isReactHookName(calleeName) && calleeName !== "useCallback";
 };
 const isHandlerShapedReseed = (setterCall, componentFunction) => {
@@ -36585,7 +37218,7 @@ const noDerivedUseState = defineRule({
 		return {
 			...propStackTracker.visitors,
 			CallExpression(node) {
-				if (!isHookCall$2(node, "useState") || !node.arguments?.length) return;
+				if (!isReactHookCall(node, "useState", context.scopes) || !node.arguments?.length) return;
 				const seed = unwrapInitializerSeed(node.arguments[0]);
 				const reportStalePropCopy = (propName) => {
 					if (isIntentionalSnapshotState(node)) return;
@@ -37261,7 +37894,7 @@ const noDirectMutationState = defineRule({
 const isSetterIdentifier = (name) => SETTER_PATTERN.test(name);
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/collect-use-state-bindings.ts
-const collectUseStateBindings = (componentBody) => {
+const collectUseStateBindings = (componentBody, scopes) => {
 	const bindings = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return bindings;
 	for (const statement of componentBody.body ?? []) {
@@ -37274,7 +37907,7 @@ const collectUseStateBindings = (componentBody) => {
 			const setterElement = elements[1];
 			if (!isNodeOfType(valueElement, "Identifier") || !isNodeOfType(setterElement, "Identifier") || !isSetterIdentifier(setterElement.name)) continue;
 			if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-			if (!isHookCall$2(declarator.init, "useState")) continue;
+			if (!isReactHookCall(declarator.init, "useState", scopes)) continue;
 			bindings.push({
 				valueName: valueElement.name,
 				setterName: setterElement.name,
@@ -37441,7 +38074,7 @@ const noDirectStateMutation = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = collectUseStateBindings(componentBody);
+			const bindings = collectUseStateBindings(componentBody, context.scopes);
 			if (bindings.length === 0) return;
 			const stateValueToSetter = new Map(bindings.map((binding) => [binding.valueName, binding.setterName]));
 			const setterValueObservations = collectSetterValueObservations(componentBody, new Set(bindings.map((binding) => binding.setterName)));
@@ -38001,25 +38634,31 @@ const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSub
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-effect-chain.ts
-const findTopLevelEffectCalls = (componentBody) => {
+const findTopLevelEffectCalls = (componentBody, scopes) => {
 	const effectCalls = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return effectCalls;
 	for (const statement of componentBody.body ?? []) {
 		if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 		const expression = unwrapDiscardedExpression(statement);
 		if (!isNodeOfType(expression, "CallExpression")) continue;
-		if (!isHookCall$2(expression, EFFECT_HOOK_NAMES$1)) continue;
+		if (!isReactHookCall(expression, EFFECT_HOOK_NAMES$1, scopes)) continue;
 		effectCalls.push(expression);
 	}
 	return effectCalls;
 };
-const collectDepIdentifierNames = (effectNode) => {
-	const depNames = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(effectNode, "CallExpression")) return depNames;
+const collectDependencyStateSymbolIds = (effectNode, stateSymbolIds, scopes) => {
+	const dependencyStateSymbolIds = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(effectNode, "CallExpression")) return dependencyStateSymbolIds;
 	const depsNode = effectNode.arguments?.[1];
-	if (!isNodeOfType(depsNode, "ArrayExpression")) return depNames;
-	for (const element of depsNode.elements ?? []) if (isNodeOfType(element, "Identifier")) depNames.add(element.name);
-	return depNames;
+	if (!isNodeOfType(depsNode, "ArrayExpression")) return dependencyStateSymbolIds;
+	for (const element of depsNode.elements ?? []) {
+		if (!element || isNodeOfType(element, "SpreadElement")) continue;
+		const rootIdentifier = getRootIdentifier$1(element);
+		if (!isNodeOfType(rootIdentifier, "Identifier")) continue;
+		const symbol = resolveConstIdentifierAlias(rootIdentifier, scopes, true);
+		if (symbol && stateSymbolIds.has(symbol.id)) dependencyStateSymbolIds.add(symbol.id);
+	}
+	return dependencyStateSymbolIds;
 };
 const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
 	const analysisFunctions = new Set([effectCallback]);
@@ -38125,12 +38764,13 @@ const readStaticSetterValue = (setterCall, scopes) => {
 	if (updater) return readStaticUpdaterReturnValue(updater, scopes);
 	return readStaticEffectValue(argument, scopes, null, null);
 };
-const collectStateWritesInEffect = (analysisFunctions, setterToStateName, scopes) => {
+const collectStateWritesInEffect = (analysisFunctions, setterSymbolIdToStateName, scopes) => {
 	const stateWrites = /* @__PURE__ */ new Map();
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
-		const stateName = setterToStateName.get(child.callee.name);
+		const setterSymbol = resolveConstIdentifierAlias(child.callee, scopes, true);
+		const stateName = setterSymbol ? setterSymbolIdToStateName.get(setterSymbol.id) : void 0;
 		if (!stateName) return;
 		const writeInfo = stateWrites.get(stateName) ?? {
 			values: /* @__PURE__ */ new Set(),
@@ -38216,11 +38856,12 @@ const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
 	"keys",
 	"values"
 ]);
-const isFunctionShapedReturn = (returnedValue, setterToStateName, isExplicitReturnStatement) => {
+const isFunctionShapedReturn = (returnedValue, setterToStateName, setterSymbolIdToStateName, scopes, isExplicitReturnStatement) => {
 	if (isNodeOfType(returnedValue, "ArrowFunctionExpression") || isNodeOfType(returnedValue, "FunctionExpression")) return true;
 	if (isNodeOfType(returnedValue, "CallExpression")) {
 		if (isNodeOfType(returnedValue.callee, "Identifier")) {
-			if (setterToStateName.has(returnedValue.callee.name)) return false;
+			const setterSymbol = resolveConstIdentifierAlias(returnedValue.callee, scopes, true);
+			if (setterToStateName.has(returnedValue.callee.name) || setterSymbol && setterSymbolIdToStateName.has(setterSymbol.id)) return false;
 			if (isSetterIdentifier(returnedValue.callee.name)) return true;
 		}
 		return isCleanupReturn(returnedValue, EMPTY_CLEANUP_NAME_SET, EMPTY_CLEANUP_NAME_SET, { allowOpaqueReturn: isExplicitReturnStatement });
@@ -38244,7 +38885,7 @@ const collectStorageHookSetterNames = (componentBody) => {
 		for (const declarator of statement.declarations ?? []) {
 			if (!isNodeOfType(declarator.id, "ArrayPattern")) continue;
 			if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-			const calleeName = getCalleeName$2(declarator.init);
+			const calleeName = getCalleeName$1(declarator.init);
 			if (!calleeName || !STORAGE_HOOK_PATTERN.test(calleeName)) continue;
 			for (const element of declarator.id.elements ?? []) if (isNodeOfType(element, "Identifier") && isSetterIdentifier(element.name)) setterNames.add(element.name);
 		}
@@ -38387,11 +39028,11 @@ const isExternalSyncNode = (node) => {
 	const receiverRootName = getRootIdentifierName(node.callee.object);
 	return receiverRootName !== null && EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS.has(receiverRootName);
 };
-const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, scopes, allowCommittedDomSync) => {
+const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, setterSymbolIdToStateName, scopes, allowCommittedDomSync) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
 	if (!isNodeOfType(effectCallback.body, "BlockStatement")) {
-		if (isFunctionShapedReturn(effectCallback.body, setterToStateName, false)) return true;
-	} else for (const statement of effectCallback.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument && isFunctionShapedReturn(statement.argument, setterToStateName, true)) return true;
+		if (isFunctionShapedReturn(effectCallback.body, setterToStateName, setterSymbolIdToStateName, scopes, false)) return true;
+	} else for (const statement of effectCallback.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument && isFunctionShapedReturn(statement.argument, setterToStateName, setterSymbolIdToStateName, scopes, true)) return true;
 	let didFindExternalCall = false;
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (isExternalSyncNode(child) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
@@ -38407,10 +39048,11 @@ const noEffectChain = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const useStateBindings = collectUseStateBindings(componentBody);
+			const useStateBindings = collectUseStateBindings(componentBody, context.scopes);
 			if (useStateBindings.length === 0) return;
 			const setterToStateName = /* @__PURE__ */ new Map();
 			const stateSymbolIds = /* @__PURE__ */ new Map();
+			const setterSymbolIdToStateName = /* @__PURE__ */ new Map();
 			for (const binding of useStateBindings) {
 				setterToStateName.set(binding.setterName, binding.valueName);
 				if (!isNodeOfType(binding.declarator.id, "ArrayPattern")) continue;
@@ -38419,21 +39061,27 @@ const noEffectChain = defineRule({
 					const stateSymbol = context.scopes.symbolFor(stateIdentifier);
 					if (stateSymbol) stateSymbolIds.set(binding.valueName, stateSymbol.id);
 				}
+				const setterIdentifier = binding.declarator.id.elements[1];
+				if (isNodeOfType(setterIdentifier, "Identifier")) {
+					const setterSymbol = context.scopes.symbolFor(setterIdentifier);
+					if (setterSymbol) setterSymbolIdToStateName.set(setterSymbol.id, binding.valueName);
+				}
 			}
 			const storageSetterNames = collectStorageHookSetterNames(componentBody);
+			const stateSymbolIdSet = new Set(stateSymbolIds.values());
 			const effectInfos = [];
-			for (const effectCall of findTopLevelEffectCalls(componentBody)) {
+			for (const effectCall of findTopLevelEffectCalls(componentBody, context.scopes)) {
 				const callback = getEffectCallback(effectCall, context.scopes);
 				if (!callback || !isFunctionLike$1(callback) || callback.async) continue;
 				const analysisFunctions = collectSynchronouslyInvokedFunctions(callback, context.scopes);
-				const stateWrites = collectStateWritesInEffect(analysisFunctions, setterToStateName, context.scopes);
+				const stateWrites = collectStateWritesInEffect(analysisFunctions, setterSymbolIdToStateName, context.scopes);
 				const writtenStateNames = new Set(stateWrites.keys());
 				effectInfos.push({
 					node: effectCall,
-					depNames: collectDepIdentifierNames(effectCall),
+					dependencyStateSymbolIds: collectDependencyStateSymbolIds(effectCall, stateSymbolIdSet, context.scopes),
 					stateWrites,
 					analysisFunctions,
-					isExternalSync: isExternalSyncEffect(callback, analysisFunctions, setterToStateName, context.scopes, writtenStateNames.size === 0) || callsStorageHookSetter(analysisFunctions, storageSetterNames) || writtenStateNames.size === 0 && callsOpaqueExternalSetter(analysisFunctions, setterToStateName)
+					isExternalSync: isExternalSyncEffect(callback, analysisFunctions, setterToStateName, setterSymbolIdToStateName, context.scopes, writtenStateNames.size === 0) || callsStorageHookSetter(analysisFunctions, storageSetterNames) || writtenStateNames.size === 0 && callsOpaqueExternalSetter(analysisFunctions, setterToStateName)
 				});
 			}
 			if (effectInfos.length < 2) return;
@@ -38444,10 +39092,11 @@ const noEffectChain = defineRule({
 				for (const readerEffect of effectInfos) {
 					if (readerEffect === writerEffect) continue;
 					if (readerEffect.isExternalSync) continue;
-					if (readerEffect.depNames.size === 0) continue;
+					if (readerEffect.dependencyStateSymbolIds.size === 0) continue;
 					let chainedStateName = null;
 					for (const [writtenName, writeInfo] of writerEffect.stateWrites) {
-						if (!readerEffect.depNames.has(writtenName)) continue;
+						const writtenStateSymbolId = stateSymbolIds.get(writtenName);
+						if (writtenStateSymbolId === void 0 || !readerEffect.dependencyStateSymbolIds.has(writtenStateSymbolId)) continue;
 						if (!canStateWriteReachReaderWork(writeInfo, readerEffect, stateSymbolIds.get(writtenName) ?? null, context.scopes)) continue;
 						chainedStateName = writtenName;
 						break;
@@ -38724,7 +39373,7 @@ const noEffectEventHandler = defineRule({
 		return {
 			...propStackTracker.visitors,
 			CallExpression(node) {
-				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1) || (node.arguments?.length ?? 0) < 2) return;
+				if (!isReactHookCall(node, EFFECT_HOOK_NAMES$1, context.scopes) || (node.arguments?.length ?? 0) < 2) return;
 				const callback = getEffectCallback(node);
 				if (!callback) return;
 				const analysis = getProgramAnalysis(node);
@@ -38844,14 +39493,14 @@ const noEffectEventInDeps = defineRule({
 			if (!isNodeOfType(declaratorNode.id, "Identifier")) return;
 			const initializer = declaratorNode.init;
 			if (!initializer || !isNodeOfType(initializer, "CallExpression")) return;
-			if (!isHookCall$2(initializer, "useEffectEvent")) return;
+			if (!isReactHookCall(initializer, "useEffectEvent", context.scopes)) return;
 			if (isNonReactEffectEventCallee(initializer.callee, declaratorNode, context.scopes)) return;
 			componentBindings.addBindingToCurrentFrame(declaratorNode.id.name);
 		} });
 		return {
 			...componentBindings.visitors,
 			CallExpression(node) {
-				if (!isHookCall$2(node, HOOKS_WITH_DEPS) || node.arguments.length < 2) return;
+				if (!isReactHookCall(node, HOOKS_WITH_DEPS, context.scopes) || node.arguments.length < 2) return;
 				if (!componentBindings.isInsideComponent()) return;
 				const depsNode = node.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) return;
@@ -38908,7 +39557,7 @@ const noEffectWithFreshDeps = defineRule({
 			node: finding.reportNode,
 			message: `A dependency inside this custom Hook changes every render because \`${finding.bindingName}\` is a new ${finding.kind} built fresh each time.`
 		});
-		if (!isHookCall$2(node, HOOKS_WITH_DEPS)) return;
+		if (!isReactHookCall(node, HOOKS_WITH_DEPS, context.scopes)) return;
 		const args = node.arguments ?? [];
 		if (args.length < 2) return;
 		const depsNode = args[1];
@@ -39169,7 +39818,7 @@ const noEventHandler = defineRule({
 	severity: "warn",
 	recommendation: "Run the side effect in the event handler that triggers it, instead of watching its state from a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#sharing-logic-between-event-handlers",
 	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
+		if (!isReactHookCall(node, "useEffect", context.scopes)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis || hasCleanup(analysis, node)) return;
 		const frames = collectBoundedEffectExecutionFrames(analysis, node);
@@ -39631,25 +40280,25 @@ const addDeclarationBindings = (statement, scope) => {
 	}
 	if (isNodeOfType(statement, "FunctionDeclaration") && statement.id) addPatternBindings(statement.id, scope);
 };
-const collectRenderReachableNamesFromStatements = (statements, names, scope, eventHandlerReferenceNames = /* @__PURE__ */ new Set()) => {
+const collectRenderReachableNamesFromStatements = (statements, names, scope, scopes, eventHandlerReferenceNames = /* @__PURE__ */ new Set()) => {
 	let hasReturn = false;
-	for (const statement of statements ?? []) if (collectRenderReachableNamesFromStatement(statement, names, scope, eventHandlerReferenceNames)) hasReturn = true;
+	for (const statement of statements ?? []) if (collectRenderReachableNamesFromStatement(statement, names, scope, scopes, eventHandlerReferenceNames)) hasReturn = true;
 	else addDeclarationBindings(statement, scope);
 	return hasReturn;
 };
-const collectRenderReachableNamesFromStatement = (statement, names, scope, eventHandlerReferenceNames) => {
+const collectRenderReachableNamesFromStatement = (statement, names, scope, scopes, eventHandlerReferenceNames) => {
 	if (isNodeOfType(statement, "ReturnStatement")) {
 		if (statement.argument) addNames(names, collectScopedReferenceNames(statement.argument, scope, eventHandlerReferenceNames));
 		return true;
 	}
-	if (isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "CallExpression") && isNodeOfType(statement.expression.callee, "Identifier") && isReactHookName(statement.expression.callee.name) && !EFFECT_HOOK_NAMES$1.has(statement.expression.callee.name)) {
+	if (isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "CallExpression") && (isNodeOfType(statement.expression.callee, "Identifier") && isReactHookName(statement.expression.callee.name) || isReactHookCall(statement.expression, BUILTIN_HOOK_NAMES, scopes)) && !isReactHookCall(statement.expression, EFFECT_HOOK_NAMES$1, scopes)) {
 		for (const argument of statement.expression.arguments ?? []) addNames(names, collectScopedReferenceNames(argument, scope, eventHandlerReferenceNames));
 		return false;
 	}
-	if (isNodeOfType(statement, "BlockStatement")) return collectRenderReachableNamesFromStatements(statement.body, names, createBlockBindingScope(scope), eventHandlerReferenceNames);
+	if (isNodeOfType(statement, "BlockStatement")) return collectRenderReachableNamesFromStatements(statement.body, names, createBlockBindingScope(scope), scopes, eventHandlerReferenceNames);
 	if (isNodeOfType(statement, "IfStatement")) {
-		const consequentHasReturn = collectRenderReachableNamesFromStatement(statement.consequent, names, scope, eventHandlerReferenceNames);
-		const alternateHasReturn = statement.alternate ? collectRenderReachableNamesFromStatement(statement.alternate, names, scope, eventHandlerReferenceNames) : false;
+		const consequentHasReturn = collectRenderReachableNamesFromStatement(statement.consequent, names, scope, scopes, eventHandlerReferenceNames);
+		const alternateHasReturn = statement.alternate ? collectRenderReachableNamesFromStatement(statement.alternate, names, scope, scopes, eventHandlerReferenceNames) : false;
 		if (consequentHasReturn || alternateHasReturn) addNames(names, collectScopedReferenceNames(statement.test, scope, eventHandlerReferenceNames));
 		return consequentHasReturn || alternateHasReturn;
 	}
@@ -39657,7 +40306,7 @@ const collectRenderReachableNamesFromStatement = (statement, names, scope, event
 		let hasReturn = false;
 		for (const switchCase of statement.cases ?? []) {
 			const caseScope = createBlockBindingScope(scope);
-			if (!collectRenderReachableNamesFromStatements(switchCase.consequent, names, caseScope, eventHandlerReferenceNames)) continue;
+			if (!collectRenderReachableNamesFromStatements(switchCase.consequent, names, caseScope, scopes, eventHandlerReferenceNames)) continue;
 			hasReturn = true;
 			if (switchCase.test) addNames(names, collectScopedReferenceNames(switchCase.test, scope, eventHandlerReferenceNames));
 		}
@@ -39665,25 +40314,25 @@ const collectRenderReachableNamesFromStatement = (statement, names, scope, event
 		return hasReturn;
 	}
 	if (isNodeOfType(statement, "TryStatement")) {
-		const blockHasReturn = collectRenderReachableNamesFromStatement(statement.block, names, scope, eventHandlerReferenceNames);
-		const handlerHasReturn = statement.handler ? collectRenderReachableNamesFromStatement(statement.handler, names, scope, eventHandlerReferenceNames) : false;
-		const finalizerHasReturn = statement.finalizer ? collectRenderReachableNamesFromStatement(statement.finalizer, names, scope, eventHandlerReferenceNames) : false;
+		const blockHasReturn = collectRenderReachableNamesFromStatement(statement.block, names, scope, scopes, eventHandlerReferenceNames);
+		const handlerHasReturn = statement.handler ? collectRenderReachableNamesFromStatement(statement.handler, names, scope, scopes, eventHandlerReferenceNames) : false;
+		const finalizerHasReturn = statement.finalizer ? collectRenderReachableNamesFromStatement(statement.finalizer, names, scope, scopes, eventHandlerReferenceNames) : false;
 		return blockHasReturn || handlerHasReturn || finalizerHasReturn;
 	}
 	if (isNodeOfType(statement, "CatchClause")) {
 		const catchScope = createBlockBindingScope(scope);
 		addPatternBindings(statement.param, catchScope);
-		return collectRenderReachableNamesFromStatement(statement.body, names, catchScope, eventHandlerReferenceNames);
+		return collectRenderReachableNamesFromStatement(statement.body, names, catchScope, scopes, eventHandlerReferenceNames);
 	}
 	if (isNodeOfType(statement, "WhileStatement") || isNodeOfType(statement, "DoWhileStatement")) {
-		const bodyHasReturn = collectRenderReachableNamesFromStatement(statement.body, names, scope, eventHandlerReferenceNames);
+		const bodyHasReturn = collectRenderReachableNamesFromStatement(statement.body, names, scope, scopes, eventHandlerReferenceNames);
 		if (bodyHasReturn) addNames(names, collectScopedReferenceNames(statement.test, scope, eventHandlerReferenceNames));
 		return bodyHasReturn;
 	}
 	if (isNodeOfType(statement, "ForStatement")) {
 		const loopScope = createBlockBindingScope(scope);
 		if (statement.init) addDeclarationBindings(statement.init, loopScope);
-		if (!collectRenderReachableNamesFromStatement(statement.body, names, loopScope, eventHandlerReferenceNames)) return false;
+		if (!collectRenderReachableNamesFromStatement(statement.body, names, loopScope, scopes, eventHandlerReferenceNames)) return false;
 		if (statement.init) addNames(names, collectScopedReferenceNames(statement.init, loopScope, eventHandlerReferenceNames));
 		if (statement.test) addNames(names, collectScopedReferenceNames(statement.test, loopScope, eventHandlerReferenceNames));
 		if (statement.update) addNames(names, collectScopedReferenceNames(statement.update, loopScope, eventHandlerReferenceNames));
@@ -39693,22 +40342,22 @@ const collectRenderReachableNamesFromStatement = (statement, names, scope, event
 		const rightNames = collectScopedReferenceNames(statement.right, scope, eventHandlerReferenceNames);
 		const loopScope = createBlockBindingScope(scope);
 		if (isNodeOfType(statement.left, "VariableDeclaration")) addDeclarationBindings(statement.left, loopScope);
-		if (!collectRenderReachableNamesFromStatement(statement.body, names, loopScope, eventHandlerReferenceNames)) return false;
+		if (!collectRenderReachableNamesFromStatement(statement.body, names, loopScope, scopes, eventHandlerReferenceNames)) return false;
 		addNames(names, rightNames);
 		return true;
 	}
-	if (isNodeOfType(statement, "LabeledStatement")) return collectRenderReachableNamesFromStatement(statement.body, names, scope, eventHandlerReferenceNames);
+	if (isNodeOfType(statement, "LabeledStatement")) return collectRenderReachableNamesFromStatement(statement.body, names, scope, scopes, eventHandlerReferenceNames);
 	if (isNodeOfType(statement, "WithStatement")) {
-		const bodyHasReturn = collectRenderReachableNamesFromStatement(statement.body, names, scope, eventHandlerReferenceNames);
+		const bodyHasReturn = collectRenderReachableNamesFromStatement(statement.body, names, scope, scopes, eventHandlerReferenceNames);
 		if (bodyHasReturn) addNames(names, collectScopedReferenceNames(statement.object, scope, eventHandlerReferenceNames));
 		return bodyHasReturn;
 	}
 	return false;
 };
-const collectRenderReachableNames = (componentBody, eventHandlerReferenceNames = /* @__PURE__ */ new Set()) => {
+const collectRenderReachableNames = (componentBody, scopes, eventHandlerReferenceNames = /* @__PURE__ */ new Set()) => {
 	const names = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(componentBody, "BlockStatement")) return names;
-	collectRenderReachableNamesFromStatements(componentBody.body, names, createComponentBindingScope(), eventHandlerReferenceNames);
+	collectRenderReachableNamesFromStatements(componentBody.body, names, createComponentBindingScope(), scopes, eventHandlerReferenceNames);
 	return names;
 };
 //#endregion
@@ -39731,42 +40380,36 @@ const expandTransitiveDependencies = (seedNames, dependencyGraph) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/collect-function-like-local-names.ts
-const isUseCallbackCall = (node) => isNodeOfType(node, "CallExpression") && getCalleeName(node.callee) === "useCallback";
-const getCalleeName = (node) => {
-	if (isNodeOfType(node, "Identifier")) return node.name;
-	if (isNodeOfType(node, "MemberExpression")) return getStaticMemberPropertyName(node);
-	return null;
-};
-const isFunctionLikeReference = (node, functionLikeLocalNames, scope) => {
-	if (isInlineFunctionExpression(node) || isUseCallbackCall(node)) return true;
+const isFunctionLikeReference = (node, functionLikeLocalNames, scope, scopes) => {
+	if (isInlineFunctionExpression(node) || isReactHookCall(node, "useCallback", scopes)) return true;
 	if (isNodeOfType(node, "Identifier")) return functionLikeLocalNames.has(resolveBindingName(scope, node.name));
 	const memberReferenceName = getStaticMemberReferenceName(node, (name) => resolveBindingName(scope, name));
 	return Boolean(memberReferenceName && functionLikeLocalNames.has(memberReferenceName));
 };
-const addObjectPropertyFunctionNames = (objectBindingName, node, functionLikeLocalNames, scope) => {
+const addObjectPropertyFunctionNames = (objectBindingName, node, functionLikeLocalNames, scope, scopes) => {
 	if (!isNodeOfType(node, "ObjectExpression")) return;
 	for (const property of node.properties ?? []) {
 		if (!isNodeOfType(property, "Property")) continue;
 		const propertyName = getStaticPropertyKeyName(property, { stringifyNonStringLiterals: true });
 		if (!propertyName) continue;
-		if (!isFunctionLikeReference(property.value, functionLikeLocalNames, scope)) continue;
+		if (!isFunctionLikeReference(property.value, functionLikeLocalNames, scope, scopes)) continue;
 		functionLikeLocalNames.add(`${objectBindingName}.${propertyName}`);
 	}
 };
-const addVariableDeclarationFunctionNames = (statement, functionLikeLocalNames, scope) => {
+const addVariableDeclarationFunctionNames = (statement, functionLikeLocalNames, scope, scopes) => {
 	if (!isNodeOfType(statement, "VariableDeclaration")) return;
 	const declarationScope = getVariableDeclarationScope(statement, scope);
 	for (const declarator of statement.declarations ?? []) {
 		const declaredBindingNames = addPatternBindings(declarator.id, declarationScope);
 		if (!declarator.init) continue;
-		const isFunctionReference = isFunctionLikeReference(declarator.init, functionLikeLocalNames, scope);
+		const isFunctionReference = isFunctionLikeReference(declarator.init, functionLikeLocalNames, scope, scopes);
 		for (const declaredBindingName of declaredBindingNames) {
 			if (isFunctionReference) functionLikeLocalNames.add(declaredBindingName);
-			addObjectPropertyFunctionNames(declaredBindingName, declarator.init, functionLikeLocalNames, scope);
+			addObjectPropertyFunctionNames(declaredBindingName, declarator.init, functionLikeLocalNames, scope, scopes);
 		}
 	}
 };
-const collectStatementFunctionNames = (statement, functionLikeLocalNames, scope) => {
+const collectStatementFunctionNames = (statement, functionLikeLocalNames, scope, scopes) => {
 	if (isNodeOfType(statement, "FunctionDeclaration")) {
 		if (statement.id) {
 			const declaredBindingNames = addPatternBindings(statement.id, scope);
@@ -39775,61 +40418,61 @@ const collectStatementFunctionNames = (statement, functionLikeLocalNames, scope)
 		return;
 	}
 	if (isNodeOfType(statement, "VariableDeclaration")) {
-		addVariableDeclarationFunctionNames(statement, functionLikeLocalNames, scope);
+		addVariableDeclarationFunctionNames(statement, functionLikeLocalNames, scope, scopes);
 		return;
 	}
 	if (isNodeOfType(statement, "BlockStatement")) {
-		collectStatementListFunctionNames(statement.body, functionLikeLocalNames, createBlockBindingScope(scope));
+		collectStatementListFunctionNames(statement.body, functionLikeLocalNames, createBlockBindingScope(scope), scopes);
 		return;
 	}
 	if (isNodeOfType(statement, "IfStatement")) {
-		collectStatementFunctionNames(statement.consequent, functionLikeLocalNames, scope);
-		if (statement.alternate) collectStatementFunctionNames(statement.alternate, functionLikeLocalNames, scope);
+		collectStatementFunctionNames(statement.consequent, functionLikeLocalNames, scope, scopes);
+		if (statement.alternate) collectStatementFunctionNames(statement.alternate, functionLikeLocalNames, scope, scopes);
 		return;
 	}
 	if (isNodeOfType(statement, "SwitchStatement")) {
-		for (const switchCase of statement.cases ?? []) collectStatementListFunctionNames(switchCase.consequent, functionLikeLocalNames, createBlockBindingScope(scope));
+		for (const switchCase of statement.cases ?? []) collectStatementListFunctionNames(switchCase.consequent, functionLikeLocalNames, createBlockBindingScope(scope), scopes);
 		return;
 	}
 	if (isNodeOfType(statement, "TryStatement")) {
-		collectStatementFunctionNames(statement.block, functionLikeLocalNames, scope);
+		collectStatementFunctionNames(statement.block, functionLikeLocalNames, scope, scopes);
 		if (statement.handler) {
 			const catchScope = createBlockBindingScope(scope);
 			addPatternBindings(statement.handler.param, catchScope);
-			collectStatementFunctionNames(statement.handler.body, functionLikeLocalNames, catchScope);
+			collectStatementFunctionNames(statement.handler.body, functionLikeLocalNames, catchScope, scopes);
 		}
-		if (statement.finalizer) collectStatementFunctionNames(statement.finalizer, functionLikeLocalNames, scope);
+		if (statement.finalizer) collectStatementFunctionNames(statement.finalizer, functionLikeLocalNames, scope, scopes);
 		return;
 	}
 	if (isNodeOfType(statement, "ForStatement")) {
 		const loopScope = createBlockBindingScope(scope);
-		if (statement.init && isNodeOfType(statement.init, "VariableDeclaration")) addVariableDeclarationFunctionNames(statement.init, functionLikeLocalNames, loopScope);
-		collectStatementFunctionNames(statement.body, functionLikeLocalNames, loopScope);
+		if (statement.init && isNodeOfType(statement.init, "VariableDeclaration")) addVariableDeclarationFunctionNames(statement.init, functionLikeLocalNames, loopScope, scopes);
+		collectStatementFunctionNames(statement.body, functionLikeLocalNames, loopScope, scopes);
 		return;
 	}
 	if (isNodeOfType(statement, "ForInStatement") || isNodeOfType(statement, "ForOfStatement")) {
 		const loopScope = createBlockBindingScope(scope);
-		if (isNodeOfType(statement.left, "VariableDeclaration")) addVariableDeclarationFunctionNames(statement.left, functionLikeLocalNames, loopScope);
+		if (isNodeOfType(statement.left, "VariableDeclaration")) addVariableDeclarationFunctionNames(statement.left, functionLikeLocalNames, loopScope, scopes);
 		else addPatternBindings(statement.left, loopScope);
-		collectStatementFunctionNames(statement.body, functionLikeLocalNames, loopScope);
+		collectStatementFunctionNames(statement.body, functionLikeLocalNames, loopScope, scopes);
 		return;
 	}
 	if (isNodeOfType(statement, "WhileStatement") || isNodeOfType(statement, "DoWhileStatement")) {
-		collectStatementFunctionNames(statement.body, functionLikeLocalNames, scope);
+		collectStatementFunctionNames(statement.body, functionLikeLocalNames, scope, scopes);
 		return;
 	}
-	if (isNodeOfType(statement, "LabeledStatement")) collectStatementFunctionNames(statement.body, functionLikeLocalNames, scope);
+	if (isNodeOfType(statement, "LabeledStatement")) collectStatementFunctionNames(statement.body, functionLikeLocalNames, scope, scopes);
 };
-const collectStatementListFunctionNames = (statements, functionLikeLocalNames, scope) => {
-	for (const statement of statements ?? []) collectStatementFunctionNames(statement, functionLikeLocalNames, scope);
+const collectStatementListFunctionNames = (statements, functionLikeLocalNames, scope, scopes) => {
+	for (const statement of statements ?? []) collectStatementFunctionNames(statement, functionLikeLocalNames, scope, scopes);
 };
-const collectFunctionLikeLocalNames = (componentBody) => {
+const collectFunctionLikeLocalNames = (componentBody, scopes) => {
 	const functionLikeLocalNames = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(componentBody, "BlockStatement")) return functionLikeLocalNames;
 	let previousSize = -1;
 	while (previousSize !== functionLikeLocalNames.size) {
 		previousSize = functionLikeLocalNames.size;
-		collectStatementListFunctionNames(componentBody.body, functionLikeLocalNames, createComponentBindingScope());
+		collectStatementListFunctionNames(componentBody.body, functionLikeLocalNames, createComponentBindingScope(), scopes);
 	}
 	return functionLikeLocalNames;
 };
@@ -39869,17 +40512,17 @@ const noEventTriggerState = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const useStateBindings = collectUseStateBindings(componentBody);
+			const useStateBindings = collectUseStateBindings(componentBody, context.scopes);
 			if (useStateBindings.length === 0) return;
 			const analysis = getProgramAnalysis(componentBody);
 			if (!analysis) return;
 			const localStateNames = new Set(useStateBindings.map((binding) => binding.valueName));
-			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody);
+			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody, context.scopes);
 			const dependencyGraph = buildLocalDependencyGraph(componentBody, eventHandlerReferenceNames);
-			const renderReachableNames = expandTransitiveDependencies(collectRenderReachableNames(componentBody, eventHandlerReferenceNames), dependencyGraph);
+			const renderReachableNames = expandTransitiveDependencies(collectRenderReachableNames(componentBody, context.scopes, eventHandlerReferenceNames), dependencyGraph);
 			walkAst(componentBody, (effectCall) => {
 				if (!isNodeOfType(effectCall, "CallExpression")) return;
-				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) return;
+				if (!isReactHookCall(effectCall, EFFECT_HOOK_NAMES$1, context.scopes)) return;
 				if ((effectCall.arguments?.length ?? 0) < 2) return;
 				const depsNode = effectCall.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) return;
@@ -40263,6 +40906,17 @@ const DOM_MEASUREMENT_NAMES = new Set([
 	"scrollHeight"
 ]);
 const MEASUREMENT_HELPER_CALLEE_PATTERN = /^(?:get|measure|read)\w*(?:Width|Height|Rect|Rects|Size|Bounds|Position)$/;
+const IMPERATIVE_DOM_MUTATION_NAMES = new Set([
+	"blur",
+	"focus",
+	"restoreSelection",
+	"scroll",
+	"scrollBy",
+	"scrollIntoView",
+	"scrollTo",
+	"setRangeText",
+	"setSelectionRange"
+]);
 const subtreeReadsDomMeasurement = (root) => {
 	if (!root) return false;
 	let found = false;
@@ -40281,29 +40935,66 @@ const subtreeReadsDomMeasurement = (root) => {
 	});
 	return found;
 };
-const collectMeasuringFunctionNames = (program) => {
+const collectFunctionNamesMatchingBody = (program, matchesBody) => {
 	const names = /* @__PURE__ */ new Set();
 	walkAst(program, (child) => {
 		if (isNodeOfType(child, "FunctionDeclaration")) {
-			if (child.id && isNodeOfType(child.id, "Identifier") && subtreeReadsDomMeasurement(child.body)) names.add(child.id.name);
+			if (child.id && isNodeOfType(child.id, "Identifier") && matchesBody(child.body)) names.add(child.id.name);
 			return;
 		}
 		if (!isNodeOfType(child, "VariableDeclarator") || !isNodeOfType(child.id, "Identifier")) return;
 		let functionValue = child.init;
 		if (functionValue && isNodeOfType(functionValue, "CallExpression") && isNodeOfType(functionValue.callee, "Identifier") && /^use[A-Z]/.test(functionValue.callee.name)) functionValue = functionValue.arguments?.[0];
-		if (functionValue && isFunctionLike$1(functionValue) && subtreeReadsDomMeasurement(functionValue.body)) names.add(child.id.name);
+		if (functionValue && isFunctionLike$1(functionValue) && matchesBody(functionValue.body)) names.add(child.id.name);
 	});
 	return names;
 };
-const callsAnyName = (root, names) => {
-	if (!root || names.size === 0) return false;
+const collectMeasuringFunctionNames = (program) => collectFunctionNamesMatchingBody(program, subtreeReadsDomMeasurement);
+const subtreeMutatesDomImperatively = (root) => {
+	if (!root || isFunctionLike$1(root)) return false;
+	let found = false;
+	walkAst(root, (child) => {
+		if (found) return false;
+		if (child !== root && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = stripParenExpression(child.callee);
+		const propertyName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : null;
+		if (propertyName !== null && IMPERATIVE_DOM_MUTATION_NAMES.has(propertyName)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+};
+const collectImperativeDomFunctionNames = (program) => collectFunctionNamesMatchingBody(program, subtreeMutatesDomImperatively);
+const callsAnyName = (root, names, shouldSkipNestedFunctions = false) => {
+	if (!root || names.size === 0 || shouldSkipNestedFunctions && isFunctionLike$1(root)) return false;
 	let found = false;
 	walkAst(root, (child) => {
 		if (found) return false;
+		if (shouldSkipNestedFunctions && child !== root && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && names.has(child.callee.name)) found = true;
 	});
 	return found;
 };
+const isFollowedByImperativeDomMutation = (call, imperativeDomFunctionNames) => {
+	let statement = call;
+	let parent = statement.parent;
+	while (parent) {
+		const statements = isNodeOfType(parent, "BlockStatement") || isNodeOfType(parent, "Program") || isNodeOfType(parent, "StaticBlock") ? parent.body : isNodeOfType(parent, "SwitchCase") ? parent.consequent : null;
+		if (statements) {
+			const statementIndex = statements.findIndex((siblingStatement) => siblingStatement === statement);
+			if (statementIndex >= 0) {
+				const nextStatement = statements[statementIndex + 1];
+				return subtreeMutatesDomImperatively(nextStatement) || callsAnyName(nextStatement, imperativeDomFunctionNames, true);
+			}
+		}
+		if (isFunctionLike$1(parent) || parent.type.endsWith("Statement") && !isNodeOfType(parent, "ExpressionStatement")) return false;
+		statement = parent;
+		parent = parent.parent;
+	}
+	return false;
+};
 const isInsideStartViewTransition = (node) => {
 	let cursor = node.parent;
 	while (cursor) {
@@ -40344,11 +41035,12 @@ const importsImperativeDomLibrary = (program) => {
 };
 const hasExemptFlushSyncCall = (program, localName) => {
 	const measuringFunctionNames = collectMeasuringFunctionNames(program);
+	const imperativeDomFunctionNames = collectImperativeDomFunctionNames(program);
 	let exempt = false;
 	walkAst(program, (child) => {
 		if (exempt) return false;
 		if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "Identifier") || child.callee.name !== localName) return;
-		if (isInsideStartViewTransition(child) || enclosingFunctionChainReadsMeasurement(child, measuringFunctionNames)) {
+		if (isInsideStartViewTransition(child) || enclosingFunctionChainReadsMeasurement(child, measuringFunctionNames) || isFollowedByImperativeDomMutation(child, imperativeDomFunctionNames)) {
 			exempt = true;
 			return false;
 		}
@@ -40913,41 +41605,223 @@ const readLogicalConditionResult = (operator, leftResult, rightResult) => {
 	if (leftResult === false && rightResult === false) return false;
 	return null;
 };
-const readHydrationConditionResult = (expression, context, runtime) => {
+const readHydrationConditionResult = (expression, context, runtime, state) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
 	if (predicateMatch) return predicateMatch[`${runtime}Result`];
 	const staticResult = readInitialStateBoolean(unwrappedExpression, context.scopes);
 	if (staticResult !== null) return staticResult;
+	const expressionSymbol = isNodeOfType(unwrappedExpression, "Identifier") ? context.scopes.symbolFor(unwrappedExpression) : null;
+	const parameterValue = expressionSymbol ? state.parameterValuesBySymbolId.get(expressionSymbol.id) : null;
+	if (expressionSymbol && parameterValue && !state.visitedSymbolIds.has(expressionSymbol.id)) {
+		state.visitedSymbolIds.add(expressionSymbol.id);
+		const result = readHydrationConditionResult(parameterValue, context, runtime, state);
+		state.visitedSymbolIds.delete(expressionSymbol.id);
+		return result;
+	}
+	if (expressionSymbol && expressionSymbol.kind === "const" && expressionSymbol.initializer && expressionSymbol.references.every((reference) => reference.flag === "read") && !state.visitedSymbolIds.has(expressionSymbol.id)) {
+		state.visitedSymbolIds.add(expressionSymbol.id);
+		const result = readHydrationConditionResult(expressionSymbol.initializer, context, runtime, state);
+		state.visitedSymbolIds.delete(expressionSymbol.id);
+		return result;
+	}
+	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
+		const callArguments = unwrappedExpression.arguments ?? [];
+		if (isReactApiCall(unwrappedExpression, "useMemo", context.scopes, {
+			allowGlobalReactNamespace: true,
+			resolveNamedAliases: true
+		})) {
+			const callbackArgument = callArguments[0];
+			if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
+			const callbackFunction = resolveExactLocalFunction(callbackArgument, context.scopes);
+			return isFunctionLike$1(callbackFunction) && callbackFunction.params.length === 0 ? readHydrationFunctionResult(callbackFunction, context, runtime, state) : null;
+		}
+		const callee = stripParenExpression(unwrappedExpression.callee);
+		if (isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee) && callArguments.length === 1 && !isNodeOfType(callArguments[0], "SpreadElement")) return readHydrationConditionResult(callArguments[0], context, runtime, state);
+		const helperFunction = resolveExactLocalFunction(callee, context.scopes);
+		if (!isFunctionLike$1(helperFunction) || helperFunction.async || isNodeOfType(helperFunction, "FunctionDeclaration") && helperFunction.generator || isNodeOfType(helperFunction, "FunctionExpression") && helperFunction.generator || helperFunction.params.some((parameter) => !isNodeOfType(parameter, "Identifier")) || callArguments.some((argument) => isNodeOfType(argument, "SpreadElement"))) return null;
+		const parameterValuesBySymbolId = new Map(state.parameterValuesBySymbolId);
+		for (let parameterIndex = 0; parameterIndex < helperFunction.params.length; parameterIndex++) {
+			const parameter = helperFunction.params[parameterIndex];
+			const argument = callArguments[parameterIndex];
+			if (!argument || !isNodeOfType(parameter, "Identifier")) continue;
+			const parameterSymbol = context.scopes.symbolFor(parameter);
+			if (parameterSymbol) parameterValuesBySymbolId.set(parameterSymbol.id, argument);
+		}
+		return readHydrationFunctionResult(helperFunction, context, runtime, {
+			...state,
+			parameterValuesBySymbolId
+		});
+	}
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime);
+		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime, state);
 		return argumentResult === null ? null : !argumentResult;
 	}
 	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime), readHydrationConditionResult(unwrappedExpression.right, context, runtime));
+	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime, state), readHydrationConditionResult(unwrappedExpression.right, context, runtime, state));
+};
+const readHydrationStatementResult = (statement, context, runtime, state) => {
+	if (isNodeOfType(statement, "ReturnStatement")) return {
+		didReturn: true,
+		value: statement.argument ? readHydrationConditionResult(statement.argument, context, runtime, state) : null
+	};
+	if (isNodeOfType(statement, "BlockStatement")) {
+		for (const childStatement of statement.body) {
+			const result = readHydrationStatementResult(childStatement, context, runtime, state);
+			if (result.didReturn) return result;
+			if (statementAlwaysExits(childStatement)) break;
+		}
+		return {
+			didReturn: false,
+			value: null
+		};
+	}
+	if (!isNodeOfType(statement, "IfStatement")) return {
+		didReturn: false,
+		value: null
+	};
+	const conditionResult = readHydrationConditionResult(statement.test, context, runtime, state);
+	if (conditionResult !== null) {
+		const selectedBranch = conditionResult ? statement.consequent : statement.alternate;
+		return selectedBranch ? readHydrationStatementResult(selectedBranch, context, runtime, state) : {
+			didReturn: false,
+			value: null
+		};
+	}
+	const consequentResult = readHydrationStatementResult(statement.consequent, context, runtime, state);
+	const alternateResult = statement.alternate ? readHydrationStatementResult(statement.alternate, context, runtime, state) : {
+		didReturn: false,
+		value: null
+	};
+	return consequentResult.didReturn && alternateResult.didReturn && consequentResult.value !== null && consequentResult.value === alternateResult.value ? consequentResult : {
+		didReturn: consequentResult.didReturn || alternateResult.didReturn,
+		value: null
+	};
+};
+const readHydrationFunctionResult = (functionNode, context, runtime, state) => {
+	if (!isFunctionLike$1(functionNode) || state.visitedFunctionNodes.has(functionNode)) return null;
+	state.visitedFunctionNodes.add(functionNode);
+	const result = isNodeOfType(functionNode.body, "BlockStatement") ? readHydrationStatementResult(functionNode.body, context, runtime, state).value : readHydrationConditionResult(functionNode.body, context, runtime, state);
+	state.visitedFunctionNodes.delete(functionNode);
+	return result;
+};
+const doEquivalentExpressionBindingsMatch = (leftExpression, rightExpression, scopes) => {
+	const left = stripParenExpression(leftExpression);
+	const right = stripParenExpression(rightExpression);
+	if (isNodeOfType(left, "Identifier") && isNodeOfType(right, "Identifier")) {
+		const leftSymbol = scopes.symbolFor(left);
+		const rightSymbol = scopes.symbolFor(right);
+		return leftSymbol || rightSymbol ? leftSymbol?.id === rightSymbol?.id : true;
+	}
+	if (isNodeOfType(left, "MemberExpression") && isNodeOfType(right, "MemberExpression")) return doEquivalentExpressionBindingsMatch(left.object, right.object, scopes) && (!left.computed || doEquivalentExpressionBindingsMatch(left.property, right.property, scopes));
+	if (isNodeOfType(left, "CallExpression") && isNodeOfType(right, "CallExpression")) {
+		const rightArguments = right.arguments ?? [];
+		return doEquivalentExpressionBindingsMatch(left.callee, right.callee, scopes) && (left.arguments ?? []).every((argument, index) => {
+			const rightArgument = rightArguments[index];
+			return Boolean(rightArgument && doEquivalentExpressionBindingsMatch(argument, rightArgument, scopes));
+		});
+	}
+	return true;
+};
+const areHelperReturnValuesEquivalent = (leftValue, rightValue, context) => {
+	if (areExpressionsStructurallyEqual(leftValue, rightValue)) return doEquivalentExpressionBindingsMatch(leftValue, rightValue, context.scopes);
+	const leftBoolean = readInitialStateBoolean(leftValue, context.scopes);
+	const rightBoolean = readInitialStateBoolean(rightValue, context.scopes);
+	return leftBoolean !== null && rightBoolean !== null && leftBoolean === rightBoolean;
 };
-const matchHydrationCondition = (expression, context) => {
+const doHelperReturnValuesDiffer = (leftValues, rightValues, context) => {
+	const everyValueHasEquivalent = (values, candidateValues) => values.every((value) => candidateValues.some((candidateValue) => areHelperReturnValuesEquivalent(value, candidateValue, context)));
+	return !everyValueHasEquivalent(leftValues, rightValues) || !everyValueHasEquivalent(rightValues, leftValues);
+};
+const matchHydrationConditionInternal = (expression, context, state) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
 	if (predicateMatch) return {
 		predicateMatch,
 		predicateNode: unwrappedExpression
 	};
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationCondition(unwrappedExpression.argument, context);
-	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	const leftMatch = matchHydrationCondition(unwrappedExpression.left, context);
-	const rightMatch = matchHydrationCondition(unwrappedExpression.right, context);
-	if (leftMatch && rightMatch) {
-		const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client");
-		const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server");
-		return clientResult !== null && serverResult !== null && clientResult !== serverResult ? leftMatch : null;
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = context.scopes.symbolFor(unwrappedExpression);
+		const parameterValue = symbol ? state.parameterValuesBySymbolId.get(symbol.id) : null;
+		if (symbol && parameterValue && !state.visitedSymbolIds.has(symbol.id)) {
+			state.visitedSymbolIds.add(symbol.id);
+			const match = matchHydrationConditionInternal(parameterValue, context, state);
+			state.visitedSymbolIds.delete(symbol.id);
+			return match;
+		}
+		if (!symbol || symbol.kind !== "const" || !symbol.initializer || symbol.references.some((reference) => reference.flag !== "read") || state.visitedSymbolIds.has(symbol.id)) return null;
+		state.visitedSymbolIds.add(symbol.id);
+		const match = matchHydrationConditionInternal(symbol.initializer, context, state);
+		state.visitedSymbolIds.delete(symbol.id);
+		return match;
+	}
+	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
+		const callArguments = unwrappedExpression.arguments ?? [];
+		if (isReactApiCall(unwrappedExpression, "useMemo", context.scopes, {
+			allowGlobalReactNamespace: true,
+			resolveNamedAliases: true
+		})) {
+			const callbackArgument = callArguments[0];
+			if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
+			const callbackFunction = resolveExactLocalFunction(callbackArgument, context.scopes);
+			return isFunctionLike$1(callbackFunction) && callbackFunction.params.length === 0 ? matchHydrationFunctionResult(callbackFunction, context, state) : null;
+		}
+		const callee = stripParenExpression(unwrappedExpression.callee);
+		if (isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee) && callArguments.length === 1 && !isNodeOfType(callArguments[0], "SpreadElement")) return matchHydrationConditionInternal(callArguments[0], context, state);
+		const helperFunction = resolveExactLocalFunction(callee, context.scopes);
+		if (!isFunctionLike$1(helperFunction) || helperFunction.async || isNodeOfType(helperFunction, "FunctionDeclaration") && helperFunction.generator || isNodeOfType(helperFunction, "FunctionExpression") && helperFunction.generator || helperFunction.params.some((parameter) => !isNodeOfType(parameter, "Identifier")) || callArguments.some((argument) => isNodeOfType(argument, "SpreadElement"))) return null;
+		const parameterValuesBySymbolId = new Map(state.parameterValuesBySymbolId);
+		for (let parameterIndex = 0; parameterIndex < helperFunction.params.length; parameterIndex++) {
+			const parameter = helperFunction.params[parameterIndex];
+			const argument = callArguments[parameterIndex];
+			if (!argument || !isNodeOfType(parameter, "Identifier")) continue;
+			const parameterSymbol = context.scopes.symbolFor(parameter);
+			if (parameterSymbol) parameterValuesBySymbolId.set(parameterSymbol.id, argument);
+		}
+		return matchHydrationFunctionResult(helperFunction, context, {
+			...state,
+			parameterValuesBySymbolId
+		});
 	}
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationConditionInternal(unwrappedExpression.argument, context, state);
+	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
+	const leftMatch = matchHydrationConditionInternal(unwrappedExpression.left, context, state);
+	const rightMatch = matchHydrationConditionInternal(unwrappedExpression.right, context, state);
 	const nestedMatch = leftMatch ?? rightMatch;
 	if (!nestedMatch) return null;
-	const otherResult = readInitialStateBoolean(leftMatch ? unwrappedExpression.right : unwrappedExpression.left, context.scopes);
-	if (unwrappedExpression.operator === "&&" && otherResult === false || unwrappedExpression.operator === "||" && otherResult === true) return null;
-	return nestedMatch;
+	const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client", state);
+	const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server", state);
+	return clientResult !== null && serverResult !== null && clientResult === serverResult ? null : nestedMatch;
 };
+const matchHydrationReturningStatement = (statement, context, state) => {
+	if (isNodeOfType(statement, "ReturnStatement")) return statement.argument ? matchHydrationConditionInternal(statement.argument, context, state) : null;
+	if (isNodeOfType(statement, "IfStatement")) {
+		const conditionMatch = matchHydrationConditionInternal(statement.test, context, state);
+		const consequentValues = getReturnedValues(statement.consequent);
+		const alternateValues = statement.alternate ? getReturnedValues(statement.alternate) : findFollowingReturnedValues(statement);
+		if (conditionMatch && consequentValues.length > 0 && alternateValues.length > 0 && doHelperReturnValuesDiffer(consequentValues, alternateValues, context)) return conditionMatch;
+		return matchHydrationReturningStatement(statement.consequent, context, state) ?? (statement.alternate ? matchHydrationReturningStatement(statement.alternate, context, state) : null);
+	}
+	if (!isNodeOfType(statement, "BlockStatement")) return null;
+	for (const childStatement of statement.body) {
+		const match = matchHydrationReturningStatement(childStatement, context, state);
+		if (match) return match;
+		if (statementAlwaysExits(childStatement)) break;
+	}
+	return null;
+};
+const matchHydrationFunctionResult = (functionNode, context, state) => {
+	if (!isFunctionLike$1(functionNode) || state.visitedFunctionNodes.has(functionNode)) return null;
+	state.visitedFunctionNodes.add(functionNode);
+	const match = isNodeOfType(functionNode.body, "BlockStatement") ? matchHydrationReturningStatement(functionNode.body, context, state) : matchHydrationConditionInternal(functionNode.body, context, state);
+	state.visitedFunctionNodes.delete(functionNode);
+	return match;
+};
+const matchHydrationCondition = (expression, context) => matchHydrationConditionInternal(expression, context, {
+	parameterValuesBySymbolId: /* @__PURE__ */ new Map(),
+	visitedFunctionNodes: /* @__PURE__ */ new Set(),
+	visitedSymbolIds: /* @__PURE__ */ new Set()
+});
 const areNodeArraysEquivalent = (leftNodes, rightNodes) => leftNodes.length === rightNodes.length && leftNodes.every((leftNode, index) => areRenderedBranchesEquivalent(leftNode, rightNodes[index]));
 const areRenderedBranchesEquivalent = (leftNode, rightNode) => {
 	if (!leftNode || !rightNode) return leftNode === rightNode;
@@ -41090,17 +41964,17 @@ const noHydrationBranchOnBrowserGlobal = defineRule({
 			const { predicateMatch, predicateNode } = conditionMatch;
 			if (reportedNodes.has(predicateNode)) return;
 			if (rightBranch && areRenderedBranchesEquivalent(leftBranch, rightBranch)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(predicateNode, context.scopes);
+			const componentOrHookNode = findRenderPhaseComponentOrHook(conditionNode, context.scopes);
 			if (!componentOrHookNode) return;
 			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (requiresRenderedContext && !isInRenderedOutput(predicateNode, componentOrHookNode, context.scopes)) return;
+			if (requiresRenderedContext && !isInRenderedOutput(conditionNode, componentOrHookNode, context.scopes)) return;
 			if (!isRenderedValue(leftBranch) && (!rightBranch || !isRenderedValue(rightBranch))) {
-				const attribute = findEnclosingJsxAttribute(predicateNode);
+				const attribute = findEnclosingJsxAttribute(conditionNode);
 				if (!attribute || isEventHandlerAttribute(attribute)) return;
 			}
-			if (fileIsEmailTemplate || isGatedByFalsyInitialState(predicateNode, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(predicateNode, componentOrHookNode, context.scopes)) return;
-			const openingElement = findEnclosingJsxOpeningElement(predicateNode);
+			if (fileIsEmailTemplate || isGatedByFalsyInitialState(conditionNode, context.scopes)) return;
+			if (isAfterClientOnlyEarlyReturn(conditionNode, componentOrHookNode, context.scopes)) return;
+			const openingElement = findEnclosingJsxOpeningElement(conditionNode);
 			if (hasSuppressHydrationWarningAttribute(openingElement) && !isStructuralRenderedValue(leftBranch) && !isStructuralRenderedValue(rightBranch)) return;
 			if (branchRootsSuppressSameElement(leftBranch, rightBranch)) return;
 			if (isGeneratedImageRenderContext(context, openingElement ?? leftBranch)) return;
@@ -41477,7 +42351,7 @@ const noInitializeState = defineRule({
 	tags: ["test-noise"],
 	recommendation: "Pass the initial value directly to useState() instead of setting it from a mount-only useEffect. For SSR hydration, prefer useSyncExternalStore().",
 	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
+		if (!isReactHookCall(node, "useEffect", context.scopes)) return;
 		const dependencies = node.arguments?.[1];
 		if (!dependencies || !isNodeOfType(dependencies, "ArrayExpression") || (dependencies.elements ?? []).length !== 0) return;
 		const analysis = getProgramAnalysis(node);
@@ -41840,7 +42714,8 @@ const noJsxElementType = defineRule({
 	create: (context) => {
 		let isJsxImported = false;
 		const flaggedAnnotations = [];
-		const checkReturnType = (returnType) => {
+		const collectComponentReturnType = (functionNode, returnType) => {
+			if (!(isNodeOfType(functionNode, "TSDeclareFunction") ? Boolean(functionNode.id && isReactComponentName(functionNode.id.name)) : isComponentFunction$1(functionNode))) return;
 			const typeAnnotation = extractReturnTypeAnnotation(returnType);
 			if (!typeAnnotation) return;
 			if (isJsxElementTypeReference(typeAnnotation)) flaggedAnnotations.push(typeAnnotation);
@@ -41850,19 +42725,16 @@ const noJsxElementType = defineRule({
 				if (isJsxImportBinding(node)) isJsxImported = true;
 			},
 			FunctionDeclaration(node) {
-				checkReturnType(node.returnType);
+				collectComponentReturnType(node, node.returnType);
 			},
 			ArrowFunctionExpression(node) {
-				checkReturnType(node.returnType);
+				collectComponentReturnType(node, node.returnType);
 			},
 			FunctionExpression(node) {
-				checkReturnType(node.returnType);
+				collectComponentReturnType(node, node.returnType);
 			},
 			TSDeclareFunction(node) {
-				checkReturnType(node.returnType);
-			},
-			TSMethodSignature(node) {
-				checkReturnType(node.returnType);
+				collectComponentReturnType(node, node.returnType);
 			},
 			"Program:exit"() {
 				if (isJsxImported) return;
@@ -43091,7 +43963,7 @@ const noMirrorPropEffect = defineRule({
 					const setterElement = elements[1];
 					if (!isNodeOfType(valueElement, "Identifier") || !isNodeOfType(setterElement, "Identifier") || !isSetterIdentifier(setterElement.name)) continue;
 					if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-					if (!isHookCall$2(declarator.init, "useState")) continue;
+					if (!isReactHookCall(declarator.init, "useState", context.scopes)) continue;
 					const initializer = declarator.init.arguments?.[0];
 					if (!initializer) continue;
 					const propRootName = getPropRootName(initializer, propNames);
@@ -43109,7 +43981,7 @@ const noMirrorPropEffect = defineRule({
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
-				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
+				if (!isReactHookCall(effectCall, EFFECT_HOOK_NAMES$1, context.scopes)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const depsNode = effectCall.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) continue;
@@ -43518,7 +44390,7 @@ const noMultiComp = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-mutable-in-deps.ts
-const collectUseRefBindingNames = (componentBody) => {
+const collectUseRefBindingNames = (componentBody, scopes) => {
 	const useRefBindings = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(componentBody, "BlockStatement")) return useRefBindings;
 	for (const statement of componentBody.body ?? []) {
@@ -43526,7 +44398,7 @@ const collectUseRefBindingNames = (componentBody) => {
 		for (const declarator of statement.declarations ?? []) {
 			if (!isNodeOfType(declarator.id, "Identifier")) continue;
 			if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-			if (!isHookCall$2(declarator.init, "useRef")) continue;
+			if (!isReactHookCall(declarator.init, "useRef", scopes)) continue;
 			useRefBindings.add(declarator.id.name);
 		}
 	}
@@ -43561,12 +44433,12 @@ const noMutableInDeps = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody, componentParams = []) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const useRefBindingNames = collectUseRefBindingNames(componentBody);
+			const useRefBindingNames = collectUseRefBindingNames(componentBody, context.scopes);
 			const localBindingNames = collectLocalBindingNames(componentBody);
 			for (const param of componentParams) collectPatternNames(param, localBindingNames);
 			walkAst(componentBody, (child) => {
 				if (!isNodeOfType(child, "CallExpression")) return;
-				if (!isHookCall$2(child, HOOKS_WITH_DEPS)) return;
+				if (!isReactHookCall(child, HOOKS_WITH_DEPS, context.scopes)) return;
 				if ((child.arguments?.length ?? 0) < 2) return;
 				const depsNode = child.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) return;
@@ -45396,6 +46268,7 @@ const EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1 = new Set([
 	"useMatchMedia",
 	"useMediaJobProgress",
 	"useMediaQuery",
+	"useMediaQueryState",
 	"useResizeObserver",
 	"useVisibility",
 	"useWindowSize"
@@ -45432,9 +46305,30 @@ const isParentWiredHookCalleeRef = (analysis, ref) => {
 	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier) return false;
 	return (parent.arguments ?? []).some((hookArgument) => getDownstreamRefs(analysis, hookArgument).some((downstreamRef) => isCallbackPropReference(analysis, downstreamRef)));
 };
-const isExternalSubscriptionHookRef = (ref) => {
+const getLocalHookExternalStateProof = (analysis, ref) => {
+	let hookFunction = resolveToFunction(ref);
+	if (!hookFunction) for (const definition of ref.resolved?.defs ?? []) {
+		const definitionNode = definition.node;
+		if (!isNodeOfType(definitionNode, "VariableDeclarator") || !definitionNode.init) continue;
+		const initializer = stripParenExpression(definitionNode.init);
+		if (!isNodeOfType(initializer, "CallExpression")) continue;
+		const callee = stripParenExpression(initializer.callee);
+		if (!isNodeOfType(callee, "Identifier")) continue;
+		const calleeReference = getRef(analysis, callee);
+		if (!calleeReference) continue;
+		hookFunction = resolveToFunction(calleeReference);
+		if (hookFunction) break;
+	}
+	if (!hookFunction) return null;
+	const returnedReferences = collectFunctionReturnStatements(hookFunction).flatMap((returnStatement) => returnStatement.argument ? getDownstreamRefs(analysis, returnStatement.argument) : []);
+	if (returnedReferences.length === 0) return null;
+	return returnedReferences.every((returnedReference) => isState(analysis, returnedReference) && isExternallyDrivenState(analysis, returnedReference));
+};
+const isExternalSubscriptionHookRef = (analysis, ref) => {
 	const identifier = ref.identifier;
 	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const localHookProof = getLocalHookExternalStateProof(analysis, ref);
+	if (localHookProof !== null) return localHookProof;
 	if (EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(identifier.name) && isCalleePosition(identifier)) return true;
 	return Boolean(ref.resolved?.defs.some((def) => {
 		const node = def.node;
@@ -45457,16 +46351,10 @@ const noPassDataToParent = defineRule({
 	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
-		});
-		const isReactUseEffectCall = (node) => isReactApiCall(node, "useEffect", context.scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true
-		});
+		const isReactUseRefCall = (node) => isReactHookCall(node, "useRef", context.scopes);
+		const isReactUseEffectCall = (node) => isReactHookCall(node, "useEffect", context.scopes);
 		return { CallExpression(node) {
-			if (!isUseEffect(node)) return;
+			if (!isReactUseEffectCall(node)) return;
 			const analysis = getProgramAnalysis(node);
 			if (!analysis) return;
 			if (hasCleanup(analysis, node)) return;
@@ -45518,11 +46406,11 @@ const noPassDataToParent = defineRule({
 						if (argumentRef && resolveToFunction(argumentRef)) return [];
 					}
 					return getDownstreamRefs(analysis, argument);
-				}).flatMap((argumentRef) => isExternallyDrivenState(analysis, argumentRef) ? [] : getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
+				}).flatMap((argumentRef) => isExternallyDrivenState(analysis, argumentRef) || isExternalSubscriptionHookRef(analysis, argumentRef) ? [] : getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
 				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref, context.scopes)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
 				if (!argsUpstreamRefs.some((argRef) => {
 					if (isUseStateIdentifier(argRef.identifier)) return false;
-					if (isExternalSubscriptionHookRef(argRef)) return false;
+					if (isExternalSubscriptionHookRef(analysis, argRef)) return false;
 					if (isProp(analysis, argRef)) return false;
 					if (isUseRefIdentifier(argRef.identifier)) return false;
 					if (isRefCurrent(argRef)) return false;
@@ -45753,7 +46641,7 @@ const noPassLiveStateToParent = defineRule({
 	tags: ["test-noise"],
 	recommendation: "Move the state up to the parent (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#notifying-parent-components-about-state-changes",
 	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
+		if (!isReactHookCall(node, "useEffect", context.scopes)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const effectFnRefs = getEffectFnRefs(analysis, node);
@@ -46168,7 +47056,7 @@ const hasPreviousValueDep = (effectNode, depElements) => {
 		if (!isNodeOfType(element, "Identifier")) continue;
 		const binding = findVariableInitializer(effectNode, element.name);
 		if (!binding?.initializer || !isNodeOfType(binding.initializer, "CallExpression")) continue;
-		const calleeName = getCalleeName$2(binding.initializer);
+		const calleeName = getCalleeName$1(binding.initializer);
 		if (calleeName && PREVIOUS_VALUE_HOOK_PATTERN.test(calleeName)) return true;
 	}
 	return false;
@@ -46190,7 +47078,7 @@ const getRefHeldPropCallbackName = (callExpression, isPropName) => {
 	if (!isNodeOfType(receiver, "Identifier")) return null;
 	const binding = findVariableInitializer(callExpression, receiver.name);
 	if (!binding?.initializer || !isNodeOfType(binding.initializer, "CallExpression")) return null;
-	if (getCalleeName$2(binding.initializer) !== "useRef") return null;
+	if (getCalleeName$1(binding.initializer) !== "useRef") return null;
 	const callbackArgument = binding.initializer.arguments?.[0];
 	if (!callbackArgument || !isNodeOfType(callbackArgument, "Identifier")) return null;
 	return isPropName(callbackArgument.name) ? callbackArgument.name : null;
@@ -46222,7 +47110,7 @@ const noPropCallbackInEffect = defineRule({
 		return {
 			...propStackTracker.visitors,
 			CallExpression(node) {
-				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1) || (node.arguments?.length ?? 0) < 2) return;
+				if (!isReactHookCall(node, EFFECT_HOOK_NAMES$1, context.scopes) || (node.arguments?.length ?? 0) < 2) return;
 				const callback = getEffectCallback(node);
 				if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
 				const depsNode = node.arguments[1];
@@ -47086,6 +47974,69 @@ const noRedundantShouldComponentUpdate = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/correctness/no-ref-callback-cleanup-before-react-19.ts
+const resolveFunctionExpressions = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isFunctionLike$1(expression)) return expression.async || expression.generator ? [] : [expression];
+	if (isNodeOfType(expression, "ConditionalExpression")) {
+		if (isNodeOfType(expression.test, "Literal")) return resolveFunctionExpressions(expression.test.value ? expression.consequent : expression.alternate, scopes, visitedSymbolIds);
+		return [...resolveFunctionExpressions(expression.consequent, scopes, visitedSymbolIds), ...resolveFunctionExpressions(expression.alternate, scopes, visitedSymbolIds)];
+	}
+	if (isNodeOfType(expression, "LogicalExpression")) {
+		if (isNodeOfType(expression.left, "Literal")) {
+			const isLeftTruthy = Boolean(expression.left.value);
+			if (expression.operator === "&&" && !isLeftTruthy) return [];
+			if (expression.operator === "||" && isLeftTruthy) return [];
+			if (expression.operator === "??" && expression.left.value !== null) return [];
+		}
+		if (expression.operator === "&&") return resolveFunctionExpressions(expression.right, scopes, visitedSymbolIds);
+		return [...resolveFunctionExpressions(expression.left, scopes, visitedSymbolIds), ...resolveFunctionExpressions(expression.right, scopes, visitedSymbolIds)];
+	}
+	if (isNodeOfType(expression, "SequenceExpression")) {
+		const finalExpression = expression.expressions.at(-1);
+		return finalExpression ? resolveFunctionExpressions(finalExpression, scopes, visitedSymbolIds) : [];
+	}
+	if (isNodeOfType(expression, "CallExpression")) {
+		if (!isReactApiCall(expression, "useCallback", scopes)) return [];
+		const callback = expression.arguments[0];
+		return callback && !isNodeOfType(callback, "SpreadElement") ? resolveFunctionExpressions(callback, scopes, visitedSymbolIds) : [];
+	}
+	if (!isNodeOfType(expression, "Identifier")) return [];
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return [];
+	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration") && symbol.references.every((reference) => reference.flag === "read")) return resolveFunctionExpressions(symbol.declarationNode, scopes, new Set([...visitedSymbolIds, symbol.id]));
+	const initializer = getDirectConstInitializer(symbol);
+	if (!initializer) return [];
+	return resolveFunctionExpressions(initializer, scopes, new Set([...visitedSymbolIds, symbol.id]));
+};
+const functionReturnsCleanupFunction = (functionExpression, scopes) => {
+	if (!isFunctionLike$1(functionExpression)) return false;
+	if (!isNodeOfType(functionExpression.body, "BlockStatement")) return resolveFunctionExpressions(functionExpression.body, scopes).length > 0;
+	return collectFunctionReturnStatements(functionExpression).some((returnStatement) => Boolean(returnStatement.argument && resolveFunctionExpressions(returnStatement.argument, scopes).length > 0));
+};
+const callbackReturnsCleanupFunction = (callback, scopes) => {
+	return resolveFunctionExpressions(callback, scopes).some((functionExpression) => functionReturnsCleanupFunction(functionExpression, scopes));
+};
+const noRefCallbackCleanupBeforeReact19 = defineRule({
+	id: "no-ref-callback-cleanup-before-react-19",
+	title: "Ref cleanup requires React 19",
+	requires: ["react:18"],
+	disabledWhen: ["react:19"],
+	severity: "warn",
+	recommendation: "React 18 ignores functions returned from ref callbacks. Handle cleanup when React calls the ref with `null`, or require React 19 before returning a cleanup function.",
+	create: (context) => ({ JSXAttribute(node) {
+		if (getJsxAttributeName(node.name) !== "ref") return;
+		if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
+		const callback = node.value.expression;
+		if (!callback || isNodeOfType(callback, "JSXEmptyExpression")) return;
+		if (!callbackReturnsCleanupFunction(callback, context.scopes)) return;
+		context.report({
+			node,
+			message: "This ref callback returns a cleanup function, but React 18 ignores ref cleanup returns, so the cleanup never runs. Handle detachment when React calls the ref with `null`, or require React 19."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
 const REPEATED_ANCESTOR_TYPES = new Set([
 	"DoWhileStatement",
@@ -48052,7 +49003,7 @@ const noResetAllStateOnPropChange = defineRule({
 	tags: ["test-noise"],
 	recommendation: "Pass the prop as `key` so React resets the component for you when the prop changes, instead of clearing every state value by hand in a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#resetting-all-state-when-a-prop-changes",
 	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
+		if (!isReactHookCall(node, "useEffect", context.scopes)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const effectFnRefs = getEffectFnRefs(analysis, node);
@@ -48321,7 +49272,7 @@ const isTanStackServerFnHandlerCall = (node) => {
 	if (node.callee.property.name !== "handler") return false;
 	let currentNode = node.callee.object;
 	while (isNodeOfType(currentNode, "CallExpression")) {
-		const calleeName = getCalleeName$2(currentNode);
+		const calleeName = getCalleeName$1(currentNode);
 		if (calleeName && TANSTACK_SERVER_FN_NAMES.has(calleeName)) return true;
 		if (!isNodeOfType(currentNode.callee, "MemberExpression")) return false;
 		currentNode = currentNode.callee.object;
@@ -48822,7 +49773,7 @@ const noSelfUpdatingEffect = defineRule({
 	create: (context) => {
 		const checkFunctionScope = (functionBody) => {
 			if (!functionBody || !isNodeOfType(functionBody, "BlockStatement")) return;
-			const useStateBindings = collectUseStateBindings(functionBody);
+			const useStateBindings = collectUseStateBindings(functionBody, context.scopes);
 			if (useStateBindings.length === 0) return;
 			const setterNameToStateName = /* @__PURE__ */ new Map();
 			for (const binding of useStateBindings) setterNameToStateName.set(binding.setterName, binding.valueName);
@@ -48831,7 +49782,7 @@ const noSelfUpdatingEffect = defineRule({
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
-				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
+				if (!isReactHookCall(effectCall, EFFECT_HOOK_NAMES$1, context.scopes)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const dependencyStateNames = collectDependencyStateNames(effectCall.arguments[1]);
 				if (dependencyStateNames.size === 0) continue;
@@ -48917,7 +49868,7 @@ const noSetStateInRender = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const setterNames = new Set(collectUseStateBindings(componentBody).map((binding) => binding.setterName));
+			const setterNames = new Set(collectUseStateBindings(componentBody, context.scopes).map((binding) => binding.setterName));
 			if (setterNames.size === 0) return;
 			for (const statement of componentBody.body ?? []) {
 				const setterCall = isUnconditionalSetterCallStatement(statement, setterNames);
@@ -49166,10 +50117,10 @@ const collectTimerRefUsageFacts = (ownerScope, refName) => {
 	});
 	return facts;
 };
-const isEffectCallbackFunction = (functionNode) => {
+const isEffectCallbackFunction = (functionNode, scopes) => {
 	const parent = functionNode.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
-	return isHookCall$2(parent, EFFECT_HOOK_NAMES$1) && getEffectCallback(parent) === functionNode;
+	return isReactHookCall(parent, EFFECT_HOOK_NAMES$1, scopes) && getEffectCallback(parent) === functionNode;
 };
 const doesEffectCallbackReturnName = (effectCallback, name) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
@@ -49188,24 +50139,24 @@ const isFunctionReturnedFromEffectCallback = (functionNode, effectCallback) => {
 	const cleanupBindingName = getFunctionBindingName$1(functionNode);
 	return cleanupBindingName !== null && doesEffectCallbackReturnName(effectCallback, cleanupBindingName);
 };
-const isReturnedFromAnyEffectInScope = (functionNode, ownerScope) => {
+const isReturnedFromAnyEffectInScope = (functionNode, ownerScope, scopes) => {
 	const cleanupBindingName = getFunctionBindingName$1(functionNode);
 	if (cleanupBindingName === null) return false;
 	let isReturnedFromEffect = false;
 	walkAst(ownerScope, (child) => {
 		if (isReturnedFromEffect) return false;
-		if (!isNodeOfType(child, "CallExpression") || !isHookCall$2(child, EFFECT_HOOK_NAMES$1)) return;
+		if (!isNodeOfType(child, "CallExpression") || !isReactHookCall(child, EFFECT_HOOK_NAMES$1, scopes)) return;
 		const effectCallback = getEffectCallback(child);
 		if (effectCallback && doesEffectCallbackReturnName(effectCallback, cleanupBindingName)) isReturnedFromEffect = true;
 	});
 	return isReturnedFromEffect;
 };
-const isInsideEffectCleanupReturn = (node, ownerScope) => {
+const isInsideEffectCleanupReturn = (node, ownerScope, scopes) => {
 	let functionNode = findEnclosingFunction$1(node);
 	while (functionNode) {
 		const outerFunction = findEnclosingFunction$1(functionNode);
-		if (outerFunction && isEffectCallbackFunction(outerFunction) && isFunctionReturnedFromEffectCallback(functionNode, outerFunction)) return true;
-		if (isReturnedFromAnyEffectInScope(functionNode, ownerScope)) return true;
+		if (outerFunction && isEffectCallbackFunction(outerFunction, scopes) && isFunctionReturnedFromEffectCallback(functionNode, outerFunction)) return true;
+		if (isReturnedFromAnyEffectInScope(functionNode, ownerScope, scopes)) return true;
 		functionNode = outerFunction;
 	}
 	return false;
@@ -49241,10 +50192,10 @@ const noStaleTimerRef = defineRule({
 		if (isShadowedTimerGlobal(node)) return;
 		const { clearCalleeName, refName } = clearCall;
 		const refBinding = findVariableInitializer(node, refName);
-		if (!refBinding?.initializer || !isHookCall$2(refBinding.initializer, "useRef")) return;
+		if (!refBinding?.initializer || !isReactHookCall(refBinding.initializer, "useRef", context.scopes)) return;
 		const usageFacts = collectTimerRefUsageFacts(refBinding.scopeOwner, refName);
 		if (!usageFacts.holdsScheduledTimerId || !usageFacts.hasPendingSignalRead) return;
-		if (isInsideEffectCleanupReturn(node, refBinding.scopeOwner)) return;
+		if (isInsideEffectCleanupReturn(node, refBinding.scopeOwner, context.scopes)) return;
 		if (hasRefCurrentReassignmentAfterClear(node, refName)) return;
 		context.report({
 			node,
@@ -55048,7 +55999,7 @@ const classifyCallableReadsInsideEffect = (callableIdentifier, effectCallback, c
 			allReadsAreInSubHandlers = false;
 			return;
 		}
-		if (firstSubHandlerName === null) firstSubHandlerName = getCalleeName$2(subHandlerCall);
+		if (firstSubHandlerName === null) firstSubHandlerName = getCalleeName$1(subHandlerCall);
 	});
 	return {
 		hasAnyRead,
@@ -55071,7 +56022,7 @@ const preferUseEffectEvent = defineRule({
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 				const effectCall = statement.expression;
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
-				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
+				if (!isReactHookCall(effectCall, EFFECT_HOOK_NAMES$1, context.scopes)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const depsNode = effectCall.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) continue;
@@ -55103,11 +56054,11 @@ const preferUseEffectEvent = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/prefer-use-sync-external-store.ts
-const findUseEffectsInComponent = (componentBody) => {
+const findUseEffectsInComponent = (componentBody, scopes) => {
 	const effectCalls = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return effectCalls;
 	for (const statement of componentBody.body ?? []) walkAst(statement, (child) => {
-		if (isNodeOfType(child, "CallExpression") && isHookCall$2(child, EFFECT_HOOK_NAMES$1)) effectCalls.push(child);
+		if (isNodeOfType(child, "CallExpression") && isReactHookCall(child, EFFECT_HOOK_NAMES$1, scopes)) effectCalls.push(child);
 	});
 	return effectCalls;
 };
@@ -55310,7 +56261,7 @@ const preferUseSyncExternalStore = defineRule({
 		};
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const useStateBindings = collectUseStateBindings(componentBody);
+			const useStateBindings = collectUseStateBindings(componentBody, context.scopes);
 			if (useStateBindings.length === 0) return;
 			const useStateInitializerByValueName = /* @__PURE__ */ new Map();
 			for (const binding of useStateBindings) {
@@ -55323,7 +56274,7 @@ const preferUseSyncExternalStore = defineRule({
 			}
 			const setterNameToValueName = /* @__PURE__ */ new Map();
 			for (const binding of useStateBindings) setterNameToValueName.set(binding.setterName, binding.valueName);
-			for (const effectCall of findUseEffectsInComponent(componentBody)) {
+			for (const effectCall of findUseEffectsInComponent(componentBody, context.scopes)) {
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const depsNode = effectCall.arguments[1];
@@ -55365,7 +56316,7 @@ const preferUseSyncExternalStore = defineRule({
 			})).filter((candidate) => candidate.storeName !== null);
 			if (snapshotBindings.length === 0) return;
 			const reportedDeclarators = /* @__PURE__ */ new Set();
-			for (const effectCall of findUseEffectsInComponent(componentBody)) {
+			for (const effectCall of findUseEffectsInComponent(componentBody, context.scopes)) {
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const depsNode = effectCall.arguments[1];
@@ -55462,7 +56413,7 @@ const preferUseReducer = defineRule({
 	create: (context) => {
 		const reportCoUpdatedUseState = (body, componentName) => {
 			if (!isNodeOfType(body, "BlockStatement")) return;
-			const bindings = collectUseStateBindings(body);
+			const bindings = collectUseStateBindings(body, context.scopes);
 			const setterNames = new Set(bindings.map((binding) => binding.setterName));
 			if (setterNames.size < 5) return;
 			const coUpdatedCount = findLargestCoUpdatedSetterGroup(body, setterNames, new Map(bindings.map((binding) => {
@@ -55678,7 +56629,7 @@ const QUERY_READ_METHOD_NAMES = new Set([
 ]);
 const isQueryCacheSourceCall = (initializer) => {
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	const hookName = getCalleeName$2(initializer);
+	const hookName = getCalleeName$1(initializer);
 	if (!hookName) return false;
 	return hookName === "useQueryClient" || TRPC_UTILS_HOOK_PATTERN.test(hookName);
 };
@@ -55810,7 +56761,7 @@ const queryMutationMissingInvalidation = defineRule({
 			},
 			CallExpression(node) {
 				if (!hasQueryReadUsage) {
-					const callName = getCalleeName$2(node);
+					const callName = getCalleeName$1(node);
 					if (callName && (QUERY_READ_HOOK_NAMES.has(callName) || QUERY_READ_METHOD_NAMES.has(callName) || TRPC_UTILS_HOOK_PATTERN.test(callName))) hasQueryReadUsage = true;
 				}
 				const calleeName = isNodeOfType(node.callee, "Identifier") ? node.callee.name : null;
@@ -57473,6 +58424,125 @@ const ASYNC_DATA_CALLEE_NAMES = new Set([
 const RESOURCE_LOAD_EVENT_ATTRIBUTE_PATTERN = /^on(?:Load|Error|Abort|Progress|CanPlay|Stalled|Suspend|Waiting|Ended)/;
 const JSX_EVENT_HANDLER_ATTRIBUTE_PATTERN = /^on[A-Z]/;
 const REDUX_DISPATCH_HOOK_PATTERN = /^use\w*Dispatch$/;
+const FILE_READER_READ_METHOD_NAMES = new Set([
+	"readAsArrayBuffer",
+	"readAsBinaryString",
+	"readAsDataURL",
+	"readAsText"
+]);
+const isGlobalFileReaderConstruction = (expression, context) => {
+	if (!expression) return false;
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "NewExpression") || !isNodeOfType(unwrappedExpression.callee, "Identifier")) return false;
+	return unwrappedExpression.callee.name === "FileReader" && context.scopes.isGlobalReference(unwrappedExpression.callee);
+};
+const getFileReaderOriginStartBefore = (readerSymbol, readCall, context) => {
+	const readFunction = findEnclosingFunction$1(readCall);
+	let latestValue = null;
+	let latestStart = null;
+	if (readerSymbol.initializer && findEnclosingFunction$1(readerSymbol.declarationNode) === readFunction && readerSymbol.declarationNode.range[0] < readCall.range[0]) {
+		latestValue = readerSymbol.initializer;
+		latestStart = readerSymbol.declarationNode.range[0];
+	}
+	for (const reference of readerSymbol.references) {
+		if (reference.flag === "read" || reference.identifier.range[0] >= readCall.range[0] || latestStart !== null && reference.identifier.range[0] <= latestStart || findEnclosingFunction$1(reference.identifier) !== readFunction) continue;
+		const assignment = reference.identifier.parent;
+		if (!assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== reference.identifier) continue;
+		latestValue = assignment.right;
+		latestStart = reference.identifier.range[0];
+	}
+	return isGlobalFileReaderConstruction(latestValue, context) ? latestStart : null;
+};
+const resolveLoadingCompletionFunction = (expression, context) => {
+	const directFunction = resolveExactLocalFunction(expression, context.scopes);
+	if (directFunction) return directFunction;
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(unwrappedExpression);
+	const initializer = symbol ? getDirectUnreassignedInitializer(symbol) : null;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression") || !isReactApiCall(initializer, "useCallback", context.scopes)) return null;
+	const callback = initializer.arguments?.[0];
+	return callback && isFunctionLike$1(callback) ? callback : null;
+};
+const isSetterBooleanCall = (node, setterSymbol, value, context) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	const argument = node.arguments?.[0];
+	const unwrappedArgument = argument ? stripParenExpression(argument) : null;
+	return Boolean(isNodeOfType(callee, "Identifier") && context.scopes.symbolFor(callee) === setterSymbol && unwrappedArgument && isNodeOfType(unwrappedArgument, "Literal") && unwrappedArgument.value === value);
+};
+const functionClearsLoadingState = (functionNode, setterSymbol, context, visitedFunctions) => {
+	if (visitedFunctions.has(functionNode) || !isFunctionLike$1(functionNode)) return false;
+	visitedFunctions.add(functionNode);
+	let didClearLoadingState = false;
+	walkAst(functionNode.body, (child) => {
+		if (didClearLoadingState) return false;
+		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (isSetterBooleanCall(child, setterSymbol, false, context)) {
+			didClearLoadingState = true;
+			return false;
+		}
+		const helperFunction = resolveLoadingCompletionFunction(child.callee, context);
+		if (helperFunction && functionClearsLoadingState(helperFunction, setterSymbol, context, visitedFunctions)) {
+			didClearLoadingState = true;
+			return false;
+		}
+	});
+	return didClearLoadingState;
+};
+const getLatestFileReaderCallbackBefore = (readCall, readerSymbol, propertyName, originStart, context) => {
+	const readFunction = findEnclosingFunction$1(readCall);
+	if (!readFunction || !isFunctionLike$1(readFunction)) return null;
+	let callback = null;
+	let callbackStart = originStart;
+	walkAst(readFunction.body, (child) => {
+		if (child !== readFunction.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "AssignmentExpression") || child.operator !== "=" || child.range[0] >= readCall.range[0] || child.range[0] <= callbackStart || !isNodeOfType(child.left, "MemberExpression") || getStaticPropertyName(child.left) !== propertyName) return;
+		const receiver = stripParenExpression(child.left.object);
+		if (!isNodeOfType(receiver, "Identifier") || context.scopes.symbolFor(receiver) !== readerSymbol) return;
+		callback = child.right;
+		callbackStart = child.range[0];
+	});
+	return callback;
+};
+const setterStartsLoadingBefore = (readCall, setterSymbol, context) => {
+	const readFunction = findEnclosingFunction$1(readCall);
+	if (!readFunction || !isFunctionLike$1(readFunction)) return false;
+	let didStartLoading = false;
+	walkAst(readFunction.body, (child) => {
+		if (didStartLoading) return false;
+		if (child !== readFunction.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "CallExpression") || child.range[0] >= readCall.range[0]) return;
+		if (isSetterBooleanCall(child, setterSymbol, true, context)) {
+			didStartLoading = true;
+			return false;
+		}
+	});
+	return didStartLoading;
+};
+const setterTracksFileReader = (functionBody, setterSymbol, context) => {
+	let didFindFileReaderLifecycle = false;
+	walkAst(functionBody, (child) => {
+		if (didFindFileReaderLifecycle) return false;
+		if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "MemberExpression") || !FILE_READER_READ_METHOD_NAMES.has(getStaticPropertyName(child.callee) ?? "")) return;
+		const receiver = stripParenExpression(child.callee.object);
+		if (!isNodeOfType(receiver, "Identifier")) return;
+		const readerSymbol = context.scopes.symbolFor(receiver);
+		if (!readerSymbol) return;
+		const originStart = getFileReaderOriginStartBefore(readerSymbol, child, context);
+		if (originStart === null || !setterStartsLoadingBefore(child, setterSymbol, context)) return;
+		const loadCallback = getLatestFileReaderCallbackBefore(child, readerSymbol, "onload", originStart, context);
+		const errorCallback = getLatestFileReaderCallbackBefore(child, readerSymbol, "onerror", originStart, context);
+		const loadFunction = loadCallback ? resolveLoadingCompletionFunction(loadCallback, context) : null;
+		const errorFunction = errorCallback ? resolveLoadingCompletionFunction(errorCallback, context) : null;
+		if (loadFunction && errorFunction && functionClearsLoadingState(loadFunction, setterSymbol, context, /* @__PURE__ */ new Set()) && functionClearsLoadingState(errorFunction, setterSymbol, context, /* @__PURE__ */ new Set())) {
+			didFindFileReaderLifecycle = true;
+			return false;
+		}
+	});
+	return didFindFileReaderLifecycle;
+};
 const hasAsyncLoadingWork = (fnBody, setterName) => {
 	let found = false;
 	walkAst(fnBody, (child) => {
@@ -57646,6 +58716,8 @@ const renderingUsetransitionLoading = defineRule({
 		const fnBody = enclosingFunctionBody(node);
 		if (fnBody && hasAsyncLoadingWork(fnBody, setterName)) return;
 		if (fnBody && setterName) {
+			const setterSymbol = isNodeOfType(secondBinding, "Identifier") ? context.scopes.symbolFor(secondBinding) : null;
+			if (setterSymbol && setterTracksFileReader(fnBody, setterSymbol, context)) return;
 			if (setterEscapes(fnBody, setterName, node)) return;
 			if (setterCalledAlongsideAsyncSignal(fnBody, setterName)) return;
 			if (setterCalledInEventListenerHandler(fnBody, setterName)) return;
@@ -57977,7 +59049,7 @@ const rerenderDependencies = defineRule({
 	severity: "error",
 	recommendation: "Move it into a useMemo, useRef, or a constant outside the component so it stays the same between renders.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, HOOKS_WITH_DEPS) || node.arguments.length < 2) return;
+		if (!isReactHookCall(node, HOOKS_WITH_DEPS, context.scopes) || node.arguments.length < 2) return;
 		const depsNode = node.arguments[1];
 		if (!isNodeOfType(depsNode, "ArrayExpression")) return;
 		for (const element of depsNode.elements ?? []) {
@@ -58232,7 +59304,7 @@ const rerenderLazyRefInit = defineRule({
 	category: "Performance",
 	recommendation: "Initialize the ref lazily so expensive values are not rebuilt and discarded on every render.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, "useRef") || !node.arguments?.length) return;
+		if (!isReactHookCall(node, "useRef", context.scopes) || !node.arguments?.length) return;
 		const initializer = stripParenExpression(node.arguments[0]);
 		const isPlainCall = isNodeOfType(initializer, "CallExpression");
 		const isNewCall = isNodeOfType(initializer, "NewExpression");
@@ -58296,7 +59368,7 @@ const rerenderLazyStateInit = defineRule({
 	category: "Performance",
 	recommendation: "Wrap expensive initial state in an arrow function so the initializer does not rerun and get thrown away on every render.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, "useState") || !node.arguments?.length) return;
+		if (!isReactHookCall(node, "useState", context.scopes) || !node.arguments?.length) return;
 		const initializer = findEagerInitializerCall(node.arguments[0]);
 		if (!initializer) return;
 		const isConstructor = isNodeOfType(initializer, "NewExpression");
@@ -59059,11 +60131,11 @@ const isInsideConditionTest = (identifier, stopAt) => {
 	}
 	return false;
 };
-const collectEffectDependencyInfos = (componentBody, setterNames) => {
+const collectEffectDependencyInfos = (componentBody, setterNames, scopes) => {
 	const effectInfos = [];
 	walkAst(componentBody, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
-		if (!isHookCall$2(child, EFFECT_HOOK_NAMES$1)) return;
+		if (!isReactHookCall(child, EFFECT_HOOK_NAMES$1, scopes)) return;
 		const dependencyNames = /* @__PURE__ */ new Set();
 		for (const argument of child.arguments ?? []) {
 			if (!isNodeOfType(argument, "ArrayExpression")) continue;
@@ -59119,13 +60191,14 @@ const collectEffectDependencyInfos = (componentBody, setterNames) => {
 	});
 	return effectInfos;
 };
-const collectCustomHookArgumentNames = (componentBody) => {
+const collectCustomHookArgumentNames = (componentBody, scopes) => {
 	const argumentNames = /* @__PURE__ */ new Set();
 	walkAst(componentBody, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
 		const calleeName = child.callee.name;
 		if (!isReactHookName(calleeName)) return;
+		if (isReactHookCall(child, BUILTIN_HOOK_NAMES, scopes)) return;
 		if (BUILTIN_HOOK_NAMES.has(calleeName)) return;
 		if (EFFECT_HOOK_NAMES$1.has(calleeName)) return;
 		for (const argument of child.arguments ?? []) walkAst(argument, (argumentNode) => {
@@ -59166,21 +60239,21 @@ const rerenderStateOnlyInHandlers = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = collectUseStateBindings(componentBody);
+			const bindings = collectUseStateBindings(componentBody, context.scopes);
 			if (bindings.length === 0) return;
 			if (collectRenderReachableExpressions(componentBody).length === 0) return;
-			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody);
+			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody, context.scopes);
 			const dependencyGraph = buildLocalDependencyGraph(componentBody, eventHandlerReferenceNames);
-			const directRenderNames = collectRenderReachableNames(componentBody, eventHandlerReferenceNames);
+			const directRenderNames = collectRenderReachableNames(componentBody, context.scopes, eventHandlerReferenceNames);
 			if (hasRenderPhaseNonHookCall(componentBody)) for (const voidMarkedName of collectTopLevelVoidMarkedNames(componentBody)) directRenderNames.add(voidMarkedName);
 			const renderReachableNames = expandTransitiveDependencies(directRenderNames, dependencyGraph);
 			const setterNames = new Set(bindings.map((binding) => binding.setterName));
-			const effectInfos = collectEffectDependencyInfos(componentBody, setterNames);
+			const effectInfos = collectEffectDependencyInfos(componentBody, setterNames, context.scopes);
 			const selfEchoValueNames = /* @__PURE__ */ new Set();
 			for (const binding of bindings) if (effectInfos.some((effectInfo) => effectInfo.dependencyNames.has(binding.valueName) && effectInfo.synchronouslyCalledFunctionNames.has(binding.setterName) && !effectInfo.payloadReadNames.has(binding.valueName) && !effectInfo.nestedCallbackCalledFunctionNames.has(binding.setterName))) selfEchoValueNames.add(binding.valueName);
 			const effectConsumedNames = /* @__PURE__ */ new Set();
 			for (const effectInfo of effectInfos) for (const dependencyName of effectInfo.dependencyNames) if (!selfEchoValueNames.has(dependencyName)) effectConsumedNames.add(dependencyName);
-			for (const hookArgumentName of collectCustomHookArgumentNames(componentBody)) effectConsumedNames.add(hookArgumentName);
+			for (const hookArgumentName of collectCustomHookArgumentNames(componentBody, context.scopes)) effectConsumedNames.add(hookArgumentName);
 			for (const reachableName of expandTransitiveDependencies(effectConsumedNames, dependencyGraph)) renderReachableNames.add(reachableName);
 			const calledSetterNames = /* @__PURE__ */ new Set();
 			walkAst(componentBody, (child) => {
@@ -67081,7 +68154,7 @@ const declarationAwaitsGate = (declaration, context) => {
 		if (!isNodeOfType(argument, "CallExpression")) continue;
 		if (hasPossibleStaticMemberCallWrite(argument, context.scopes)) return true;
 		if (getOrderIndependentLocalFunction(argument, context.scopes) !== null) continue;
-		const calleeName = getCalleeName$2(argument);
+		const calleeName = getCalleeName$1(argument);
 		if (!calleeName) continue;
 		if (isAuthGuardName(calleeName)) return true;
 		const [leadingToken] = tokenizeIdentifierWords(calleeName);
@@ -67721,7 +68794,7 @@ const walkServerFnChain = (outerNode) => {
 	if (!isNodeOfType(outerNode.callee, "MemberExpression")) return result;
 	let currentNode = stripParenExpression(outerNode.callee.object);
 	while (isNodeOfType(currentNode, "CallExpression")) {
-		const calleeName = getCalleeName$2(currentNode);
+		const calleeName = getCalleeName$1(currentNode);
 		if (calleeName && TANSTACK_SERVER_FN_NAMES.has(calleeName)) {
 			result.isServerFnChain = true;
 			const optionsArgument = currentNode.arguments?.[0];
@@ -71853,6 +72926,17 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noRedundantShouldComponentUpdate.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-ref-callback-cleanup-before-react-19",
+		id: "no-ref-callback-cleanup-before-react-19",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noRefCallbackCleanupBeforeReact19,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
 	{
 		key: "react-doctor/no-ref-current-in-render",
 		id: "no-ref-current-in-render",