oxlint-plugin-react-doctor 0.7.9-dev.7e6cdf9 → 0.7.9-dev.8835214

package/dist/index.js

@@ -836,131 +836,22 @@ const getImportedName = (importSpecifier) => {
 	if (isNodeOfType(imported, "Literal") && typeof imported.value === "string") return imported.value;
 };
 //#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-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;
+//#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;
 	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 = {}) => {
+//#region src/plugin/utils/is-hook-call.ts
+const isHookCall$2 = (node, hookName) => {
 	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);
+	const calleeName = getCalleeName$2(node);
+	if (!calleeName) return false;
+	return typeof hookName === "string" ? calleeName === hookName : hookName.has(calleeName);
 };
 //#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";
 //#endregion
@@ -1030,12 +921,12 @@ const collectChildComponentNames = (element, into) => {
 		into.add(name);
 	});
 };
-const countEffectHookCalls = (body, scopes) => {
+const countEffectHookCalls = (body) => {
 	if (!body) return 0;
 	let count = 0;
 	walkAst(body, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isReactHookCall(child, EFFECT_HOOK_NAMES$1, scopes)) count++;
+		if (isHookCall$2(child, EFFECT_HOOK_NAMES$1)) count++;
 	});
 	return count;
 };
@@ -1061,11 +952,11 @@ const getComponentEffectIndex = (programRoot) => {
 	componentEffectIndexCache.set(programRoot, index);
 	return index;
 };
-const getSameFileComponentEffectCount = (programRoot, componentName, scopes) => {
+const getSameFileComponentEffectCount = (programRoot, componentName) => {
 	const index = getComponentEffectIndex(programRoot);
 	const cachedCount = index.effectCountByName.get(componentName);
 	if (cachedCount !== void 0) return cachedCount;
-	const count = countEffectHookCalls(index.bodyByName.get(componentName) ?? null, scopes);
+	const count = countEffectHookCalls(index.bodyByName.get(componentName) ?? null);
 	index.effectCountByName.set(componentName, count);
 	return count;
 };
@@ -1125,7 +1016,7 @@ const activityWrapsEffectHeavySubtree = defineRule({
 				let totalEffects = 0;
 				const effectfulChildren = [];
 				for (const componentName of childComponentNames) {
-					const effectCount = getSameFileComponentEffectCount(programRoot, componentName, context.scopes);
+					const effectCount = getSameFileComponentEffectCount(programRoot, componentName);
 					if (effectCount === 0) continue;
 					totalEffects += effectCount;
 					effectfulChildren.push(`<${componentName}>`);
@@ -1316,14 +1207,6 @@ 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:
@@ -1337,6 +1220,38 @@ const getCalleeName$1 = (node) => {
 */
 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, 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/resolve-exact-local-function.ts
 const resolveExactLocalFunction = (expression, scopes) => {
 	const unwrappedExpression = stripParenExpression(expression);
@@ -1382,17 +1297,9 @@ 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 REACT_STABLE_HANDLER_HOOK_NAMES = new Set(["useCallback", "useEffectEvent"]);
-const CUSTOM_STABLE_HANDLER_HOOK_NAMES = new Set([
+const STABLE_HANDLER_HOOK_NAMES = new Set([
+	"useCallback",
 	"useEffectEvent",
 	"useEvent",
 	"useEventCallback",
@@ -1401,21 +1308,21 @@ const CUSTOM_STABLE_HANDLER_HOOK_NAMES = new Set([
 ]);
 const THROTTLED_HANDLER_HOOK_PATTERN = /^use\w*(?:Throttle|Debounce)/i;
 const isThrottledHandlerHookCall = (callNode) => {
-	const calleeName = getCalleeName$1(callNode);
+	const calleeName = getCalleeName$2(callNode);
 	return calleeName !== null && THROTTLED_HANDLER_HOOK_PATTERN.test(calleeName);
 };
-const isEmptyDepsUseMemoCall = (callNode, scopes) => {
-	if (!isReactHookCall(callNode, "useMemo", scopes)) return false;
+const isEmptyDepsUseMemoCall = (callNode) => {
+	if (!isHookCall$2(callNode, "useMemo")) return false;
 	const memoDepsNode = callNode.arguments?.[1];
 	return isNodeOfType(memoDepsNode, "ArrayExpression") && (memoDepsNode.elements?.length ?? 0) === 0;
 };
-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);
+const isStableHandlerInitializer = (initializer) => {
+	if (isNodeOfType(initializer, "CallExpression")) return isHookCall$2(initializer, STABLE_HANDLER_HOOK_NAMES) || isEmptyDepsUseMemoCall(initializer) || isThrottledHandlerHookCall(initializer);
 	return isNodeOfType(initializer, "MemberExpression") && isNodeOfType(initializer.property, "Identifier") && initializer.property.name === "current";
 };
-const isStableRefReceiverDep = (referenceNode, receiverDepName, scopes) => {
+const isStableRefReceiverDep = (referenceNode, receiverDepName) => {
 	const receiverBinding = findVariableInitializer(referenceNode, receiverDepName);
-	return Boolean(receiverBinding?.initializer && isReactHookCall(receiverBinding.initializer, "useRef", scopes));
+	return Boolean(receiverBinding?.initializer && isHookCall$2(receiverBinding.initializer, "useRef"));
 };
 const advancedEventHandlerRefs = defineRule({
 	id: "advanced-event-handler-refs",
@@ -1425,7 +1332,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 (!isReactHookCall(node, EFFECT_HOOK_NAMES$1, context.scopes)) return;
+		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		if ((node.arguments?.length ?? 0) < 2) return;
 		const callback = getEffectCallback(node);
 		if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
@@ -1449,8 +1356,8 @@ const advancedEventHandlerRefs = defineRule({
 		});
 		if (!registeredHandlerName) return;
 		const handlerBinding = findVariableInitializer(node, registeredHandlerName);
-		if (handlerBinding?.initializer && isStableHandlerInitializer(handlerBinding.initializer, context.scopes)) return;
-		if ([...depIdentifierNames].some((depName) => depName !== registeredHandlerName && subscriptionReceiverNames.has(depName) && !isStableRefReceiverDep(node, depName, context.scopes))) return;
+		if (handlerBinding?.initializer && isStableHandlerInitializer(handlerBinding.initializer)) return;
+		if ([...depIdentifierNames].some((depName) => depName !== registeredHandlerName && subscriptionReceiverNames.has(depName) && !isStableRefReceiverDep(node, depName))) return;
 		context.report({
 			node,
 			message: `useEffect re-adds the "${registeredHandlerName}" listener every time the handler changes.`
@@ -1937,6 +1844,15 @@ 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",
@@ -4944,6 +4860,23 @@ 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;
@@ -9008,6 +8941,65 @@ 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",
@@ -14606,7 +14598,7 @@ const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	walkAst(componentFunction.body, (child) => {
 		if (didFindUnmountCleanup) return false;
 		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction) return;
-		if (!isReactHookCall(child, CLEANUP_EFFECT_HOOK_NAMES, context.scopes)) return;
+		if (!isHookCall$2(child, CLEANUP_EFFECT_HOOK_NAMES)) return;
 		const dependencyList = child.arguments?.[1];
 		if (!isNodeOfType(dependencyList, "ArrayExpression") || dependencyList.elements.length > 0) return;
 		const cleanupCallback = getEffectCallback(child);
@@ -15037,7 +15029,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, context) || !resolveReactRefCurrentOriginSymbol(releaseReceiver, context.scopes)) return false;
+	if (!releaseFunction || !usageFunction || !isFunctionLike$1(usageFunction) || !isReturnedEffectCleanupFunction(releaseFunction) || !resolveReactRefCurrentOriginSymbol(releaseReceiver, context.scopes)) return false;
 	const controllerKey = getListenerAbortControllerKey(usage, context);
 	const refCurrentKey = resolveExpressionKey(releaseReceiver, context);
 	if (controllerKey === null || refCurrentKey === null) return false;
@@ -15184,7 +15176,7 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	return true;
 };
 const matchesPairedReleaseVerb = (releaseVerbName, pairedVerbNames) => pairedVerbNames.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName);
-const isReturnedEffectCleanupFunction = (functionNode, context) => {
+const isReturnedEffectCleanupFunction = (functionNode) => {
 	let currentNode = functionNode;
 	let parentNode = currentNode.parent;
 	while (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
@@ -15193,10 +15185,10 @@ const isReturnedEffectCleanupFunction = (functionNode, context) => {
 	}
 	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") && isReactHookCall(effectCall, CLEANUP_EFFECT_HOOK_NAMES, context.scopes));
+	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isHookCall$2(effectCall, CLEANUP_EFFECT_HOOK_NAMES));
 };
 const isPotentiallyReachableFunction = (functionNode, context) => {
-	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode, context)) return true;
+	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode)) return true;
 	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
 	if (!bindingIdentifier) return false;
 	const symbol = context.scopes.symbolFor(bindingIdentifier);
@@ -15901,7 +15893,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 && isReactHookCall(callbackCall, "useCallback", context.scopes) && isDirectJsxEventHandlerValue(callbackCall)) return true;
+	if (isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments?.[0] === functionRoot && isHookCall$2(callbackCall, "useCallback") && isDirectJsxEventHandlerValue(callbackCall)) return true;
 	const parentNode = functionNode.parent;
 	if (isDirectJsxEventHandlerValue(functionNode)) return true;
 	if (!isNodeOfType(parentNode, "Property") || parentNode.value !== functionNode || parentNode.computed) return false;
@@ -15937,12 +15929,12 @@ const effectNeedsCleanup = defineRule({
 		};
 		return {
 			CallExpression(node) {
-				if (isReactHookCall(node, "useCallback", context.scopes)) {
+				if (isHookCall$2(node, "useCallback")) {
 					const retainedCallback = getEffectCallback(node);
 					if (retainedCallback && !isInlineRetainedHandlerFunction(retainedCallback, context)) reportRetainedLeak(retainedCallback);
 					return;
 				}
-				if (!isReactHookCall(node, CLEANUP_EFFECT_HOOK_NAMES, context.scopes)) return;
+				if (!isHookCall$2(node, CLEANUP_EFFECT_HOOK_NAMES)) return;
 				const callback = getEffectCallback(node);
 				if (!callback) return;
 				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback, context), context);
@@ -15950,7 +15942,7 @@ const effectNeedsCleanup = defineRule({
 				const firstUsage = findFirstUsageWithoutCleanup(callback, usages, context);
 				if (!firstUsage) return;
 				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
-				const hookName = getCalleeName$1(node) ?? "effect";
+				const hookName = getCalleeName$2(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.`
@@ -18823,7 +18815,7 @@ const flattenCalleeName = (callee) => {
 const PRAGMA = "React";
 const isReactFunctionCall = (node, expectedCall) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	if (getCalleeName$1(node) !== expectedCall) return false;
+	if (getCalleeName$2(node) !== expectedCall) return false;
 	if (isNodeOfType(node.callee, "MemberExpression")) {
 		const receiver = stripParenExpression(node.callee.object);
 		return isNodeOfType(receiver, "Identifier") && receiver.name === PRAGMA;
@@ -19021,14 +19013,10 @@ const hookUseState = defineRule({
 	create: (context) => {
 		const { allowDestructuredState } = resolveSettings$40(context.settings);
 		return { CallExpression(node) {
-			const callExpressionNode = node;
-			if (!isReactFunctionCall(callExpressionNode, "useState")) return;
-			const expressionRoot = findTransparentExpressionRoot(callExpressionNode);
-			const expressionParent = expressionRoot.parent;
-			if (isNodeOfType(expressionParent, "ReturnStatement")) return;
-			if (isNodeOfType(expressionParent, "ArrowFunctionExpression") && expressionParent.body === expressionRoot) return;
+			if (!isReactFunctionCall(node, "useState")) return;
 			const parent = node.parent;
 			if (!parent) return;
+			if (isNodeOfType(parent, "ReturnStatement")) return;
 			if (!isNodeOfType(parent, "VariableDeclarator")) {
 				context.report({
 					node,
@@ -19136,8 +19124,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 (!isReactHookCall(node, HOOKS_WITH_DEP_ARRAY, context.scopes)) return;
-		const depsIndex = isReactHookCall(node, "useImperativeHandle", context.scopes) ? 2 : 1;
+		if (!isHookCall$2(node, HOOKS_WITH_DEP_ARRAY)) return;
+		const depsIndex = getCalleeName$2(node) === "useImperativeHandle" ? 2 : 1;
 		const depsArgument = node.arguments[depsIndex];
 		if (!depsArgument || !isNodeOfType(depsArgument, "ArrayExpression")) return;
 		for (const element of depsArgument.elements) {
@@ -20308,7 +20296,7 @@ const isImportedSelectAtom = (callExpression) => {
 const isDeferredCallbackPosition$1 = (functionNode) => {
 	const parent = functionNode.parent;
 	if (isNodeOfType(parent, "CallExpression") && parent.arguments?.[0] === functionNode) {
-		const hookName = getCalleeName$1(parent);
+		const hookName = getCalleeName$2(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;
 	}
@@ -30379,7 +30367,7 @@ const DEFERRING_CALLEE_NAMES$1 = new Set([
 	"on",
 	"once"
 ]);
-const getCalleeName = (callee) => {
+const getCalleeName$1 = (callee) => {
 	if (!callee) return null;
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
 	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
@@ -30391,11 +30379,11 @@ const isDeferredCallbackPosition = (expression) => {
 	const parent = parentOf(expression);
 	if (!parent) return false;
 	if (isNodeOfType(parent, "CallExpression") && argumentsInclude(parent.arguments, expression)) {
-		const name = getCalleeName(parent.callee);
+		const name = getCalleeName$1(parent.callee);
 		if (name && DEFERRING_CALLEE_NAMES$1.has(name)) return true;
 	}
 	if (isNodeOfType(parent, "NewExpression") && argumentsInclude(parent.arguments, expression)) {
-		const name = getCalleeName(parent.callee);
+		const name = getCalleeName$1(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;
@@ -30815,6 +30803,14 @@ 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];
@@ -32346,7 +32342,12 @@ const noAdjustStateOnPropChange = defineRule({
 	tags: ["test-noise"],
 	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 (!isReactHookCall(node, "useEffect", context.scopes)) return;
+		if (!isReactApiCall(node, "useEffect", context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveConditionalAliases: true,
+			resolveNamedAliases: true
+		})) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const dependencyReferences = getEffectDepsRefs(analysis, node);
@@ -34369,7 +34370,7 @@ const declarationBodyContainsHookCall = (symbol) => {
 	walkAst(componentFunction, (descendant) => {
 		if (didFindHookCall) return false;
 		if (!isNodeOfType(descendant, "CallExpression")) return;
-		const calleeName = getCalleeName$1(descendant);
+		const calleeName = getCalleeName$2(descendant);
 		if (calleeName && isReactHookName(calleeName)) {
 			didFindHookCall = true;
 			return false;
@@ -34394,7 +34395,7 @@ const isReturnedFromUseCallbackAdapter = (callNode) => {
 		if (isNodeOfType(parent, "ArrowFunctionExpression")) {
 			if (parent.body !== current) return false;
 			const grandparent = parent.parent;
-			return isNodeOfType(grandparent, "CallExpression") && getCalleeName$1(grandparent) === "useCallback" && grandparent.arguments.some((argumentNode) => argumentNode === parent);
+			return isNodeOfType(grandparent, "CallExpression") && getCalleeName$2(grandparent) === "useCallback" && grandparent.arguments.some((argumentNode) => argumentNode === parent);
 		}
 		if (!isNodeOfType(parent, "ConditionalExpression") && !isNodeOfType(parent, "LogicalExpression")) return false;
 		current = parent;
@@ -36926,7 +36927,12 @@ const noDerivedState = defineRule({
 				for (const fact of collectRenderStateWriteFacts(analysis, componentBody, context.filename)) reportStateWrite(fact.callExpression, fact.stateDeclarator);
 			} }).visitors,
 			CallExpression(node) {
-				if (!isReactHookCall(node, "useEffect", context.scopes)) return;
+				if (!isReactApiCall(node, "useEffect", context.scopes, {
+					allowGlobalReactNamespace: true,
+					allowUnboundBareCalls: true,
+					resolveConditionalAliases: true,
+					resolveNamedAliases: true
+				})) return;
 				const analysis = getProgramAnalysis(node);
 				if (!analysis) return;
 				for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
@@ -36946,7 +36952,12 @@ 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 (!isReactHookCall(node, EFFECT_HOOK_NAMES$1, context.scopes)) return;
+		if (!isReactApiCall(node, EFFECT_HOOK_NAMES$1, context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveConditionalAliases: true,
+			resolveNamedAliases: true
+		})) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		if (!collectEffectStateWriteFacts(analysis, context, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
@@ -37069,7 +37080,7 @@ const getEnclosingEffectHookCallback = (node, componentFunction) => {
 		if (isFunctionLike$1(cursor)) {
 			const parent = cursor.parent ?? null;
 			if (parent && isNodeOfType(parent, "CallExpression")) {
-				const calleeName = getCalleeName$1(parent);
+				const calleeName = getCalleeName$2(parent);
 				if (calleeName !== null && EFFECT_HOOK_NAME_PATTERN.test(calleeName) && (parent.arguments ?? []).some((argument) => argument === cursor)) return cursor;
 			}
 		}
@@ -37140,7 +37151,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$1(parent);
+	const calleeName = getCalleeName$2(parent);
 	return calleeName !== null && isReactHookName(calleeName) && calleeName !== "useCallback";
 };
 const isHandlerShapedReseed = (setterCall, componentFunction) => {
@@ -37222,7 +37233,7 @@ const noDerivedUseState = defineRule({
 		return {
 			...propStackTracker.visitors,
 			CallExpression(node) {
-				if (!isReactHookCall(node, "useState", context.scopes) || !node.arguments?.length) return;
+				if (!isHookCall$2(node, "useState") || !node.arguments?.length) return;
 				const seed = unwrapInitializerSeed(node.arguments[0]);
 				const reportStalePropCopy = (propName) => {
 					if (isIntentionalSnapshotState(node)) return;
@@ -37911,7 +37922,12 @@ const collectUseStateBindings = (componentBody, scopes) => {
 			const setterElement = elements[1];
 			if (!isNodeOfType(valueElement, "Identifier") || !isNodeOfType(setterElement, "Identifier") || !isSetterIdentifier(setterElement.name)) continue;
 			if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-			if (!isReactHookCall(declarator.init, "useState", scopes)) continue;
+			if (!(scopes ? isReactApiCall(declarator.init, "useState", scopes, {
+				allowGlobalReactNamespace: true,
+				allowUnboundBareCalls: true,
+				resolveConditionalAliases: true,
+				resolveNamedAliases: true
+			}) : isHookCall$2(declarator.init, "useState"))) continue;
 			bindings.push({
 				valueName: valueElement.name,
 				setterName: setterElement.name,
@@ -38078,7 +38094,7 @@ const noDirectStateMutation = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = collectUseStateBindings(componentBody, context.scopes);
+			const bindings = collectUseStateBindings(componentBody);
 			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)));
@@ -38645,7 +38661,12 @@ const findTopLevelEffectCalls = (componentBody, scopes) => {
 		if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 		const expression = unwrapDiscardedExpression(statement);
 		if (!isNodeOfType(expression, "CallExpression")) continue;
-		if (!isReactHookCall(expression, EFFECT_HOOK_NAMES$1, scopes)) continue;
+		if (!isReactApiCall(expression, EFFECT_HOOK_NAMES$1, scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true,
+			resolveConditionalAliases: true,
+			resolveNamedAliases: true
+		})) continue;
 		effectCalls.push(expression);
 	}
 	return effectCalls;
@@ -38889,7 +38910,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$1(declarator.init);
+			const calleeName = getCalleeName$2(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);
 		}
@@ -39377,7 +39398,7 @@ const noEffectEventHandler = defineRule({
 		return {
 			...propStackTracker.visitors,
 			CallExpression(node) {
-				if (!isReactHookCall(node, EFFECT_HOOK_NAMES$1, context.scopes) || (node.arguments?.length ?? 0) < 2) return;
+				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1) || (node.arguments?.length ?? 0) < 2) return;
 				const callback = getEffectCallback(node);
 				if (!callback) return;
 				const analysis = getProgramAnalysis(node);
@@ -39497,14 +39518,14 @@ const noEffectEventInDeps = defineRule({
 			if (!isNodeOfType(declaratorNode.id, "Identifier")) return;
 			const initializer = declaratorNode.init;
 			if (!initializer || !isNodeOfType(initializer, "CallExpression")) return;
-			if (!isReactHookCall(initializer, "useEffectEvent", context.scopes)) return;
+			if (!isHookCall$2(initializer, "useEffectEvent")) return;
 			if (isNonReactEffectEventCallee(initializer.callee, declaratorNode, context.scopes)) return;
 			componentBindings.addBindingToCurrentFrame(declaratorNode.id.name);
 		} });
 		return {
 			...componentBindings.visitors,
 			CallExpression(node) {
-				if (!isReactHookCall(node, HOOKS_WITH_DEPS, context.scopes) || node.arguments.length < 2) return;
+				if (!isHookCall$2(node, HOOKS_WITH_DEPS) || node.arguments.length < 2) return;
 				if (!componentBindings.isInsideComponent()) return;
 				const depsNode = node.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) return;
@@ -39561,7 +39582,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 (!isReactHookCall(node, HOOKS_WITH_DEPS, context.scopes)) return;
+		if (!isHookCall$2(node, HOOKS_WITH_DEPS)) return;
 		const args = node.arguments ?? [];
 		if (args.length < 2) return;
 		const depsNode = args[1];
@@ -39822,7 +39843,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 (!isReactHookCall(node, "useEffect", context.scopes)) return;
+		if (!isUseEffect(node)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis || hasCleanup(analysis, node)) return;
 		const frames = collectBoundedEffectExecutionFrames(analysis, node);
@@ -40284,25 +40305,25 @@ const addDeclarationBindings = (statement, scope) => {
 	}
 	if (isNodeOfType(statement, "FunctionDeclaration") && statement.id) addPatternBindings(statement.id, scope);
 };
-const collectRenderReachableNamesFromStatements = (statements, names, scope, scopes, eventHandlerReferenceNames = /* @__PURE__ */ new Set()) => {
+const collectRenderReachableNamesFromStatements = (statements, names, scope, eventHandlerReferenceNames = /* @__PURE__ */ new Set()) => {
 	let hasReturn = false;
-	for (const statement of statements ?? []) if (collectRenderReachableNamesFromStatement(statement, names, scope, scopes, eventHandlerReferenceNames)) hasReturn = true;
+	for (const statement of statements ?? []) if (collectRenderReachableNamesFromStatement(statement, names, scope, eventHandlerReferenceNames)) hasReturn = true;
 	else addDeclarationBindings(statement, scope);
 	return hasReturn;
 };
-const collectRenderReachableNamesFromStatement = (statement, names, scope, scopes, eventHandlerReferenceNames) => {
+const collectRenderReachableNamesFromStatement = (statement, names, scope, 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) || isReactHookCall(statement.expression, BUILTIN_HOOK_NAMES, scopes)) && !isReactHookCall(statement.expression, EFFECT_HOOK_NAMES$1, scopes)) {
+	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)) {
 		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), scopes, eventHandlerReferenceNames);
+	if (isNodeOfType(statement, "BlockStatement")) return collectRenderReachableNamesFromStatements(statement.body, names, createBlockBindingScope(scope), eventHandlerReferenceNames);
 	if (isNodeOfType(statement, "IfStatement")) {
-		const consequentHasReturn = collectRenderReachableNamesFromStatement(statement.consequent, names, scope, scopes, eventHandlerReferenceNames);
-		const alternateHasReturn = statement.alternate ? collectRenderReachableNamesFromStatement(statement.alternate, names, scope, scopes, eventHandlerReferenceNames) : false;
+		const consequentHasReturn = collectRenderReachableNamesFromStatement(statement.consequent, names, scope, eventHandlerReferenceNames);
+		const alternateHasReturn = statement.alternate ? collectRenderReachableNamesFromStatement(statement.alternate, names, scope, eventHandlerReferenceNames) : false;
 		if (consequentHasReturn || alternateHasReturn) addNames(names, collectScopedReferenceNames(statement.test, scope, eventHandlerReferenceNames));
 		return consequentHasReturn || alternateHasReturn;
 	}
@@ -40310,7 +40331,7 @@ const collectRenderReachableNamesFromStatement = (statement, names, scope, scope
 		let hasReturn = false;
 		for (const switchCase of statement.cases ?? []) {
 			const caseScope = createBlockBindingScope(scope);
-			if (!collectRenderReachableNamesFromStatements(switchCase.consequent, names, caseScope, scopes, eventHandlerReferenceNames)) continue;
+			if (!collectRenderReachableNamesFromStatements(switchCase.consequent, names, caseScope, eventHandlerReferenceNames)) continue;
 			hasReturn = true;
 			if (switchCase.test) addNames(names, collectScopedReferenceNames(switchCase.test, scope, eventHandlerReferenceNames));
 		}
@@ -40318,25 +40339,25 @@ const collectRenderReachableNamesFromStatement = (statement, names, scope, scope
 		return hasReturn;
 	}
 	if (isNodeOfType(statement, "TryStatement")) {
-		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;
+		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;
 		return blockHasReturn || handlerHasReturn || finalizerHasReturn;
 	}
 	if (isNodeOfType(statement, "CatchClause")) {
 		const catchScope = createBlockBindingScope(scope);
 		addPatternBindings(statement.param, catchScope);
-		return collectRenderReachableNamesFromStatement(statement.body, names, catchScope, scopes, eventHandlerReferenceNames);
+		return collectRenderReachableNamesFromStatement(statement.body, names, catchScope, eventHandlerReferenceNames);
 	}
 	if (isNodeOfType(statement, "WhileStatement") || isNodeOfType(statement, "DoWhileStatement")) {
-		const bodyHasReturn = collectRenderReachableNamesFromStatement(statement.body, names, scope, scopes, eventHandlerReferenceNames);
+		const bodyHasReturn = collectRenderReachableNamesFromStatement(statement.body, names, scope, 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, scopes, eventHandlerReferenceNames)) return false;
+		if (!collectRenderReachableNamesFromStatement(statement.body, names, loopScope, 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));
@@ -40346,22 +40367,22 @@ const collectRenderReachableNamesFromStatement = (statement, names, scope, scope
 		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, scopes, eventHandlerReferenceNames)) return false;
+		if (!collectRenderReachableNamesFromStatement(statement.body, names, loopScope, eventHandlerReferenceNames)) return false;
 		addNames(names, rightNames);
 		return true;
 	}
-	if (isNodeOfType(statement, "LabeledStatement")) return collectRenderReachableNamesFromStatement(statement.body, names, scope, scopes, eventHandlerReferenceNames);
+	if (isNodeOfType(statement, "LabeledStatement")) return collectRenderReachableNamesFromStatement(statement.body, names, scope, eventHandlerReferenceNames);
 	if (isNodeOfType(statement, "WithStatement")) {
-		const bodyHasReturn = collectRenderReachableNamesFromStatement(statement.body, names, scope, scopes, eventHandlerReferenceNames);
+		const bodyHasReturn = collectRenderReachableNamesFromStatement(statement.body, names, scope, eventHandlerReferenceNames);
 		if (bodyHasReturn) addNames(names, collectScopedReferenceNames(statement.object, scope, eventHandlerReferenceNames));
 		return bodyHasReturn;
 	}
 	return false;
 };
-const collectRenderReachableNames = (componentBody, scopes, eventHandlerReferenceNames = /* @__PURE__ */ new Set()) => {
+const collectRenderReachableNames = (componentBody, eventHandlerReferenceNames = /* @__PURE__ */ new Set()) => {
 	const names = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(componentBody, "BlockStatement")) return names;
-	collectRenderReachableNamesFromStatements(componentBody.body, names, createComponentBindingScope(), scopes, eventHandlerReferenceNames);
+	collectRenderReachableNamesFromStatements(componentBody.body, names, createComponentBindingScope(), eventHandlerReferenceNames);
 	return names;
 };
 //#endregion
@@ -40384,36 +40405,42 @@ const expandTransitiveDependencies = (seedNames, dependencyGraph) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/collect-function-like-local-names.ts
-const isFunctionLikeReference = (node, functionLikeLocalNames, scope, scopes) => {
-	if (isInlineFunctionExpression(node) || isReactHookCall(node, "useCallback", scopes)) return true;
+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;
 	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, scopes) => {
+const addObjectPropertyFunctionNames = (objectBindingName, node, functionLikeLocalNames, scope) => {
 	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, scopes)) continue;
+		if (!isFunctionLikeReference(property.value, functionLikeLocalNames, scope)) continue;
 		functionLikeLocalNames.add(`${objectBindingName}.${propertyName}`);
 	}
 };
-const addVariableDeclarationFunctionNames = (statement, functionLikeLocalNames, scope, scopes) => {
+const addVariableDeclarationFunctionNames = (statement, functionLikeLocalNames, scope) => {
 	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, scopes);
+		const isFunctionReference = isFunctionLikeReference(declarator.init, functionLikeLocalNames, scope);
 		for (const declaredBindingName of declaredBindingNames) {
 			if (isFunctionReference) functionLikeLocalNames.add(declaredBindingName);
-			addObjectPropertyFunctionNames(declaredBindingName, declarator.init, functionLikeLocalNames, scope, scopes);
+			addObjectPropertyFunctionNames(declaredBindingName, declarator.init, functionLikeLocalNames, scope);
 		}
 	}
 };
-const collectStatementFunctionNames = (statement, functionLikeLocalNames, scope, scopes) => {
+const collectStatementFunctionNames = (statement, functionLikeLocalNames, scope) => {
 	if (isNodeOfType(statement, "FunctionDeclaration")) {
 		if (statement.id) {
 			const declaredBindingNames = addPatternBindings(statement.id, scope);
@@ -40422,61 +40449,61 @@ const collectStatementFunctionNames = (statement, functionLikeLocalNames, scope,
 		return;
 	}
 	if (isNodeOfType(statement, "VariableDeclaration")) {
-		addVariableDeclarationFunctionNames(statement, functionLikeLocalNames, scope, scopes);
+		addVariableDeclarationFunctionNames(statement, functionLikeLocalNames, scope);
 		return;
 	}
 	if (isNodeOfType(statement, "BlockStatement")) {
-		collectStatementListFunctionNames(statement.body, functionLikeLocalNames, createBlockBindingScope(scope), scopes);
+		collectStatementListFunctionNames(statement.body, functionLikeLocalNames, createBlockBindingScope(scope));
 		return;
 	}
 	if (isNodeOfType(statement, "IfStatement")) {
-		collectStatementFunctionNames(statement.consequent, functionLikeLocalNames, scope, scopes);
-		if (statement.alternate) collectStatementFunctionNames(statement.alternate, functionLikeLocalNames, scope, scopes);
+		collectStatementFunctionNames(statement.consequent, functionLikeLocalNames, scope);
+		if (statement.alternate) collectStatementFunctionNames(statement.alternate, functionLikeLocalNames, scope);
 		return;
 	}
 	if (isNodeOfType(statement, "SwitchStatement")) {
-		for (const switchCase of statement.cases ?? []) collectStatementListFunctionNames(switchCase.consequent, functionLikeLocalNames, createBlockBindingScope(scope), scopes);
+		for (const switchCase of statement.cases ?? []) collectStatementListFunctionNames(switchCase.consequent, functionLikeLocalNames, createBlockBindingScope(scope));
 		return;
 	}
 	if (isNodeOfType(statement, "TryStatement")) {
-		collectStatementFunctionNames(statement.block, functionLikeLocalNames, scope, scopes);
+		collectStatementFunctionNames(statement.block, functionLikeLocalNames, scope);
 		if (statement.handler) {
 			const catchScope = createBlockBindingScope(scope);
 			addPatternBindings(statement.handler.param, catchScope);
-			collectStatementFunctionNames(statement.handler.body, functionLikeLocalNames, catchScope, scopes);
+			collectStatementFunctionNames(statement.handler.body, functionLikeLocalNames, catchScope);
 		}
-		if (statement.finalizer) collectStatementFunctionNames(statement.finalizer, functionLikeLocalNames, scope, scopes);
+		if (statement.finalizer) collectStatementFunctionNames(statement.finalizer, functionLikeLocalNames, scope);
 		return;
 	}
 	if (isNodeOfType(statement, "ForStatement")) {
 		const loopScope = createBlockBindingScope(scope);
-		if (statement.init && isNodeOfType(statement.init, "VariableDeclaration")) addVariableDeclarationFunctionNames(statement.init, functionLikeLocalNames, loopScope, scopes);
-		collectStatementFunctionNames(statement.body, functionLikeLocalNames, loopScope, scopes);
+		if (statement.init && isNodeOfType(statement.init, "VariableDeclaration")) addVariableDeclarationFunctionNames(statement.init, functionLikeLocalNames, loopScope);
+		collectStatementFunctionNames(statement.body, functionLikeLocalNames, loopScope);
 		return;
 	}
 	if (isNodeOfType(statement, "ForInStatement") || isNodeOfType(statement, "ForOfStatement")) {
 		const loopScope = createBlockBindingScope(scope);
-		if (isNodeOfType(statement.left, "VariableDeclaration")) addVariableDeclarationFunctionNames(statement.left, functionLikeLocalNames, loopScope, scopes);
+		if (isNodeOfType(statement.left, "VariableDeclaration")) addVariableDeclarationFunctionNames(statement.left, functionLikeLocalNames, loopScope);
 		else addPatternBindings(statement.left, loopScope);
-		collectStatementFunctionNames(statement.body, functionLikeLocalNames, loopScope, scopes);
+		collectStatementFunctionNames(statement.body, functionLikeLocalNames, loopScope);
 		return;
 	}
 	if (isNodeOfType(statement, "WhileStatement") || isNodeOfType(statement, "DoWhileStatement")) {
-		collectStatementFunctionNames(statement.body, functionLikeLocalNames, scope, scopes);
+		collectStatementFunctionNames(statement.body, functionLikeLocalNames, scope);
 		return;
 	}
-	if (isNodeOfType(statement, "LabeledStatement")) collectStatementFunctionNames(statement.body, functionLikeLocalNames, scope, scopes);
+	if (isNodeOfType(statement, "LabeledStatement")) collectStatementFunctionNames(statement.body, functionLikeLocalNames, scope);
 };
-const collectStatementListFunctionNames = (statements, functionLikeLocalNames, scope, scopes) => {
-	for (const statement of statements ?? []) collectStatementFunctionNames(statement, functionLikeLocalNames, scope, scopes);
+const collectStatementListFunctionNames = (statements, functionLikeLocalNames, scope) => {
+	for (const statement of statements ?? []) collectStatementFunctionNames(statement, functionLikeLocalNames, scope);
 };
-const collectFunctionLikeLocalNames = (componentBody, scopes) => {
+const collectFunctionLikeLocalNames = (componentBody) => {
 	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(), scopes);
+		collectStatementListFunctionNames(componentBody.body, functionLikeLocalNames, createComponentBindingScope());
 	}
 	return functionLikeLocalNames;
 };
@@ -40516,17 +40543,17 @@ const noEventTriggerState = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const useStateBindings = collectUseStateBindings(componentBody, context.scopes);
+			const useStateBindings = collectUseStateBindings(componentBody);
 			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, context.scopes);
+			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody);
 			const dependencyGraph = buildLocalDependencyGraph(componentBody, eventHandlerReferenceNames);
-			const renderReachableNames = expandTransitiveDependencies(collectRenderReachableNames(componentBody, context.scopes, eventHandlerReferenceNames), dependencyGraph);
+			const renderReachableNames = expandTransitiveDependencies(collectRenderReachableNames(componentBody, eventHandlerReferenceNames), dependencyGraph);
 			walkAst(componentBody, (effectCall) => {
 				if (!isNodeOfType(effectCall, "CallExpression")) return;
-				if (!isReactHookCall(effectCall, EFFECT_HOOK_NAMES$1, context.scopes)) return;
+				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) return;
 				if ((effectCall.arguments?.length ?? 0) < 2) return;
 				const depsNode = effectCall.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) return;
@@ -40591,17 +40618,10 @@ const isShadowedByLocalBinding = (identifier) => {
 };
 const isRealFetchCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (isNodeOfType(callee, "Identifier") && FETCH_CALLEE_NAMES.has(callee.name)) return !isShadowedByLocalBinding(callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && FETCH_MEMBER_OBJECTS.has(receiver.name) && !isShadowedByLocalBinding(receiver);
-};
-const isXmlHttpRequestConstruction = (node) => {
-	if (!isNodeOfType(node, "NewExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	return isNodeOfType(callee, "Identifier") && callee.name === "XMLHttpRequest";
+	if (isNodeOfType(node.callee, "Identifier") && FETCH_CALLEE_NAMES.has(node.callee.name)) return !isShadowedByLocalBinding(node.callee);
+	return isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && FETCH_MEMBER_OBJECTS.has(node.callee.object.name) && !isShadowedByLocalBinding(node.callee.object);
 };
+const isXmlHttpRequestConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "XMLHttpRequest";
 const isNetworkRequest = (node) => isRealFetchCall(node) || isXmlHttpRequestConstruction(node);
 const resolveLocalFunction = (expression, context) => {
 	if (!expression) return null;
@@ -42362,7 +42382,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 (!isReactHookCall(node, "useEffect", context.scopes)) return;
+		if (!isUseEffect(node)) return;
 		const dependencies = node.arguments?.[1];
 		if (!dependencies || !isNodeOfType(dependencies, "ArrayExpression") || (dependencies.elements ?? []).length !== 0) return;
 		const analysis = getProgramAnalysis(node);
@@ -43974,7 +43994,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 (!isReactHookCall(declarator.init, "useState", context.scopes)) continue;
+					if (!isHookCall$2(declarator.init, "useState")) continue;
 					const initializer = declarator.init.arguments?.[0];
 					if (!initializer) continue;
 					const propRootName = getPropRootName(initializer, propNames);
@@ -43992,7 +44012,7 @@ const noMirrorPropEffect = defineRule({
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
-				if (!isReactHookCall(effectCall, EFFECT_HOOK_NAMES$1, context.scopes)) continue;
+				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const depsNode = effectCall.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) continue;
@@ -44401,7 +44421,7 @@ const noMultiComp = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-mutable-in-deps.ts
-const collectUseRefBindingNames = (componentBody, scopes) => {
+const collectUseRefBindingNames = (componentBody) => {
 	const useRefBindings = /* @__PURE__ */ new Set();
 	if (!isNodeOfType(componentBody, "BlockStatement")) return useRefBindings;
 	for (const statement of componentBody.body ?? []) {
@@ -44409,7 +44429,7 @@ const collectUseRefBindingNames = (componentBody, scopes) => {
 		for (const declarator of statement.declarations ?? []) {
 			if (!isNodeOfType(declarator.id, "Identifier")) continue;
 			if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-			if (!isReactHookCall(declarator.init, "useRef", scopes)) continue;
+			if (!isHookCall$2(declarator.init, "useRef")) continue;
 			useRefBindings.add(declarator.id.name);
 		}
 	}
@@ -44444,12 +44464,12 @@ const noMutableInDeps = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody, componentParams = []) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const useRefBindingNames = collectUseRefBindingNames(componentBody, context.scopes);
+			const useRefBindingNames = collectUseRefBindingNames(componentBody);
 			const localBindingNames = collectLocalBindingNames(componentBody);
 			for (const param of componentParams) collectPatternNames(param, localBindingNames);
 			walkAst(componentBody, (child) => {
 				if (!isNodeOfType(child, "CallExpression")) return;
-				if (!isReactHookCall(child, HOOKS_WITH_DEPS, context.scopes)) return;
+				if (!isHookCall$2(child, HOOKS_WITH_DEPS)) return;
 				if ((child.arguments?.length ?? 0) < 2) return;
 				const depsNode = child.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) return;
@@ -46362,10 +46382,16 @@ 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) => isReactHookCall(node, "useRef", context.scopes);
-		const isReactUseEffectCall = (node) => isReactHookCall(node, "useEffect", context.scopes);
+		const isReactUseRefCall = (node) => isReactApiCall(node, "useRef", context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true
+		});
+		const isReactUseEffectCall = (node) => isReactApiCall(node, "useEffect", context.scopes, {
+			allowGlobalReactNamespace: true,
+			allowUnboundBareCalls: true
+		});
 		return { CallExpression(node) {
-			if (!isReactUseEffectCall(node)) return;
+			if (!isUseEffect(node)) return;
 			const analysis = getProgramAnalysis(node);
 			if (!analysis) return;
 			if (hasCleanup(analysis, node)) return;
@@ -46652,7 +46678,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 (!isReactHookCall(node, "useEffect", context.scopes)) return;
+		if (!isUseEffect(node)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const effectFnRefs = getEffectFnRefs(analysis, node);
@@ -47067,7 +47093,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$1(binding.initializer);
+		const calleeName = getCalleeName$2(binding.initializer);
 		if (calleeName && PREVIOUS_VALUE_HOOK_PATTERN.test(calleeName)) return true;
 	}
 	return false;
@@ -47089,7 +47115,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$1(binding.initializer) !== "useRef") return null;
+	if (getCalleeName$2(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;
@@ -47121,7 +47147,7 @@ const noPropCallbackInEffect = defineRule({
 		return {
 			...propStackTracker.visitors,
 			CallExpression(node) {
-				if (!isReactHookCall(node, EFFECT_HOOK_NAMES$1, context.scopes) || (node.arguments?.length ?? 0) < 2) return;
+				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1) || (node.arguments?.length ?? 0) < 2) return;
 				const callback = getEffectCallback(node);
 				if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
 				const depsNode = node.arguments[1];
@@ -49014,7 +49040,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 (!isReactHookCall(node, "useEffect", context.scopes)) return;
+		if (!isUseEffect(node)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const effectFnRefs = getEffectFnRefs(analysis, node);
@@ -49283,7 +49309,7 @@ const isTanStackServerFnHandlerCall = (node) => {
 	if (node.callee.property.name !== "handler") return false;
 	let currentNode = node.callee.object;
 	while (isNodeOfType(currentNode, "CallExpression")) {
-		const calleeName = getCalleeName$1(currentNode);
+		const calleeName = getCalleeName$2(currentNode);
 		if (calleeName && TANSTACK_SERVER_FN_NAMES.has(calleeName)) return true;
 		if (!isNodeOfType(currentNode.callee, "MemberExpression")) return false;
 		currentNode = currentNode.callee.object;
@@ -49784,7 +49810,7 @@ const noSelfUpdatingEffect = defineRule({
 	create: (context) => {
 		const checkFunctionScope = (functionBody) => {
 			if (!functionBody || !isNodeOfType(functionBody, "BlockStatement")) return;
-			const useStateBindings = collectUseStateBindings(functionBody, context.scopes);
+			const useStateBindings = collectUseStateBindings(functionBody);
 			if (useStateBindings.length === 0) return;
 			const setterNameToStateName = /* @__PURE__ */ new Map();
 			for (const binding of useStateBindings) setterNameToStateName.set(binding.setterName, binding.valueName);
@@ -49793,7 +49819,7 @@ const noSelfUpdatingEffect = defineRule({
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
-				if (!isReactHookCall(effectCall, EFFECT_HOOK_NAMES$1, context.scopes)) continue;
+				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const dependencyStateNames = collectDependencyStateNames(effectCall.arguments[1]);
 				if (dependencyStateNames.size === 0) continue;
@@ -49879,7 +49905,7 @@ const noSetStateInRender = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const setterNames = new Set(collectUseStateBindings(componentBody, context.scopes).map((binding) => binding.setterName));
+			const setterNames = new Set(collectUseStateBindings(componentBody).map((binding) => binding.setterName));
 			if (setterNames.size === 0) return;
 			for (const statement of componentBody.body ?? []) {
 				const setterCall = isUnconditionalSetterCallStatement(statement, setterNames);
@@ -50128,10 +50154,10 @@ const collectTimerRefUsageFacts = (ownerScope, refName) => {
 	});
 	return facts;
 };
-const isEffectCallbackFunction = (functionNode, scopes) => {
+const isEffectCallbackFunction = (functionNode) => {
 	const parent = functionNode.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
-	return isReactHookCall(parent, EFFECT_HOOK_NAMES$1, scopes) && getEffectCallback(parent) === functionNode;
+	return isHookCall$2(parent, EFFECT_HOOK_NAMES$1) && getEffectCallback(parent) === functionNode;
 };
 const doesEffectCallbackReturnName = (effectCallback, name) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
@@ -50150,24 +50176,24 @@ const isFunctionReturnedFromEffectCallback = (functionNode, effectCallback) => {
 	const cleanupBindingName = getFunctionBindingName$1(functionNode);
 	return cleanupBindingName !== null && doesEffectCallbackReturnName(effectCallback, cleanupBindingName);
 };
-const isReturnedFromAnyEffectInScope = (functionNode, ownerScope, scopes) => {
+const isReturnedFromAnyEffectInScope = (functionNode, ownerScope) => {
 	const cleanupBindingName = getFunctionBindingName$1(functionNode);
 	if (cleanupBindingName === null) return false;
 	let isReturnedFromEffect = false;
 	walkAst(ownerScope, (child) => {
 		if (isReturnedFromEffect) return false;
-		if (!isNodeOfType(child, "CallExpression") || !isReactHookCall(child, EFFECT_HOOK_NAMES$1, scopes)) return;
+		if (!isNodeOfType(child, "CallExpression") || !isHookCall$2(child, EFFECT_HOOK_NAMES$1)) return;
 		const effectCallback = getEffectCallback(child);
 		if (effectCallback && doesEffectCallbackReturnName(effectCallback, cleanupBindingName)) isReturnedFromEffect = true;
 	});
 	return isReturnedFromEffect;
 };
-const isInsideEffectCleanupReturn = (node, ownerScope, scopes) => {
+const isInsideEffectCleanupReturn = (node, ownerScope) => {
 	let functionNode = findEnclosingFunction$1(node);
 	while (functionNode) {
 		const outerFunction = findEnclosingFunction$1(functionNode);
-		if (outerFunction && isEffectCallbackFunction(outerFunction, scopes) && isFunctionReturnedFromEffectCallback(functionNode, outerFunction)) return true;
-		if (isReturnedFromAnyEffectInScope(functionNode, ownerScope, scopes)) return true;
+		if (outerFunction && isEffectCallbackFunction(outerFunction) && isFunctionReturnedFromEffectCallback(functionNode, outerFunction)) return true;
+		if (isReturnedFromAnyEffectInScope(functionNode, ownerScope)) return true;
 		functionNode = outerFunction;
 	}
 	return false;
@@ -50203,10 +50229,10 @@ const noStaleTimerRef = defineRule({
 		if (isShadowedTimerGlobal(node)) return;
 		const { clearCalleeName, refName } = clearCall;
 		const refBinding = findVariableInitializer(node, refName);
-		if (!refBinding?.initializer || !isReactHookCall(refBinding.initializer, "useRef", context.scopes)) return;
+		if (!refBinding?.initializer || !isHookCall$2(refBinding.initializer, "useRef")) return;
 		const usageFacts = collectTimerRefUsageFacts(refBinding.scopeOwner, refName);
 		if (!usageFacts.holdsScheduledTimerId || !usageFacts.hasPendingSignalRead) return;
-		if (isInsideEffectCleanupReturn(node, refBinding.scopeOwner, context.scopes)) return;
+		if (isInsideEffectCleanupReturn(node, refBinding.scopeOwner)) return;
 		if (hasRefCurrentReassignmentAfterClear(node, refName)) return;
 		context.report({
 			node,
@@ -56010,7 +56036,7 @@ const classifyCallableReadsInsideEffect = (callableIdentifier, effectCallback, c
 			allReadsAreInSubHandlers = false;
 			return;
 		}
-		if (firstSubHandlerName === null) firstSubHandlerName = getCalleeName$1(subHandlerCall);
+		if (firstSubHandlerName === null) firstSubHandlerName = getCalleeName$2(subHandlerCall);
 	});
 	return {
 		hasAnyRead,
@@ -56033,7 +56059,7 @@ const preferUseEffectEvent = defineRule({
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 				const effectCall = statement.expression;
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
-				if (!isReactHookCall(effectCall, EFFECT_HOOK_NAMES$1, context.scopes)) continue;
+				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const depsNode = effectCall.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression")) continue;
@@ -56065,11 +56091,11 @@ const preferUseEffectEvent = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/prefer-use-sync-external-store.ts
-const findUseEffectsInComponent = (componentBody, scopes) => {
+const findUseEffectsInComponent = (componentBody) => {
 	const effectCalls = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return effectCalls;
 	for (const statement of componentBody.body ?? []) walkAst(statement, (child) => {
-		if (isNodeOfType(child, "CallExpression") && isReactHookCall(child, EFFECT_HOOK_NAMES$1, scopes)) effectCalls.push(child);
+		if (isNodeOfType(child, "CallExpression") && isHookCall$2(child, EFFECT_HOOK_NAMES$1)) effectCalls.push(child);
 	});
 	return effectCalls;
 };
@@ -56272,7 +56298,7 @@ const preferUseSyncExternalStore = defineRule({
 		};
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const useStateBindings = collectUseStateBindings(componentBody, context.scopes);
+			const useStateBindings = collectUseStateBindings(componentBody);
 			if (useStateBindings.length === 0) return;
 			const useStateInitializerByValueName = /* @__PURE__ */ new Map();
 			for (const binding of useStateBindings) {
@@ -56285,7 +56311,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, context.scopes)) {
+			for (const effectCall of findUseEffectsInComponent(componentBody)) {
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const depsNode = effectCall.arguments[1];
@@ -56327,7 +56353,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, context.scopes)) {
+			for (const effectCall of findUseEffectsInComponent(componentBody)) {
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
 				const depsNode = effectCall.arguments[1];
@@ -56424,7 +56450,7 @@ const preferUseReducer = defineRule({
 	create: (context) => {
 		const reportCoUpdatedUseState = (body, componentName) => {
 			if (!isNodeOfType(body, "BlockStatement")) return;
-			const bindings = collectUseStateBindings(body, context.scopes);
+			const bindings = collectUseStateBindings(body);
 			const setterNames = new Set(bindings.map((binding) => binding.setterName));
 			if (setterNames.size < 5) return;
 			const coUpdatedCount = findLargestCoUpdatedSetterGroup(body, setterNames, new Map(bindings.map((binding) => {
@@ -56640,7 +56666,7 @@ const QUERY_READ_METHOD_NAMES = new Set([
 ]);
 const isQueryCacheSourceCall = (initializer) => {
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	const hookName = getCalleeName$1(initializer);
+	const hookName = getCalleeName$2(initializer);
 	if (!hookName) return false;
 	return hookName === "useQueryClient" || TRPC_UTILS_HOOK_PATTERN.test(hookName);
 };
@@ -56772,7 +56798,7 @@ const queryMutationMissingInvalidation = defineRule({
 			},
 			CallExpression(node) {
 				if (!hasQueryReadUsage) {
-					const callName = getCalleeName$1(node);
+					const callName = getCalleeName$2(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;
@@ -57265,30 +57291,26 @@ const REMOVAL_MESSAGE_BY_REACT_API_NAME = new Map([
 	["useCallback", "This `useCallback` is dead weight, since React Compiler already caches every function here. Delete it."],
 	["memo", "This `memo()` is dead weight, since React Compiler already caches the component's output. Delete it."]
 ]);
-const resolveReactApiNameForIdentifier = (callee, context) => {
+const resolveReactApiNameForIdentifier = (callee) => {
 	if (!isNodeOfType(callee, "Identifier")) return null;
-	if (context.scopes.symbolFor(callee)?.kind !== "import") return null;
 	const importedName = getImportedNameFromModule(callee, callee.name, "react");
 	if (importedName && REMOVAL_MESSAGE_BY_REACT_API_NAME.has(importedName)) return importedName;
 	return null;
 };
-const resolveReactApiNameForMemberExpression = (callee, context) => {
+const resolveReactApiNameForMemberExpression = (callee) => {
 	if (!isNodeOfType(callee, "MemberExpression")) return null;
 	if (callee.computed) return null;
-	const namespaceIdentifier = stripParenExpression(callee.object);
+	const namespaceIdentifier = callee.object;
 	const propertyIdentifier = callee.property;
 	if (!isNodeOfType(namespaceIdentifier, "Identifier")) return null;
 	if (!isNodeOfType(propertyIdentifier, "Identifier")) return null;
 	if (!REMOVAL_MESSAGE_BY_REACT_API_NAME.has(propertyIdentifier.name)) return null;
 	const namespaceName = namespaceIdentifier.name;
-	if (context.scopes.symbolFor(namespaceIdentifier)?.kind === "import" && isImportedFromModule(namespaceIdentifier, namespaceName, "react")) return propertyIdentifier.name;
-	if (isCanonicalReactNamespaceName(namespaceName) && context.scopes.isGlobalReference(namespaceIdentifier)) return propertyIdentifier.name;
+	if (isCanonicalReactNamespaceName(namespaceName)) return propertyIdentifier.name;
+	if (isImportedFromModule(namespaceIdentifier, namespaceName, "react")) return propertyIdentifier.name;
 	return null;
 };
-const resolveReactApiNameForCallee = (callee, context) => {
-	const unwrappedCallee = stripParenExpression(callee);
-	return resolveReactApiNameForIdentifier(unwrappedCallee, context) ?? resolveReactApiNameForMemberExpression(unwrappedCallee, context);
-};
+const resolveReactApiNameForCallee = (callee) => resolveReactApiNameForIdentifier(callee) ?? resolveReactApiNameForMemberExpression(callee);
 const isNullishComparatorArgument = (argumentNode) => isNodeOfType(argumentNode, "Identifier") && argumentNode.name === "undefined" || isNodeOfType(argumentNode, "Literal") && argumentNode.value === null;
 const COMPILER_INFERABLE_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const calleeTrailingName = (callee) => {
@@ -57314,7 +57336,7 @@ const reactCompilerNoManualMemoization = defineRule({
 	requires: ["react-compiler"],
 	recommendation: "Delete the `useMemo` / `useCallback` / `memo` call and use the plain value or component. React Compiler caches it for you.",
 	create: (context) => ({ CallExpression(node) {
-		const apiName = resolveReactApiNameForCallee(node.callee, context);
+		const apiName = resolveReactApiNameForCallee(node.callee);
 		if (!apiName) return;
 		if (apiName === "memo") {
 			const comparatorArgument = node.arguments?.[1];
@@ -59064,7 +59086,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 (!isReactHookCall(node, HOOKS_WITH_DEPS, context.scopes) || node.arguments.length < 2) return;
+		if (!isHookCall$2(node, HOOKS_WITH_DEPS) || node.arguments.length < 2) return;
 		const depsNode = node.arguments[1];
 		if (!isNodeOfType(depsNode, "ArrayExpression")) return;
 		for (const element of depsNode.elements ?? []) {
@@ -59319,7 +59341,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 (!isReactHookCall(node, "useRef", context.scopes) || !node.arguments?.length) return;
+		if (!isHookCall$2(node, "useRef") || !node.arguments?.length) return;
 		const initializer = stripParenExpression(node.arguments[0]);
 		const isPlainCall = isNodeOfType(initializer, "CallExpression");
 		const isNewCall = isNodeOfType(initializer, "NewExpression");
@@ -59383,7 +59405,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 (!isReactHookCall(node, "useState", context.scopes) || !node.arguments?.length) return;
+		if (!isHookCall$2(node, "useState") || !node.arguments?.length) return;
 		const initializer = findEagerInitializerCall(node.arguments[0]);
 		if (!initializer) return;
 		const isConstructor = isNodeOfType(initializer, "NewExpression");
@@ -60146,11 +60168,11 @@ const isInsideConditionTest = (identifier, stopAt) => {
 	}
 	return false;
 };
-const collectEffectDependencyInfos = (componentBody, setterNames, scopes) => {
+const collectEffectDependencyInfos = (componentBody, setterNames) => {
 	const effectInfos = [];
 	walkAst(componentBody, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
-		if (!isReactHookCall(child, EFFECT_HOOK_NAMES$1, scopes)) return;
+		if (!isHookCall$2(child, EFFECT_HOOK_NAMES$1)) return;
 		const dependencyNames = /* @__PURE__ */ new Set();
 		for (const argument of child.arguments ?? []) {
 			if (!isNodeOfType(argument, "ArrayExpression")) continue;
@@ -60206,14 +60228,13 @@ const collectEffectDependencyInfos = (componentBody, setterNames, scopes) => {
 	});
 	return effectInfos;
 };
-const collectCustomHookArgumentNames = (componentBody, scopes) => {
+const collectCustomHookArgumentNames = (componentBody) => {
 	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) => {
@@ -60254,21 +60275,21 @@ const rerenderStateOnlyInHandlers = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = collectUseStateBindings(componentBody, context.scopes);
+			const bindings = collectUseStateBindings(componentBody);
 			if (bindings.length === 0) return;
 			if (collectRenderReachableExpressions(componentBody).length === 0) return;
-			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody, context.scopes);
+			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody);
 			const dependencyGraph = buildLocalDependencyGraph(componentBody, eventHandlerReferenceNames);
-			const directRenderNames = collectRenderReachableNames(componentBody, context.scopes, eventHandlerReferenceNames);
+			const directRenderNames = collectRenderReachableNames(componentBody, 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, context.scopes);
+			const effectInfos = collectEffectDependencyInfos(componentBody, setterNames);
 			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, context.scopes)) effectConsumedNames.add(hookArgumentName);
+			for (const hookArgumentName of collectCustomHookArgumentNames(componentBody)) effectConsumedNames.add(hookArgumentName);
 			for (const reachableName of expandTransitiveDependencies(effectConsumedNames, dependencyGraph)) renderReachableNames.add(reachableName);
 			const calledSetterNames = /* @__PURE__ */ new Set();
 			walkAst(componentBody, (child) => {
@@ -68169,7 +68190,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$1(argument);
+		const calleeName = getCalleeName$2(argument);
 		if (!calleeName) continue;
 		if (isAuthGuardName(calleeName)) return true;
 		const [leadingToken] = tokenizeIdentifierWords(calleeName);
@@ -68809,7 +68830,7 @@ const walkServerFnChain = (outerNode) => {
 	if (!isNodeOfType(outerNode.callee, "MemberExpression")) return result;
 	let currentNode = stripParenExpression(outerNode.callee.object);
 	while (isNodeOfType(currentNode, "CallExpression")) {
-		const calleeName = getCalleeName$1(currentNode);
+		const calleeName = getCalleeName$2(currentNode);
 		if (calleeName && TANSTACK_SERVER_FN_NAMES.has(calleeName)) {
 			result.isServerFnChain = true;
 			const optionsArgument = currentNode.arguments?.[0];