oxlint-plugin-react-doctor 0.7.4-dev.63fc41f → 0.7.4-dev.70b5d99

package/dist/index.js

@@ -1915,10 +1915,7 @@ const isGeneratedImageRenderContext = (context, node) => {
 	if (!node) return false;
 	const programRoot = findProgramRoot(node);
 	if (!programRoot) return false;
-	const generatedImageJsxNodes = collectGeneratedImageJsxNodes(programRoot);
-	if (generatedImageJsxNodes.has(node)) return true;
-	if (isNodeOfType(node, "JSXElement")) return generatedImageJsxNodes.has(node.openingElement);
-	return false;
+	return collectGeneratedImageJsxNodes(programRoot).has(node);
 };
 //#endregion
 //#region src/plugin/utils/object-has-accessible-child.ts
@@ -8406,54 +8403,6 @@ const effectListenerCleanupMismatch = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/collect-effect-invoked-functions.ts
-const PROMISE_CHAIN_METHOD_NAMES$1 = new Set([
-	"then",
-	"catch",
-	"finally"
-]);
-const collectEffectInvokedFunctions = (effectCallback) => {
-	const invokedFunctions = new Set([effectCallback]);
-	const localFunctionBindings = /* @__PURE__ */ new Map();
-	const calledBindingNames = /* @__PURE__ */ new Set();
-	const pendingFunctions = [effectCallback];
-	const enqueue = (candidate) => {
-		const strippedCandidate = candidate ? stripParenExpression(candidate) : candidate;
-		if (!isFunctionLike$1(strippedCandidate) || invokedFunctions.has(strippedCandidate)) return;
-		invokedFunctions.add(strippedCandidate);
-		pendingFunctions.push(strippedCandidate);
-	};
-	const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
-	while (pendingFunctions.length > 0) {
-		const currentFunction = pendingFunctions.pop();
-		if (!currentFunction) break;
-		walkAst(currentFunction, (child) => {
-			if (child !== currentFunction && isFunctionLike$1(child)) {
-				if (isNodeOfType(child, "FunctionDeclaration") && isNodeOfType(child.id, "Identifier")) localFunctionBindings.set(child.id.name, child);
-				return false;
-			}
-			if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
-				const initializer = child.init ? stripParenExpression(child.init) : null;
-				if (isFunctionLike$1(initializer)) localFunctionBindings.set(child.id.name, initializer);
-				return;
-			}
-			if (!isNodeOfType(child, "CallExpression")) return;
-			const callee = stripParenExpression(child.callee);
-			if (isFunctionLike$1(callee)) {
-				enqueue(callee);
-				return;
-			}
-			if (isNodeOfType(callee, "Identifier")) {
-				calledBindingNames.add(callee.name);
-				return;
-			}
-			if (isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
-		});
-		for (const calledName of calledBindingNames) enqueue(localFunctionBindings.get(calledName));
-	}
-	return invokedFunctions;
-};
-//#endregion
 //#region src/plugin/utils/is-react-hook-name.ts
 const isReactHookName = (name) => {
 	if (!name.startsWith("use")) return false;
@@ -8509,90 +8458,46 @@ const enclosingComponentOrHookName = (node) => {
 	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
 };
 //#endregion
-//#region src/plugin/utils/find-declarator-for-binding.ts
-const findDeclaratorForBinding = (bindingIdentifier) => {
-	let ancestor = bindingIdentifier.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "VariableDeclarator")) return ancestor;
-		if (isNodeOfType(ancestor, "FunctionDeclaration") || isNodeOfType(ancestor, "FunctionExpression") || isNodeOfType(ancestor, "ArrowFunctionExpression") || isNodeOfType(ancestor, "Program")) return null;
-		ancestor = ancestor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/executes-during-render.ts
-const SYNCHRONOUS_ITERATION_METHOD_NAMES$1 = new Set([
-	"map",
-	"filter",
-	"forEach",
-	"flatMap",
-	"reduce",
-	"reduceRight",
-	"some",
-	"every",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"sort",
-	"toSorted"
-]);
-const REACT_RENDER_PHASE_HOOK_NAMES = new Set(["useMemo", "useState"]);
-const isGlobalArrayFromMember = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "MemberExpression") || unwrappedNode.computed || !isNodeOfType(unwrappedNode.object, "Identifier") || unwrappedNode.object.name !== "Array" || !scopes.isGlobalReference(unwrappedNode.object) || !isNodeOfType(unwrappedNode.property, "Identifier")) return false;
-	return unwrappedNode.property.name === "from";
-};
-const isConstAliasOfGlobalArrayFrom = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "Identifier")) return false;
-	const binding = findVariableInitializer(unwrappedNode, unwrappedNode.name);
-	if (!binding?.initializer) return false;
-	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
-	return Boolean(declarator && scopes.symbolFor(unwrappedNode)?.declarationNode === declarator && declarator.init && declarator.parent && isNodeOfType(declarator.parent, "VariableDeclaration") && declarator.parent.kind === "const" && isGlobalArrayFromMember(declarator.init, scopes));
-};
-const executesDuringRender = (functionNode, scopes) => {
-	const parent = functionNode.parent;
-	if (!isNodeOfType(parent, "CallExpression")) return false;
-	if (parent.callee === functionNode) return true;
-	if ((scopes ? isReactApiCall(parent, REACT_RENDER_PHASE_HOOK_NAMES, scopes, { allowGlobalReactNamespace: true }) : isHookCall$2(parent, REACT_RENDER_PHASE_HOOK_NAMES)) && parent.arguments?.[0] === functionNode) return true;
-	if (scopes && parent.arguments?.[1] === functionNode && (isGlobalArrayFromMember(parent.callee, scopes) || isConstAliasOfGlobalArrayFrom(parent.callee, scopes))) return true;
-	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES$1.has(parent.callee.property.name) && parent.arguments?.[0] === functionNode;
-};
-//#endregion
-//#region src/plugin/utils/find-render-phase-component-or-hook.ts
-const findRenderPhaseComponentOrHook = (node, scopes) => {
-	let functionNode = findEnclosingFunction(node);
-	while (functionNode) {
-		if (componentOrHookDisplayNameForFunction(functionNode)) return functionNode;
-		if (!executesDuringRender(functionNode, scopes)) return null;
-		functionNode = findEnclosingFunction(functionNode);
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/get-function-binding-name.ts
-const getFunctionBindingIdentifier = (functionNode) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
-	const parent = functionNode.parent;
-	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
-	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === functionNode && isNodeOfType(parent.left, "Identifier")) return parent.left;
-	if (isNodeOfType(parent, "CallExpression")) {
-		const callParent = parent.parent;
-		if (isNodeOfType(callParent, "VariableDeclarator") && isNodeOfType(callParent.id, "Identifier")) return callParent.id;
-	}
-	return null;
-};
-const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(functionNode)?.name ?? null;
-//#endregion
 //#region src/plugin/utils/get-range-start.ts
 const getRangeStart = (node) => {
 	const rangeStart = node.range?.[0];
 	return typeof rangeStart === "number" ? rangeStart : null;
 };
 //#endregion
-//#region src/plugin/utils/is-event-handler-attribute.ts
-const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
+//#region src/plugin/utils/is-result-discarded-call.ts
+const isResultDiscardedCall = (callExpression) => {
+	let node = callExpression;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "ExpressionStatement")) return true;
+		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void") return true;
+		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
+		if (isNodeOfType(parent, "ChainExpression")) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "SequenceExpression")) {
+			const expressions = parent.expressions ?? [];
+			if (expressions[expressions.length - 1] !== node) return true;
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
 //#endregion
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
@@ -8627,9 +8532,125 @@ const isCleanupReturningSubscribeLikeCallExpression = (node) => {
 	return true;
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/is-cleanup-return.ts
+const ITERATOR_CALLBACK_METHOD_NAMES$1 = new Set([
+	"each",
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flatMap",
+	"forEach",
+	"map",
+	"reduce",
+	"reduceRight",
+	"some",
+	"sort",
+	"toSorted"
+]);
+const STATIC_ITERATOR_CALLBACK_METHOD_NAMES = new Set([
+	"from",
+	"fromAsync",
+	"groupBy"
+]);
+const unwrapChainExpression$3 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const isNullLiteral = (node) => isNodeOfType(node, "Literal") && node.value === null;
+const isListenerRemovalViaNullHandler = (callNode) => {
+	if (!isNodeOfType(callNode, "CallExpression")) return false;
+	const callee = unwrapChainExpression$3(callNode.callee);
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "on" && isNullLiteral(callNode.arguments?.[1]);
+};
+const REFERENCE_BASED_REMOVAL_METHOD_NAMES = new Set([
+	"off",
+	"removeEventListener",
+	"removeListener"
+]);
+const isNoOpInlineHandlerRemoval = (callNode, methodName) => {
+	if (!REFERENCE_BASED_REMOVAL_METHOD_NAMES.has(methodName)) return false;
+	const handlerArgument = callNode.arguments?.[1];
+	return isNodeOfType(handlerArgument, "ArrowFunctionExpression") || isNodeOfType(handlerArgument, "FunctionExpression");
+};
+const isReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
+	const callNode = unwrapChainExpression$3(node);
+	if (!isNodeOfType(callNode, "CallExpression")) return false;
+	if (isListenerRemovalViaNullHandler(callNode)) return true;
+	const callee = unwrapChainExpression$3(callNode.callee);
+	if (isNodeOfType(callee, "Identifier")) {
+		if (TIMER_CLEANUP_CALLEE_NAMES.has(callee.name)) return true;
+		if (CLEANUP_LIKE_RELEASE_CALLEE_NAMES.has(callee.name)) return true;
+		if (knownCleanupFunctionNames.has(callee.name)) return true;
+		return false;
+	}
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
+		if (isNoOpInlineHandlerRemoval(callNode, callee.property.name)) return false;
+		if (BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier") && knownBoundSubscriptionNames.has(callee.object.name)) return true;
+		return GLOBAL_RELEASE_METHOD_NAMES.has(callee.property.name);
+	}
+	return false;
+};
+const isStaticIteratorCallbackCallee = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && (callee.object.name === "Array" || callee.object.name === "Map" || callee.object.name === "Object") && STATIC_ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
+const isIteratorCallbackArgument = (node) => {
+	const parentNode = node.parent;
+	if (!isNodeOfType(parentNode, "CallExpression")) return false;
+	if (!parentNode.arguments?.some((argument) => argument === node)) return false;
+	const callee = unwrapChainExpression$3(parentNode.callee);
+	if (parentNode.arguments[1] === node && isStaticIteratorCallbackCallee(callee)) return true;
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES$1.has(callee.property.name);
+};
+const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
+	let didFindRelease = false;
+	walkAst(node, (child) => {
+		if (didFindRelease) return false;
+		if (child !== node && isFunctionLike$1(child) && !isIteratorCallbackArgument(child)) return false;
+		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
+			didFindRelease = true;
+			return false;
+		}
+	});
+	return didFindRelease;
+};
+const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
+	if (!isFunctionLike$1(node)) return false;
+	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
+};
+const isProvablyNoOpCleanupFunction = (node) => {
+	if (!isFunctionLike$1(node)) return false;
+	let sawNoOpRemoval = false;
+	let sawOtherCall = false;
+	walkAst(node.body, (child) => {
+		if (sawOtherCall) return false;
+		if (isFunctionLike$1(child)) return false;
+		const callNode = unwrapChainExpression$3(child);
+		if (!isNodeOfType(callNode, "CallExpression")) return;
+		const callee = unwrapChainExpression$3(callNode.callee);
+		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && isNoOpInlineHandlerRemoval(callNode, callee.property.name)) {
+			sawNoOpRemoval = true;
+			return;
+		}
+		sawOtherCall = true;
+	});
+	return sawNoOpRemoval && !sawOtherCall;
+};
+const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames, options = {}) => {
+	if (!returnedValue) return false;
+	const unwrappedValue = unwrapChainExpression$3(returnedValue);
+	if (isNodeOfType(unwrappedValue, "Literal") && unwrappedValue.value === null) return false;
+	if (isNodeOfType(unwrappedValue, "Identifier")) {
+		if (unwrappedValue.name === "undefined") return false;
+		if (knownCleanupFunctionNames.has(unwrappedValue.name)) return true;
+		return options.allowOpaqueReturn === true && !knownBoundSubscriptionNames.has(unwrappedValue.name);
+	}
+	if (isCleanupReturningSubscribeLikeCallExpression(unwrappedValue)) return true;
+	if (isProvablyNoOpCleanupFunction(unwrappedValue)) return false;
+	if (options.allowOpaqueReturn === true && !isSubscribeLikeCallExpression(unwrappedValue)) return true;
+	if (isCleanupFunctionLike(unwrappedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames)) return true;
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
 const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
-const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
 const RESOURCE_NOUN_BY_KIND = {
 	subscribe: "subscription",
 	timer: "timer",
@@ -8640,66 +8661,7 @@ const isSubscribeOrObserveCall = (node) => {
 	if (isSubscribeLikeCallExpression(node)) return true;
 	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME;
 };
-const resolveExpressionKey$1 = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const symbol = context.scopes.symbolFor(unwrappedExpression);
-		if (!symbol) return context.scopes.isGlobalReference(unwrappedExpression) ? `global:${unwrappedExpression.name}` : null;
-		if (visitedSymbolIds.has(symbol.id)) return `symbol:${symbol.id}`;
-		visitedSymbolIds.add(symbol.id);
-		const bindingProperty = symbol.bindingIdentifier.parent;
-		const bindingPattern = bindingProperty?.parent;
-		const variableDeclarator = bindingPattern?.parent;
-		const bindingPropertyName = isNodeOfType(bindingProperty, "Property") ? getStaticPropertyKeyName(bindingProperty) : null;
-		if (bindingPropertyName && isNodeOfType(bindingPattern, "ObjectPattern") && isNodeOfType(variableDeclarator, "VariableDeclarator") && variableDeclarator.id === bindingPattern) {
-			const objectKey = resolveExpressionKey$1(variableDeclarator.init, context, visitedSymbolIds);
-			return objectKey ? `${objectKey}.${bindingPropertyName}` : `symbol:${symbol.id}`;
-		}
-		const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
-		if (symbol.kind === "const" && initializer && (isNodeOfType(initializer, "Identifier") || isNodeOfType(initializer, "MemberExpression"))) return resolveExpressionKey$1(initializer, context, visitedSymbolIds) ?? `symbol:${symbol.id}`;
-		return `symbol:${symbol.id}`;
-	}
-	if (isNodeOfType(unwrappedExpression, "MemberExpression") && !unwrappedExpression.computed) {
-		if (!isNodeOfType(unwrappedExpression.property, "Identifier")) return null;
-		const objectKey = resolveExpressionKey$1(unwrappedExpression.object, context, visitedSymbolIds);
-		return objectKey ? `${objectKey}.${unwrappedExpression.property.name}` : null;
-	}
-	if (isNodeOfType(unwrappedExpression, "ThisExpression")) return "this";
-	if (isNodeOfType(unwrappedExpression, "Literal") && (typeof unwrappedExpression.value === "string" || typeof unwrappedExpression.value === "number")) return `literal:${String(unwrappedExpression.value)}`;
-	if (isFunctionLike$1(unwrappedExpression)) {
-		const rangeStart = getRangeStart(unwrappedExpression);
-		return rangeStart === null ? null : `function:${rangeStart}`;
-	}
-	return null;
-};
-const findAssignedResourceKey = (resourceNode, context) => {
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (isNodeOfType(parentNode, "ChainExpression")) {
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	if (isNodeOfType(parentNode, "VariableDeclarator") && parentNode.init === currentNode) return resolveExpressionKey$1(parentNode.id, context);
-	if (isNodeOfType(parentNode, "AssignmentExpression") && parentNode.right === currentNode) return resolveExpressionKey$1(parentNode.left, context);
-	return null;
-};
-const getCallRegistrationDetails = (callNode, context) => {
-	const callee = stripParenExpression(callNode.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return {
-		receiverKey: null,
-		registrationVerbName: null,
-		eventKey: null,
-		handlerKey: null
-	};
-	return {
-		receiverKey: resolveExpressionKey$1(callee.object, context),
-		registrationVerbName: callee.property.name,
-		eventKey: resolveExpressionKey$1(callNode.arguments?.[0], context),
-		handlerKey: resolveExpressionKey$1(callNode.arguments?.[1], context)
-	};
-};
-const findSubscribeLikeUsages = (callback, context) => {
+const findSubscribeLikeUsages = (callback) => {
 	const usages = [];
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	let cleanupArgument = null;
@@ -8708,22 +8670,13 @@ const findSubscribeLikeUsages = (callback, context) => {
 		const lastCallbackStatement = callbackStatements[callbackStatements.length - 1];
 		if (isNodeOfType(lastCallbackStatement, "ReturnStatement") && lastCallbackStatement.argument) cleanupArgument = lastCallbackStatement.argument;
 	}
-	const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
 	walkAst(callback, (child) => {
-		if (child !== callback && isFunctionLike$1(child)) {
-			if (child === cleanupArgument) return false;
-			if (!effectInvokedFunctions.has(child) && !isSynchronousIteratorCallback(child)) return false;
-		}
+		if (child === cleanupArgument && !isSubscribeLikeCallExpression(child)) return false;
 		if (isSocketConstruction(child)) {
 			usages.push({
 				kind: "socket",
 				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: null,
-				eventKey: null,
-				handlerKey: null
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
 			});
 			return;
 		}
@@ -8732,348 +8685,118 @@ const findSubscribeLikeUsages = (callback, context) => {
 			usages.push({
 				kind: "timer",
 				node: child,
-				resourceName: child.callee.name,
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: child.callee.name,
-				eventKey: null,
-				handlerKey: null
+				resourceName: child.callee.name
 			});
 			return;
 		}
-		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) {
-			const registrationDetails = getCallRegistrationDetails(child, context);
-			usages.push({
-				kind: "subscribe",
-				node: child,
-				resourceName: child.callee.property.name,
-				handleKey: findAssignedResourceKey(child, context),
-				...registrationDetails
-			});
+		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) usages.push({
+			kind: "subscribe",
+			node: child,
+			resourceName: child.callee.property.name
+		});
+	});
+	return usages;
+};
+const collectCleanupBindings = (effectCallback) => {
+	const bindings = {
+		cleanupFunctionNames: /* @__PURE__ */ new Set(),
+		subscriptionNames: /* @__PURE__ */ new Set(),
+		effectScopeVariableNames: /* @__PURE__ */ new Set()
+	};
+	if (!isNodeOfType(effectCallback, "ArrowFunctionExpression") && !isNodeOfType(effectCallback, "FunctionExpression")) return bindings;
+	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return bindings;
+	walkAst(effectCallback.body, (child) => {
+		if (!isSubscribeOrObserveCall(child)) return;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!isNodeOfType(child.callee, "MemberExpression")) return;
+		if (!isNodeOfType(child.callee.object, "Identifier")) return;
+		bindings.subscriptionNames.add(child.callee.object.name);
+	});
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (!isNodeOfType(child, "VariableDeclaration")) return;
+		for (const declarator of child.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			const bindingName = declarator.id.name;
+			bindings.effectScopeVariableNames.add(bindingName);
+			const init = declarator.init;
+			if (!init) continue;
+			if (isSocketConstruction(init)) {
+				bindings.subscriptionNames.add(bindingName);
+				continue;
+			}
+			if (!isNodeOfType(init, "CallExpression")) continue;
+			if (isSubscribeLikeCallExpression(init)) {
+				bindings.subscriptionNames.add(bindingName);
+				if (isCleanupReturningSubscribeLikeCallExpression(init)) bindings.cleanupFunctionNames.add(bindingName);
+			}
 		}
 	});
-	return usages.filter((usage) => isNodeReachableWithinFunction(usage.node, context));
-};
-const isNodeReachableWithinFunction = (node, context) => {
-	const owner = context.cfg.enclosingFunction(node);
-	if (!owner) return true;
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return true;
-	const targetBlock = functionCfg.blockOf(node);
-	if (!targetBlock) return true;
-	const visitedBlocks = new Set([functionCfg.entry]);
-	const pendingBlocks = [functionCfg.entry];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		if (currentBlock === targetBlock) return true;
-		for (const edge of currentBlock.successors) {
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return false;
-};
-const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, context) => {
-	let pathAnchor = usageNode;
-	let pathOwner = findEnclosingFunction(pathAnchor);
-	while (pathOwner && isSynchronousIteratorCallback(pathOwner)) {
-		if (matchingNodes.length > 0 && matchingNodes.every((matchingNode) => context.cfg.enclosingFunction(matchingNode) === pathOwner)) break;
-		const iteratorCall = pathOwner.parent;
-		if (!isNodeOfType(iteratorCall, "CallExpression")) break;
-		pathAnchor = iteratorCall;
-		pathOwner = findEnclosingFunction(pathAnchor);
-	}
-	const owner = context.cfg.enclosingFunction(pathAnchor);
-	if (!owner) return false;
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return false;
-	const usageBlock = functionCfg.blockOf(pathAnchor);
-	if (!usageBlock) return false;
-	const usageStart = getRangeStart(usageNode);
-	const matchingBlocks = new Set(matchingNodes.flatMap((matchingNode) => {
-		if (context.cfg.enclosingFunction(matchingNode) !== owner) return [];
-		const matchingBlock = functionCfg.blockOf(matchingNode);
-		if (!matchingBlock) return [];
-		const matchingStart = getRangeStart(matchingNode);
-		if (matchingBlock === usageBlock && usageStart !== null && matchingStart !== null && matchingStart < usageStart) return [];
-		return [matchingBlock];
-	}));
-	if (matchingBlocks.has(usageBlock)) return true;
-	const visitedBlocks = new Set([usageBlock]);
-	const pendingBlocks = [usageBlock];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		for (const edge of currentBlock.successors) {
-			if (matchingBlocks.has(edge.to)) continue;
-			if (edge.to === functionCfg.exit) return false;
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return matchingBlocks.size > 0;
-};
-const removeSynchronouslyReleasedUsages = (callback, usages, context) => {
+	walkAst(effectCallback.body, (child) => {
+		if (child !== effectCallback.body && (isNodeOfType(child, "ArrowFunctionExpression") || isNodeOfType(child, "FunctionExpression"))) return false;
+		if (isNodeOfType(child, "FunctionDeclaration") && child.id && isCleanupFunctionLike(child, bindings.cleanupFunctionNames, bindings.subscriptionNames)) {
+			bindings.cleanupFunctionNames.add(child.id.name);
+			return false;
+		}
+	});
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (!isNodeOfType(child, "VariableDeclaration")) return;
+		for (const declarator of child.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier") || !declarator.init) continue;
+			if (isCleanupFunctionLike(declarator.init, bindings.cleanupFunctionNames, bindings.subscriptionNames)) bindings.cleanupFunctionNames.add(declarator.id.name);
+		}
+	});
+	walkAst(effectCallback.body, (child) => {
+		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.left, "Identifier") && bindings.effectScopeVariableNames.has(child.left.name) && isCleanupFunctionLike(child.right, bindings.cleanupFunctionNames, bindings.subscriptionNames)) bindings.cleanupFunctionNames.add(child.left.name);
+	});
+	return bindings;
+};
+const removeSynchronouslyReleasedUsages = (callback, usages) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
-	const releaseCalls = [];
+	const releaseStarts = [];
 	walkInsideStatementBlocks(callback.body, (child) => {
-		if (!isNodeOfType(isNodeOfType(child, "ChainExpression") ? child.expression : child, "CallExpression")) return;
-		releaseCalls.push(child);
+		if (!isReleaseLikeCall(child, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return;
+		const releaseStart = getRangeStart(child);
+		if (releaseStart !== null) releaseStarts.push(releaseStart);
 	});
-	if (releaseCalls.length === 0) return usages;
+	if (releaseStarts.length === 0) return usages;
 	return usages.filter((usage) => {
 		const usageStart = getRangeStart(usage.node);
 		if (usageStart === null) return true;
-		const matchingReleaseCalls = releaseCalls.filter((releaseCall) => {
-			const releaseStart = getRangeStart(releaseCall);
-			return releaseStart !== null && releaseStart > usageStart && doesReleaseCallMatchUsage(releaseCall, usage, context);
-		});
-		return !doMatchingNodesCoverEveryPathAfterUsage(usage.node, matchingReleaseCalls, context);
+		return !releaseStarts.some((releaseStart) => releaseStart > usageStart);
 	});
 };
-const resolveIteratorCollectionKey = (expression, context) => {
-	if (!expression || !isNodeOfType(expression, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(expression);
-	if (!symbol || symbol.kind !== "parameter") return null;
-	let callbackNode = symbol.bindingIdentifier.parent;
-	while (callbackNode && !isFunctionLike$1(callbackNode)) callbackNode = callbackNode.parent;
-	if (!callbackNode || !isFunctionLike$1(callbackNode)) return null;
-	const callNode = callbackNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression")) return null;
-	const callee = stripParenExpression(callNode.callee);
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) {
-		if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from" && callNode.arguments?.[1] === callbackNode) return resolveExpressionKey$1(callNode.arguments[0], context);
-		if (callNode.arguments?.[0] === callbackNode) return resolveExpressionKey$1(callee.object, context);
-	}
-	return null;
-};
-const findCollectionMappingCall = (callbackNode) => {
-	if (!isNodeOfType(callbackNode, "ArrowFunctionExpression") && !isNodeOfType(callbackNode, "FunctionExpression") || callbackNode.async || callbackNode.generator) return null;
-	const callNode = callbackNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression")) return null;
-	const callee = stripParenExpression(callNode.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return null;
-	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from" && callNode.arguments?.[1] === callbackNode) return callNode;
-	return callee.property.name === "map" && callNode.arguments?.[0] === callbackNode ? callNode : null;
-};
-const findMappedResourceCollectionKey = (resourceNode, context) => {
-	const callbackNode = findEnclosingFunction(resourceNode);
-	if (!callbackNode || !isNodeOfType(callbackNode, "ArrowFunctionExpression") && !isNodeOfType(callbackNode, "FunctionExpression")) return null;
-	const mappingCall = findCollectionMappingCall(callbackNode);
-	if (!mappingCall) return null;
-	if (isNodeOfType(callbackNode.body, "BlockStatement")) {
-		const resourceRoot = findTransparentExpressionRoot(resourceNode);
-		const resourceDeclarator = resourceRoot.parent;
-		const resourceDeclaration = resourceDeclarator?.parent;
-		if (!isNodeOfType(resourceDeclarator, "VariableDeclarator") || resourceDeclarator.init !== resourceRoot || !isNodeOfType(resourceDeclarator.id, "Identifier") || !isNodeOfType(resourceDeclaration, "VariableDeclaration") || resourceDeclaration.kind !== "const" || resourceDeclaration.parent !== callbackNode.body) return null;
-		const returnStatements = [];
-		walkAst(callbackNode.body, (child) => {
-			if (child !== callbackNode.body && isFunctionLike$1(child)) return false;
-			if (isNodeOfType(child, "ReturnStatement")) returnStatements.push(child);
-		});
-		const returnStatement = returnStatements[0];
-		const callbackStatements = callbackNode.body.body ?? [];
-		const returnedIdentifier = isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument ? stripParenExpression(returnStatement.argument) : null;
-		const resourceSymbol = context.scopes.symbolFor(resourceDeclarator.id);
-		if (returnStatements.length !== 1 || callbackStatements[callbackStatements.length - 1] !== returnStatement || !isNodeOfType(returnedIdentifier, "Identifier") || !resourceSymbol || context.scopes.symbolFor(returnedIdentifier)?.id !== resourceSymbol.id || !doMatchingNodesCoverEveryPathAfterUsage(resourceNode, [returnStatement], context)) return null;
-	} else if (findTransparentExpressionRoot(resourceNode) !== callbackNode.body) return null;
-	const mappingRoot = findTransparentExpressionRoot(mappingCall);
-	const collectionDeclarator = mappingRoot.parent;
-	return isNodeOfType(collectionDeclarator, "VariableDeclarator") && collectionDeclarator.init === mappingRoot ? resolveExpressionKey$1(collectionDeclarator.id, context) : null;
-};
-const findContainingCollectionKey = (resourceNode, context) => {
-	const mappedCollectionKey = findMappedResourceCollectionKey(resourceNode, context);
-	if (mappedCollectionKey !== null) return mappedCollectionKey;
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isFunctionLike$1(parentNode)) return null;
-		if (isNodeOfType(parentNode, "VariableDeclarator") && parentNode.init === currentNode) return resolveExpressionKey$1(parentNode.id, context);
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return null;
-};
-const isWithinAssignmentTarget = (identifier) => {
-	let currentNode = identifier;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "AssignmentExpression")) return parentNode.left === currentNode;
-		if (isNodeOfType(parentNode, "UpdateExpression") || isNodeOfType(parentNode, "UnaryExpression") && parentNode.operator === "delete") return parentNode.argument === currentNode;
-		if (isNodeOfType(parentNode, "ForInStatement") || isNodeOfType(parentNode, "ForOfStatement")) return parentNode.left === currentNode;
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const resolveStableValue = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return unwrappedExpression;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	const isUnreassignedMutableBinding = (symbol?.kind === "let" || symbol?.kind === "var") && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && symbol.declarationNode.id === symbol.bindingIdentifier && symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier)) && symbol.scope.symbols.filter((candidate) => candidate.name === symbol.name).length === 1;
-	const recursiveFunctionSymbol = symbol?.kind === "function" && isFunctionLike$1(symbol.declarationNode) ? context.scopes.ownScopeFor(symbol.declarationNode)?.symbols.find((candidate) => candidate.name === symbol.name && candidate.declarationNode === symbol.declarationNode) : null;
-	const isUnreassignedFunctionBinding = symbol?.kind === "function" && symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier)) && (!recursiveFunctionSymbol || recursiveFunctionSymbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier))) && symbol.scope.symbols.filter((candidate) => candidate.name === symbol.name).length === 1;
-	if (!symbol || symbol.kind !== "const" && !isUnreassignedMutableBinding && !isUnreassignedFunctionBinding || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return unwrappedExpression;
-	visitedSymbolIds.add(symbol.id);
-	return resolveStableValue(symbol.initializer, context, visitedSymbolIds);
-};
-const resolveObjectExpression = (expression, context) => {
-	const resolvedExpression = resolveStableValue(expression, context);
-	return isNodeOfType(resolvedExpression, "ObjectExpression") ? resolvedExpression : null;
-};
-const getListenerAbortControllerKey = (usage, context) => {
-	if (usage.registrationVerbName !== "addEventListener" || !isNodeOfType(usage.node, "CallExpression")) return null;
-	const optionsArgument = usage.node.arguments?.[2];
-	const optionsObject = resolveObjectExpression(optionsArgument, context);
-	if (!optionsObject) return null;
-	for (const property of optionsObject.properties ?? []) {
-		if (!isNodeOfType(property, "Property") || getStaticPropertyKeyName(property) !== "signal") continue;
-		const signalKey = resolveExpressionKey$1(property.value, context);
-		return signalKey?.endsWith(".signal") ? signalKey.slice(0, -7) : null;
-	}
-	return null;
-};
-const SYNCHRONOUS_ITERATOR_METHOD_NAMES$1 = new Set([
-	"every",
-	"filter",
-	"flatMap",
-	"forEach",
-	"map",
-	"reduce",
-	"reduceRight",
-	"some"
-]);
-const isSynchronousIteratorCallback = (functionNode) => {
-	const callNode = functionNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	const callee = stripParenExpression(callNode.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
-	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from") return callNode.arguments?.[1] === functionNode;
-	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$1.has(callee.property.name) && callNode.arguments?.[0] === functionNode;
-};
-const findDirectCallForReference = (identifier) => {
-	const expressionRoot = findTransparentExpressionRoot(identifier);
-	const callNode = expressionRoot.parent;
-	return isNodeOfType(callNode, "CallExpression") && callNode.callee === expressionRoot ? callNode : null;
-};
-const findSingleDirectInvocation = (functionNode, caller, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
-	if (!bindingIdentifier || resolveStableValue(bindingIdentifier, context) !== functionNode) return null;
-	const symbol = context.scopes.symbolFor(bindingIdentifier);
-	if (!symbol) return null;
-	const invocationCalls = symbol.references.flatMap((reference) => {
-		const callNode = findDirectCallForReference(reference.identifier);
-		return callNode ? [callNode] : [];
-	});
-	if (invocationCalls.length !== 1) return null;
-	const invocationCall = invocationCalls[0];
-	return findEnclosingFunction(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
-};
-const resolveCleanupPathAnchor = (usageNode, effectCallback, context) => {
-	const usageFunction = findEnclosingFunction(usageNode);
-	if (!usageFunction || usageFunction === effectCallback) return usageNode;
-	return findSingleDirectInvocation(usageFunction, effectCallback, context) ?? usageNode;
-};
-const resolveSingleAssignedCleanupFunction = (expression, usage, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	const initializer = symbol?.initializer ? stripParenExpression(symbol.initializer) : null;
-	if (!symbol || symbol.kind !== "let" && symbol.kind !== "var" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || !isNodeOfType(initializer, "Literal") || initializer.value !== null || symbol.scope.symbols.filter((candidate) => candidate.name === symbol.name).length !== 1) return null;
-	const assignmentReferences = symbol.references.filter((reference) => isWithinAssignmentTarget(reference.identifier));
-	if (assignmentReferences.length !== 1) return null;
-	const assignmentReference = assignmentReferences[0];
-	const assignmentTarget = findTransparentExpressionRoot(assignmentReference.identifier);
-	const assignmentNode = assignmentTarget.parent;
-	if (!isNodeOfType(assignmentNode, "AssignmentExpression") || assignmentNode.operator !== "=" || assignmentNode.left !== assignmentTarget || findEnclosingFunction(assignmentNode) !== findEnclosingFunction(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [assignmentNode], context)) return null;
-	const assignedValue = stripParenExpression(assignmentNode.right);
-	return isFunctionLike$1(assignedValue) ? assignedValue : null;
-};
-const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visitedFunctions = /* @__PURE__ */ new Set()) => {
-	if (!isFunctionLike$1(cleanupFunction) || visitedFunctions.has(cleanupFunction)) return false;
-	visitedFunctions.add(cleanupFunction);
-	let didCleanupFunctionMatch = false;
-	walkAst(cleanupFunction.body, (cleanupChild) => {
-		if (didCleanupFunctionMatch) return false;
-		if (cleanupChild !== cleanupFunction.body && isFunctionLike$1(cleanupChild) && !isSynchronousIteratorCallback(cleanupChild)) return false;
-		if (doesReleaseCallMatchUsage(cleanupChild, usage, context)) {
-			didCleanupFunctionMatch = true;
-			return false;
-		}
-		const helperCall = isNodeOfType(cleanupChild, "ChainExpression") ? cleanupChild.expression : cleanupChild;
-		if (!isNodeOfType(helperCall, "CallExpression")) return;
-		const stableHelperFunction = resolveStableValue(helperCall.callee, context);
-		const helperFunction = isNodeOfType(stableHelperFunction, "Identifier") ? resolveSingleAssignedCleanupFunction(stableHelperFunction, usage, context) : stableHelperFunction;
-		if (helperFunction && isFunctionLike$1(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context, visitedFunctions)) {
-			didCleanupFunctionMatch = true;
-			return false;
-		}
+const cleanupReturnRunsAfterUsage = (returnStatement, usages) => {
+	if (returnStatement.argument && isCleanupReturningSubscribeLikeCallExpression(returnStatement.argument)) return true;
+	const returnStart = getRangeStart(returnStatement);
+	if (returnStart === null) return true;
+	return usages.some((usage) => {
+		const usageStart = getRangeStart(usage.node);
+		return usageStart === null || usageStart < returnStart;
 	});
-	return didCleanupFunctionMatch;
 };
-const effectHasCleanupForUsage = (callback, usage, context) => {
+const effectHasCleanupReturn = (callback, usages) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	if (usage.kind === "subscribe" && findEnclosingFunction(usage.node) === callback && doesResourceResultEscape(usage.node, true) && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
-	if (!isNodeOfType(callback.body, "BlockStatement")) return callback.body === usage.node && isCleanupReturningSubscribeLikeCallExpression(callback.body);
-	const matchingCleanupReturns = [];
+	if (!isNodeOfType(callback.body, "BlockStatement")) return isCleanupReturningSubscribeLikeCallExpression(callback.body);
+	const cleanupBindings = collectCleanupBindings(callback);
+	let didFindCleanupReturn = false;
 	walkInsideStatementBlocks(callback.body, (child) => {
+		if (didFindCleanupReturn) return;
 		if (!isNodeOfType(child, "ReturnStatement")) return;
-		const returnStart = getRangeStart(child);
-		const usageStart = getRangeStart(usage.node);
-		if (returnStart !== null && usageStart !== null && returnStart < usageStart) return;
-		const returnedValue = child.argument ? stripParenExpression(child.argument) : null;
-		if (!returnedValue) return;
-		if (usage.kind === "subscribe" && (returnedValue === usage.node || getRangeStart(returnedValue) !== null && getRangeStart(returnedValue) === getRangeStart(usage.node)) && isCleanupReturningSubscribeLikeCallExpression(returnedValue)) {
-			matchingCleanupReturns.push(child);
-			return;
-		}
-		if (usage.kind === "subscribe" && isNodeOfType(returnedValue, "Identifier") && usage.handleKey !== null && resolveExpressionKey$1(returnedValue, context) === usage.handleKey && isCleanupReturningSubscribeLikeCallExpression(usage.node)) {
-			matchingCleanupReturns.push(child);
-			return;
-		}
-		if (isNodeOfType(returnedValue, "Identifier")) {
-			if (returnedValue.name === "undefined" && context.scopes.isGlobalReference(returnedValue)) return;
-			const returnedKey = resolveExpressionKey$1(returnedValue, context);
-			if (usage.handleKey !== null && returnedKey === usage.handleKey) return;
-			if (!context.scopes.symbolFor(returnedValue)?.initializer) return;
-		}
-		const cleanupFunction = resolveStableValue(returnedValue, context);
-		if (!cleanupFunction || !isFunctionLike$1(cleanupFunction)) return;
-		if (doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context)) matchingCleanupReturns.push(child);
+		if (!cleanupReturnRunsAfterUsage(child, usages)) return;
+		if (isCleanupReturn(child.argument, cleanupBindings.cleanupFunctionNames, cleanupBindings.subscriptionNames, { allowOpaqueReturn: true })) didFindCleanupReturn = true;
 	});
-	return doMatchingNodesCoverEveryPathAfterUsage(resolveCleanupPathAnchor(usage.node, callback, context), matchingCleanupReturns, context);
-};
-const findFirstUsageWithoutCleanup = (callback, usages, context) => {
-	for (const usage of usages) if (!effectHasCleanupForUsage(callback, usage, context)) return usage;
-	return null;
-};
-const isLocalAbortControllerExpression = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "NewExpression") && isNodeOfType(unwrappedExpression.callee, "Identifier") && unwrappedExpression.callee.name === "AbortController") return true;
-	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return isLocalAbortControllerExpression(unwrappedExpression.object, context, visitedSymbolIds);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return false;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	if (symbol.initializer) return isLocalAbortControllerExpression(symbol.initializer, context, visitedSymbolIds);
-	const bindingProperty = symbol.bindingIdentifier.parent;
-	const bindingPattern = bindingProperty?.parent;
-	const variableDeclarator = bindingPattern?.parent;
-	return Boolean(isNodeOfType(bindingProperty, "Property") && isNodeOfType(bindingPattern, "ObjectPattern") && isNodeOfType(variableDeclarator, "VariableDeclarator") && variableDeclarator.init && isLocalAbortControllerExpression(variableDeclarator.init, context, visitedSymbolIds));
+	return didFindCleanupReturn;
 };
-const isSelfReleasingListenerOptionProperty = (property, context) => {
+const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
+const isSelfReleasingListenerOptionProperty = (property) => {
 	if (!isNodeOfType(property, "Property")) return false;
 	const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : isNodeOfType(property.key, "Literal") ? property.key.value : null;
-	if (keyName === "signal") return !isLocalAbortControllerExpression(property.value, context);
+	if (keyName === "signal") return true;
 	if (keyName !== "once") return false;
 	return isNodeOfType(property.value, "Literal") && property.value.value === true;
 };
-const hasSelfReleasingListenerOptions = (node, context) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some((property) => isSelfReleasingListenerOptionProperty(property, context)));
+const hasSelfReleasingListenerOptions = (node) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some(isSelfReleasingListenerOptionProperty));
 const PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB = new Map([
 	["addEventListener", new Set(["removeEventListener", "abort"])],
 	["addListener", new Set([
@@ -9099,185 +8822,85 @@ const UNIVERSAL_RELEASE_VERB_NAMES = new Set([
 	"teardown"
 ]);
 const SOCKET_RELEASE_VERB_NAMES = new Set(["close"]);
+const INTERVAL_RELEASE_VERB_NAMES = new Set(["clearInterval"]);
 const getReleaseVerbName = (node) => {
+	if (!isReleaseLikeCall(node, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return null;
 	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
 	if (!isNodeOfType(callNode, "CallExpression")) return null;
 	const callee = isNodeOfType(callNode.callee, "ChainExpression") ? callNode.callee.expression : callNode.callee;
-	if (isNodeOfType(callee, "Identifier")) return TIMER_CLEANUP_CALLEE_NAMES.has(callee.name) || GLOBAL_RELEASE_METHOD_NAMES.has(callee.name) || UNIVERSAL_RELEASE_VERB_NAMES.has(callee.name) ? callee.name : null;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-		const methodName = callee.property.name;
-		return GLOBAL_RELEASE_METHOD_NAMES.has(methodName) || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(methodName) || methodName === "on" ? methodName : null;
-	}
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
 	return null;
 };
-const doesReleaseCallMatchUsage = (node, usage, context) => {
-	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	const callee = isNodeOfType(callNode.callee, "ChainExpression") ? callNode.callee.expression : callNode.callee;
-	if (usage.kind === "timer") {
-		const expectedCleanupName = usage.registrationVerbName === "setInterval" ? "clearInterval" : "clearTimeout";
-		if (!isNodeOfType(callee, "Identifier") || !TIMER_CLEANUP_CALLEE_NAMES.has(callee.name) || callee.name !== expectedCleanupName) return false;
-		if (usage.handleKey !== null && resolveExpressionKey$1(callNode.arguments?.[0], context) === usage.handleKey) return true;
-		const collectionKey = findContainingCollectionKey(usage.node, context);
-		return collectionKey !== null && collectionKey === resolveIteratorCollectionKey(callNode.arguments?.[0], context);
-	}
-	if (isNodeOfType(callee, "Identifier") && usage.kind === "subscribe" && usage.handleKey !== null && resolveExpressionKey$1(callee, context) === usage.handleKey && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
-	const releaseVerbName = getReleaseVerbName(callNode);
-	if (!releaseVerbName) return false;
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
-	const releaseReceiverKey = resolveExpressionKey$1(callee.object, context);
-	if (usage.kind === "socket") return usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (SOCKET_RELEASE_VERB_NAMES.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName));
-	if (usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub" || releaseVerbName === "close" || releaseVerbName === "unwatch" || releaseVerbName === "unlisten" || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(releaseVerbName))) return true;
-	if (releaseVerbName === "abort" && releaseReceiverKey === getListenerAbortControllerKey(usage, context)) return true;
-	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) return false;
-	const pairedVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
-	if (!pairedVerbNames || !matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return false;
-	const releaseEventKey = resolveExpressionKey$1(callNode.arguments?.[0], context);
-	if (usage.eventKey !== null && releaseEventKey !== null && usage.eventKey !== releaseEventKey) {
-		const usageIteratorCollectionKey = isNodeOfType(usage.node, "CallExpression") ? resolveIteratorCollectionKey(usage.node.arguments?.[0], context) : null;
-		const releaseIteratorCollectionKey = resolveIteratorCollectionKey(callNode.arguments?.[0], context);
-		if (usageIteratorCollectionKey === null || usageIteratorCollectionKey !== releaseIteratorCollectionKey) return false;
-	}
-	if (releaseVerbName === "on") {
-		const handlerArgument = callNode.arguments?.[1];
-		return isNodeOfType(handlerArgument, "Literal") && handlerArgument.value === null;
-	}
-	if (releaseVerbName === "removeEventListener" || releaseVerbName === "removeListener" || releaseVerbName === "off") {
-		const releaseHandler = callNode.arguments?.[1];
-		if (!releaseHandler) return releaseVerbName === "off";
-		return usage.handlerKey !== null && resolveExpressionKey$1(releaseHandler, context) === usage.handlerKey;
-	}
-	if (releaseVerbName === "unobserve" && usage.eventKey !== null) return releaseEventKey === usage.eventKey;
-	return true;
-};
 const matchesPairedReleaseVerb = (releaseVerbName, pairedVerbNames) => pairedVerbNames.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName);
-const isReturnedEffectCleanupFunction = (functionNode) => {
-	let currentNode = functionNode;
-	let parentNode = currentNode.parent;
-	while (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	if (!isNodeOfType(parentNode, "ReturnStatement") || parentNode.argument !== currentNode) return false;
-	const effectCallback = findEnclosingFunction(parentNode);
-	const effectCall = effectCallback?.parent;
-	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isHookCall$2(effectCall, CLEANUP_EFFECT_HOOK_NAMES));
-};
-const isPotentiallyReachableFunction = (functionNode, context) => {
-	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode)) return true;
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
-	if (!bindingIdentifier) return false;
-	const symbol = context.scopes.symbolFor(bindingIdentifier);
-	if (!symbol) return false;
-	return symbol.references.some((reference) => findEnclosingFunction(reference.identifier) !== functionNode);
-};
-const isReleaseReachableForUsage = (releaseNode, usage, context) => {
-	if (!isNodeReachableWithinFunction(releaseNode, context)) return false;
-	const releaseFunction = findEnclosingFunction(releaseNode);
-	if (!releaseFunction) return true;
-	if (releaseFunction === findEnclosingFunction(usage.node)) return true;
-	return isPotentiallyReachableFunction(releaseFunction, context);
-};
-const fileContainsReleaseForUsage = (usage, context) => {
-	let programNode = usage.node;
-	while (programNode.parent) programNode = programNode.parent;
-	let didFindRelease = false;
-	walkAst(programNode, (child) => {
-		if (didFindRelease) return false;
-		if (doesReleaseCallMatchUsage(child, usage, context) && isReleaseReachableForUsage(child, usage, context)) {
-			didFindRelease = true;
+const bodyContainsPairedReleaseCall = (body, pairedVerbNames) => {
+	let didFindPairedRelease = false;
+	walkAst(body, (child) => {
+		if (didFindPairedRelease) return false;
+		if (child !== body && isFunctionLike$1(child)) return false;
+		const releaseVerbName = getReleaseVerbName(child);
+		if (releaseVerbName !== null && matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) {
+			didFindPairedRelease = true;
 			return false;
 		}
 	});
-	return didFindRelease;
+	return didFindPairedRelease;
 };
-const isUseSyncExternalStoreSubscribeFunction = (functionNode, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
-	if (!bindingIdentifier) return false;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	const isSubscribeBinding = (candidateBinding) => {
-		const symbol = context.scopes.symbolFor(candidateBinding);
-		if (!symbol || visitedSymbolIds.has(symbol.id) || symbol.references.length === 0) return false;
-		visitedSymbolIds.add(symbol.id);
-		return symbol.references.every((reference) => {
-			const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-			const referenceParent = referenceRoot.parent;
-			if (isNodeOfType(referenceParent, "CallExpression") && referenceParent.arguments?.[0] === referenceRoot) return isReactApiCall(referenceParent, "useSyncExternalStore", context.scopes);
-			const aliasDeclaration = referenceParent?.parent;
-			return Boolean(isNodeOfType(referenceParent, "VariableDeclarator") && referenceParent.init === referenceRoot && isNodeOfType(referenceParent.id, "Identifier") && isNodeOfType(aliasDeclaration, "VariableDeclaration") && aliasDeclaration.kind === "const" && isSubscribeBinding(referenceParent.id));
-		});
-	};
-	return isSubscribeBinding(bindingIdentifier);
+const fileReleaseVerbNamesCache = /* @__PURE__ */ new WeakMap();
+const collectFileReleaseVerbNames = (anyNode) => {
+	let programNode = anyNode;
+	while (programNode.parent) programNode = programNode.parent;
+	const cached = fileReleaseVerbNamesCache.get(programNode);
+	if (cached) return cached;
+	const releaseVerbNames = /* @__PURE__ */ new Set();
+	walkAst(programNode, (child) => {
+		const releaseVerbName = getReleaseVerbName(child);
+		if (releaseVerbName !== null) releaseVerbNames.add(releaseVerbName);
+	});
+	fileReleaseVerbNamesCache.set(programNode, releaseVerbNames);
+	return releaseVerbNames;
 };
-const doesResourceResultEscape = (resourceNode, allowConciseReturnEscape) => {
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode) return true;
-		if (isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode && allowConciseReturnEscape) return true;
-		if (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
-			currentNode = parentNode;
-			parentNode = currentNode.parent;
-			continue;
-		}
-		return false;
-	}
+const fileContainsPairedReleaseCall = (registrationCall, registrationVerbName) => {
+	const fileReleaseVerbNames = collectFileReleaseVerbNames(registrationCall);
+	const pairedVerbNames = PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(registrationVerbName);
+	if (!pairedVerbNames) return fileReleaseVerbNames.size > 0;
+	for (const releaseVerbName of fileReleaseVerbNames) if (matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return true;
 	return false;
 };
-const findRetainedFunctionLeak = (retainedFunction, context) => {
+const findRetainedFunctionLeak = (retainedFunction) => {
 	if (!isFunctionLike$1(retainedFunction)) return null;
 	const body = retainedFunction.body;
 	if (!body) return null;
+	const conciseReturnValue = isNodeOfType(body, "BlockStatement") ? null : body;
 	let leak = null;
-	const allowConciseReturnEscape = !isInlineRetainedHandlerFunction(retainedFunction, context);
-	const isExternalStoreSubscribeFunction = isUseSyncExternalStoreSubscribeFunction(retainedFunction, context);
-	const hasReleaseForUsage = (usage) => isExternalStoreSubscribeFunction ? effectHasCleanupForUsage(retainedFunction, usage, context) : fileContainsReleaseForUsage(usage, context);
 	walkAst(body, (child) => {
 		if (leak !== null) return false;
 		if (isFunctionLike$1(child)) return false;
-		if (isSocketConstruction(child) && !doesResourceResultEscape(child, false)) {
-			const socketUsage = {
+		if (child === conciseReturnValue && isNodeOfType(child, "CallExpression")) return;
+		if (isSocketConstruction(child) && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, SOCKET_RELEASE_VERB_NAMES)) {
+			leak = {
 				kind: "socket",
 				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: null,
-				eventKey: null,
-				handlerKey: null
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
 			};
-			if (!hasReleaseForUsage(socketUsage)) {
-				leak = socketUsage;
-				return false;
-			}
+			return false;
 		}
 		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
-			const timerUsage = {
+		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, INTERVAL_RELEASE_VERB_NAMES)) {
+			leak = {
 				kind: "timer",
 				node: child,
-				resourceName: "setInterval",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: "setInterval",
-				eventKey: null,
-				handlerKey: null
+				resourceName: "setInterval"
 			};
-			if (!hasReleaseForUsage(timerUsage)) {
-				leak = timerUsage;
-				return false;
-			}
+			return false;
 		}
-		if (isSubscribeOrObserveCall(child) && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
-			const registrationDetails = getCallRegistrationDetails(child, context);
-			const subscriptionUsage = {
+		if (isSubscribeOrObserveCall(child) && isResultDiscardedCall(child)) {
+			const registrationVerbName = isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") ? child.callee.property.name : "subscribe";
+			if (!hasSelfReleasingListenerOptions(child) && !fileContainsPairedReleaseCall(child, registrationVerbName)) leak = {
 				kind: "subscribe",
 				node: child,
-				resourceName: registrationDetails.registrationVerbName ?? "subscribe",
-				handleKey: findAssignedResourceKey(child, context),
-				...registrationDetails
+				resourceName: registrationVerbName
 			};
-			if (!hasSelfReleasingListenerOptions(child, context) && !hasReleaseForUsage(subscriptionUsage)) leak = subscriptionUsage;
 			return false;
 		}
 	});
@@ -9289,26 +8912,6 @@ const isRetainedComponentScopeFunction = (functionNode) => {
 	if (!isNodeOfType(functionNode.parent, "VariableDeclarator")) return false;
 	return enclosingComponentOrHookName(functionNode) !== null;
 };
-const isDirectJsxEventHandlerValue = (expression) => {
-	const expressionRoot = findTransparentExpressionRoot(expression);
-	const expressionContainer = expressionRoot.parent;
-	return isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === expressionRoot && isEventHandlerAttribute(expressionContainer.parent);
-};
-const isInlineRetainedHandlerFunction = (functionNode, context) => {
-	if (!isFunctionLike$1(functionNode)) return false;
-	const functionRoot = findTransparentExpressionRoot(functionNode);
-	const callbackCall = functionRoot.parent;
-	if (isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments?.[0] === functionRoot && isHookCall$2(callbackCall, "useCallback") && isDirectJsxEventHandlerValue(callbackCall)) return true;
-	const parentNode = functionNode.parent;
-	if (isDirectJsxEventHandlerValue(functionNode)) return true;
-	if (!isNodeOfType(parentNode, "Property") || parentNode.value !== functionNode || parentNode.computed) return false;
-	const propertyName = getStaticPropertyKeyName(parentNode);
-	if (!propertyName || !/^on[A-Z]/.test(propertyName)) return false;
-	const objectExpression = parentNode.parent;
-	if (!isNodeOfType(objectExpression, "ObjectExpression")) return false;
-	const objectParent = objectExpression.parent;
-	return (isNodeOfType(objectParent, "CallExpression") && objectParent.arguments.some((argument) => argument === objectExpression) || isNodeOfType(objectParent, "JSXExpressionContainer")) && findRenderPhaseComponentOrHook(parentNode, context.scopes) !== null;
-};
 const effectNeedsCleanup = defineRule({
 	id: "effect-needs-cleanup",
 	title: "Effect subscription or timer never cleaned up",
@@ -9317,8 +8920,7 @@ const effectNeedsCleanup = defineRule({
 	recommendation: "Return a cleanup function that stops the subscription or timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` or `clearTimeout(id)` for timers, `return () => observer.disconnect()` for observers, `return () => socket.close()` for connections, or `return unsubscribe` if the subscribe call already gave you one.",
 	create: (context) => {
 		const reportRetainedLeak = (retainedFunction) => {
-			if (!isPotentiallyReachableFunction(retainedFunction, context)) return;
-			const leak = findRetainedFunctionLeak(retainedFunction, context);
+			const leak = findRetainedFunctionLeak(retainedFunction);
 			if (!leak) return;
 			const resourceNoun = RESOURCE_NOUN_BY_KIND[leak.kind];
 			context.report({
@@ -9330,31 +8932,30 @@ const effectNeedsCleanup = defineRule({
 			CallExpression(node) {
 				if (isHookCall$2(node, "useCallback")) {
 					const retainedCallback = getEffectCallback(node);
-					if (retainedCallback && !isInlineRetainedHandlerFunction(retainedCallback, context)) reportRetainedLeak(retainedCallback);
+					if (retainedCallback) reportRetainedLeak(retainedCallback);
 					return;
 				}
-				if (!isHookCall$2(node, CLEANUP_EFFECT_HOOK_NAMES)) return;
+				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 				const callback = getEffectCallback(node);
 				if (!callback) return;
-				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback, context), context);
+				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback));
 				if (usages.length === 0) return;
-				const firstUsage = findFirstUsageWithoutCleanup(callback, usages, context);
-				if (!firstUsage) return;
+				if (effectHasCleanupReturn(callback, usages)) return;
+				const firstUsage = usages[0];
 				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
-				const hookName = getCalleeName$2(node) ?? "effect";
 				context.report({
 					node,
-					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without returning cleanup. Return a cleanup function so it does not leak after unmount.`
+					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in useEffect without returning cleanup. Return a cleanup function so it does not leak after unmount.`
 				});
 			},
 			FunctionDeclaration(node) {
 				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
 			},
 			ArrowFunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
 			},
 			FunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
 			}
 		};
 	}
@@ -9968,18 +9569,13 @@ const unwrapExpression$3 = (node) => {
 	return current;
 };
 /**
-* Get the hook name from a direct, wrapped, namespaced, or immutable
-* React import alias call.
+* Get the hook name from a call expression's callee, regardless of
+* whether the hook is called as `useFoo()` (Identifier) or
+* `React.useFoo()` (MemberExpression).
 */
-const getHookName = (callee, scopes) => {
-	const strippedCallee = unwrapExpression$3(callee);
-	if (isNodeOfType(strippedCallee, "Identifier")) {
-		const resolvedSymbol = scopes ? resolveConstIdentifierAlias(strippedCallee, scopes) : null;
-		const importDeclaration = resolvedSymbol?.declarationNode.parent;
-		if (resolvedSymbol?.kind === "import" && importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react") return getImportedName(resolvedSymbol.declarationNode) ?? strippedCallee.name;
-		return strippedCallee.name;
-	}
-	if (isNodeOfType(strippedCallee, "MemberExpression") && !strippedCallee.computed && isNodeOfType(strippedCallee.property, "Identifier")) return strippedCallee.property.name;
+const getHookName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
 	return null;
 };
 const FUNCTION_SCOPE_KINDS = new Set([
@@ -10164,7 +9760,7 @@ const STABLE_IDENTITY_WRAPPER_HOOK_NAMES = new Set([
 *   - primitive-literal local consts (the value never changes
 *     between renders unless the literal does)
 */
-const symbolHasStableHookOrigin = (symbol, scopes) => {
+const symbolHasStableHookOrigin = (symbol) => {
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
 	let declarator = symbol.declarationNode;
 	while (declarator && declarator.type !== "VariableDeclarator") declarator = declarator.parent ?? null;
@@ -10177,7 +9773,7 @@ const symbolHasStableHookOrigin = (symbol, scopes) => {
 		if (isNodeOfType(initializer, "TemplateLiteral") && getStaticTemplateLiteralValue(initializer) !== null) return true;
 	}
 	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const initializerHookName = getHookName(initializer.callee, scopes);
+	const initializerHookName = getHookName(initializer.callee);
 	if (!initializerHookName) return false;
 	if (initializerHookName === "useRef") return true;
 	if (initializerHookName === "useEffectEvent") return true;
@@ -10212,7 +9808,7 @@ const symbolHasStableMemoizedOrigin = (symbol, scopes, visitedSymbolIds) => {
 	if (!declarator.init) return false;
 	const initializer = unwrapExpression$3(declarator.init);
 	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const initializerHookName = getHookName(initializer.callee, scopes);
+	const initializerHookName = getHookName(initializer.callee);
 	if (!initializerHookName || !MEMOIZING_HOOK_NAMES.has(initializerHookName)) return false;
 	const depsArgument = initializer.arguments[1];
 	if (!depsArgument || !isAstNode(depsArgument)) return false;
@@ -10242,7 +9838,7 @@ const getObjectPropertyValue = (objectExpression, propertyName) => {
 	}
 	return null;
 };
-const isStableRefContainerCapture = (symbol, depKey, scopes) => {
+const isStableRefContainerCapture = (symbol, depKey) => {
 	if (symbol.kind !== "const") return false;
 	if (!depKey.startsWith(`${symbol.name}.`)) return false;
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
@@ -10256,7 +9852,7 @@ const isStableRefContainerCapture = (symbol, depKey, scopes) => {
 		if (!propertyValue) return false;
 		currentValue = propertyValue;
 	}
-	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee, scopes) === "useRef";
+	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee) === "useRef";
 };
 const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	if (visitedSymbolIds.has(symbol.id)) return true;
@@ -10274,13 +9870,7 @@ const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	}
 	return true;
 };
-const symbolHasStableImportedAlias = (symbol, scopes) => {
-	if (symbol.kind !== "const") return false;
-	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
-	const resolvedSymbol = resolveConstIdentifierAlias(symbol.bindingIdentifier, scopes);
-	return resolvedSymbol !== null && resolvedSymbol !== symbol && resolvedSymbol.kind === "import";
-};
-const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol, scopes) || symbolHasStableImportedAlias(symbol, scopes) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
+const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
 //#endregion
 //#region src/plugin/utils/symbol-has-react-use-effect-event-origin.ts
 const symbolHasReactUseEffectEventOrigin = (symbol, scopes) => {
@@ -10468,18 +10058,10 @@ const collectCaptureDepKeys = (callback, scopes) => {
 		}
 		const depKey = computeDepKey(reference);
 		if (!depKey) continue;
-		if (isStableRefContainerCapture(symbol, depKey, scopes)) {
+		if (isStableRefContainerCapture(symbol, depKey)) {
 			stableCapturedNames.add(depKey);
 			continue;
 		}
-		if (depKey === symbol.name) {
-			const identitySourceKeys = resolveReactiveIdentitySourceKeys(symbol, scopes);
-			if (identitySourceKeys) {
-				if (identitySourceKeys.size === 0) stableCapturedNames.add(depKey);
-				for (const identitySourceKey of identitySourceKeys) keys.add(identitySourceKey);
-				continue;
-			}
-		}
 		keys.add(depKey);
 	}
 	return {
@@ -10508,60 +10090,12 @@ const hasComputedMemberExpression = (node) => {
 	if (stripped.computed) return true;
 	return hasComputedMemberExpression(stripped.object);
 };
-const mergeIdentitySourceKeys = (expressions, scopes, visitedSymbolIds) => {
-	const identitySourceKeys = /* @__PURE__ */ new Set();
-	for (const expression of expressions) {
-		const expressionSourceKeys = resolveIdentitySourceKeysFromExpression(expression, scopes, visitedSymbolIds);
-		if (!expressionSourceKeys) return null;
-		for (const expressionSourceKey of expressionSourceKeys) identitySourceKeys.add(expressionSourceKey);
-	}
-	return identitySourceKeys;
-};
-const resolveIdentitySourceKeysFromExpression = (expression, scopes, visitedSymbolIds) => {
-	const stripped = unwrapExpression$3(expression);
-	if (isNodeOfType(stripped, "Literal") && (stripped.value === null || typeof stripped.value === "string" || typeof stripped.value === "number" || typeof stripped.value === "boolean") || isNodeOfType(stripped, "TemplateLiteral") && getStaticTemplateLiteralValue(stripped) !== null) return /* @__PURE__ */ new Set();
-	if (isNodeOfType(stripped, "Identifier")) {
-		const sourceSymbol = scopes.symbolFor(stripped);
-		if (!sourceSymbol) return null;
-		if (isOutsideAllFunctions(sourceSymbol) || symbolHasStableValue(sourceSymbol, scopes)) return /* @__PURE__ */ new Set();
-		if (sourceSymbol.kind === "const" && sourceSymbol.initializer && isNodeOfType(sourceSymbol.declarationNode, "VariableDeclarator") && sourceSymbol.declarationNode.id === sourceSymbol.bindingIdentifier && sourceSymbol.references.every((reference) => reference.flag === "read")) {
-			if (visitedSymbolIds.has(sourceSymbol.id)) return null;
-			visitedSymbolIds.add(sourceSymbol.id);
-			const sourceKeys = resolveIdentitySourceKeysFromExpression(sourceSymbol.initializer, scopes, visitedSymbolIds);
-			visitedSymbolIds.delete(sourceSymbol.id);
-			if (sourceKeys) return sourceKeys;
-		}
-		return new Set([sourceSymbol.name]);
-	}
-	if (isNodeOfType(stripped, "MemberExpression")) {
-		if (hasComputedMemberExpression(stripped)) return null;
-		const sourceKey = stringifyMemberChain(stripped);
-		const rootIdentifier = getMemberRootIdentifier(stripped);
-		const rootSymbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
-		if (!sourceKey || !rootSymbol) return null;
-		if (isOutsideAllFunctions(rootSymbol)) return /* @__PURE__ */ new Set();
-		if (isStableRefContainerCapture(rootSymbol, sourceKey, scopes)) return /* @__PURE__ */ new Set();
-		if (symbolHasStableValue(rootSymbol, scopes)) return /* @__PURE__ */ new Set();
-		return new Set([sourceKey]);
-	}
-	if (isNodeOfType(stripped, "LogicalExpression")) return mergeIdentitySourceKeys([stripped.left, stripped.right], scopes, visitedSymbolIds);
-	if (isNodeOfType(stripped, "ConditionalExpression")) return mergeIdentitySourceKeys([
-		stripped.test,
-		stripped.consequent,
-		stripped.alternate
-	], scopes, visitedSymbolIds);
-	return null;
-};
-const resolveReactiveIdentitySourceKeys = (symbol, scopes) => {
-	if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || symbol.references.some((reference) => reference.flag !== "read")) return null;
-	return resolveIdentitySourceKeysFromExpression(symbol.initializer, scopes, new Set([symbol.id]));
-};
 const isUseCallbackResultDep = (node, scopes) => {
 	const rootSymbol = getRootSymbol(node, scopes);
 	const initializer = rootSymbol?.initializer ? unwrapExpression$3(rootSymbol.initializer) : null;
-	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && getHookName(initializer.callee, scopes) === "useCallback");
+	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && getHookName(initializer.callee) === "useCallback");
 };
-const isExtraReactiveDepAllowed = (node, scopes) => {
+const isExtraEffectDepAllowed = (node, scopes) => {
 	const rootIdentifier = getMemberRootIdentifier(node);
 	if (!rootIdentifier) return false;
 	const symbol = scopes.symbolFor(rootIdentifier);
@@ -10589,17 +10123,10 @@ const isUnstableInitializer = (node) => {
 	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left) || isUnstableInitializer(stripped.right);
 	return isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "ArrayExpression") || isNodeOfType(stripped, "ClassExpression") || isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment") || isNodeOfType(stripped, "AssignmentExpression") || isNodeOfType(stripped, "NewExpression");
 };
-const isExtraDepAllowedForHook = (hookName, node, scopes) => {
-	if (!isExtraReactiveDepAllowed(node, scopes)) return false;
-	if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName)) return true;
-	if (hookName !== "useMemo") return false;
-	const rootSymbol = getRootSymbol(node, scopes);
-	return Boolean(rootSymbol && !symbolHasStableValue(rootSymbol, scopes) && !isUnstableInitializer(rootSymbol.initializer));
-};
 const hasDirectIdentifierDeclarator = (symbol) => isNodeOfType(symbol.declarationNode, "VariableDeclarator") && isNodeOfType(symbol.declarationNode.id, "Identifier") || isNodeOfType(symbol.declarationNode, "ClassDeclaration");
 const isFunctionValueSymbol = (symbol) => getFunctionValueNode(symbol) !== null;
-const isStableSetterLikeSymbol = (symbol, scopes) => {
-	if (!symbolHasStableHookOrigin(symbol, scopes)) return false;
+const isStableSetterLikeSymbol = (symbol) => {
+	if (!symbolHasStableHookOrigin(symbol)) return false;
 	return symbol.name.startsWith("set") || symbol.name.startsWith("dispatch") || symbol.name.startsWith("startTransition");
 };
 const findStableSetterReference = (node, scopes) => {
@@ -10609,7 +10136,7 @@ const findStableSetterReference = (node, scopes) => {
 		if (current !== node && (isNodeOfType(current, "FunctionDeclaration") || isNodeOfType(current, "FunctionExpression") || isNodeOfType(current, "ArrowFunctionExpression"))) return;
 		if (isNodeOfType(current, "Identifier")) {
 			const symbol = scopes.referenceFor(current)?.resolvedSymbol;
-			if (symbol && isStableSetterLikeSymbol(symbol, scopes)) {
+			if (symbol && isStableSetterLikeSymbol(symbol)) {
 				setterName = symbol.name;
 				return;
 			}
@@ -10725,11 +10252,11 @@ const hasRefCurrentAssignmentInComponent = (refSymbol) => {
 	}
 	return false;
 };
-const isSeededDataRefSymbol = (refSymbol, scopes) => {
+const isSeededDataRefSymbol = (refSymbol) => {
 	if (!refSymbol) return false;
 	const initializer = refSymbol.initializer ? unwrapExpression$3(refSymbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	if (getHookName(initializer.callee, scopes) !== "useRef") return false;
+	if (getHookName(initializer.callee) !== "useRef") return false;
 	const firstArgument = initializer.arguments[0];
 	if (!firstArgument || !isAstNode(firstArgument)) return false;
 	const strippedArgument = unwrapExpression$3(firstArgument);
@@ -10769,9 +10296,7 @@ const isOuterFunctionScopeDep = (node, callback, scopes) => {
 	const componentOrHookScope = componentOrHookFunction ? scopes.ownScopeFor(componentOrHookFunction) : null;
 	return Boolean(componentOrHookScope && !isDescendantScope(symbol.scope, componentOrHookScope));
 };
-const hasMemberCallForRoot = (node, rootName, scopes) => {
-	const rootSymbol = closureCaptures(node, scopes).find((reference) => reference.resolvedSymbol?.name === rootName)?.resolvedSymbol ?? null;
-	if (!rootSymbol) return false;
+const hasMemberCallForRoot = (node, rootName) => {
 	let didFindMemberCall = false;
 	const visit = (current) => {
 		if (didFindMemberCall) return;
@@ -10787,7 +10312,7 @@ const hasMemberCallForRoot = (node, rootName, scopes) => {
 					}
 					chainObject = unwrapExpression$3(chainObject.object);
 				}
-				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName && scopes.symbolFor(chainObject) === rootSymbol) {
+				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName) {
 					didFindMemberCall = true;
 					return;
 				}
@@ -10805,11 +10330,9 @@ const hasMemberCallForRoot = (node, rootName, scopes) => {
 	visit(node);
 	return didFindMemberCall;
 };
-const addAggregatePropsDependency = (captureKeys, declaredKeys, callback, scopes) => {
-	const propsCaptureKeys = [...captureKeys].filter((captureKey) => captureKey.startsWith("props."));
-	if (propsCaptureKeys.length < 2 || declaredKeys.has("props")) return;
-	if (propsCaptureKeys.every((captureKey) => [...declaredKeys].some((declaredKey) => isMatchingDepOrPrefix(declaredKey, captureKey)))) return;
-	if (hasMemberCallForRoot(callback, "props", scopes)) captureKeys.add("props");
+const addAggregatePropsDependency = (captureKeys, declaredKeys, callback) => {
+	if ([...captureKeys].filter((captureKey) => captureKey.startsWith("props.")).length < 2 || declaredKeys.has("props")) return;
+	if (hasMemberCallForRoot(callback, "props")) captureKeys.add("props");
 };
 const exhaustiveDeps = defineRule({
 	id: "exhaustive-deps",
@@ -10864,7 +10387,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 		};
 		const isAutoDependenciesHook = (hookName) => settings.experimental_autoDependenciesHooks.includes(hookName);
 		return { CallExpression(node) {
-			const hookName = getHookName(node.callee, context.scopes);
+			const hookName = getHookName(node.callee);
 			if (!hookName || !isHookOfInterest(hookName, node.callee)) return;
 			const callbackArgumentIndex = getCallbackArgumentIndex(hookName);
 			const depsArgumentIndex = getDepsArgumentIndex(hookName);
@@ -10921,7 +10444,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (outerAssignments.length > 0) return;
 				const refCurrentInCleanup = findRefCurrentInCleanup(callbackToAnalyze, context.scopes);
 				const shouldCheckRefCleanup = EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) || Boolean(additionalHooksRegex && additionalHooksRegex.test(hookName));
-				if (refCurrentInCleanup && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) && !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol) && !isSeededDataRefSymbol(refCurrentInCleanup.refSymbol, context.scopes)) context.report({
+				if (refCurrentInCleanup && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) && !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol) && !isSeededDataRefSymbol(refCurrentInCleanup.refSymbol)) context.report({
 					node: callbackToAnalyze,
 					message: buildRefCleanupMessage(refCurrentInCleanup.refCurrentName)
 				});
@@ -11020,7 +10543,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				const fullChain = stringifyMemberChain(stripped);
 				if (fullChain && fullChain.endsWith(".current") && isNodeOfType(stripped, "MemberExpression") && isNodeOfType(stripped.object, "Identifier")) {
 					const refSymbol = context.scopes.symbolFor(stripped.object);
-					if (refSymbol && symbolHasStableHookOrigin(refSymbol, context.scopes)) {
+					if (refSymbol && symbolHasStableHookOrigin(refSymbol)) {
 						if (!didReportRefCurrentDep) {
 							context.report({
 								node: elementNode,
@@ -11058,7 +10581,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				declaredKeys.add(key);
 				declaredKeyToReportNode.set(key, elementNode);
 			}
-			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument, context.scopes);
+			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument);
 			const missingCaptureKeys = [];
 			for (const captureKey of captureKeys) {
 				let isCoveredByDeclared = false;
@@ -11144,7 +10667,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (stableCapturedNames.has(rootName) || stableCapturedNames.has(declaredKey)) continue;
 				if (outerFunctionCapturedNames.has(rootName)) continue;
 				const reportNode = declaredKeyToReportNode.get(declaredKey) ?? depsArgument;
-				if (isExtraDepAllowedForHook(hookName, reportNode, context.scopes)) continue;
+				if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) && isExtraEffectDepAllowed(reportNode, context.scopes)) continue;
 				if (missingCaptureKeys.length > 0 && isOuterFunctionScopeDep(reportNode, callbackToAnalyze ?? callbackArgument, context.scopes)) continue;
 				const rootSymbol = getRootSymbol(reportNode, context.scopes);
 				if (rootSymbol && missingCaptureKeys.length > 0 && isRecursiveInitializerCapture(rootSymbol, callbackToAnalyze ?? callbackArgument)) continue;
@@ -12816,6 +12339,20 @@ const collectHandlerReferencedNames = (root) => {
 	return names;
 };
 //#endregion
+//#region src/plugin/utils/get-function-binding-name.ts
+const getFunctionBindingIdentifier = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
+	const parent = functionNode.parent;
+	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === functionNode && isNodeOfType(parent.left, "Identifier")) return parent.left;
+	if (isNodeOfType(parent, "CallExpression")) {
+		const callParent = parent.parent;
+		if (isNodeOfType(callParent, "VariableDeclarator") && isNodeOfType(callParent.id, "Identifier")) return callParent.id;
+	}
+	return null;
+};
+const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(functionNode)?.name ?? null;
+//#endregion
 //#region src/plugin/rules/jotai/jotai-select-atom-in-render-body.ts
 const JOTAI_SELECT_ATOM_SOURCES = ["jotai/utils", "jotai"];
 const COMPONENT_NAME_PATTERN = /^[A-Z]/;
@@ -13960,7 +13497,7 @@ const jsHoistIntl = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/create-loop-aware-visitors.ts
-const ITERATOR_CALLBACK_METHOD_NAMES$1 = new Set([
+const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
 	"map",
 	"flatMap",
 	"forEach",
@@ -13979,7 +13516,7 @@ const isIteratorCallback = (node) => {
 	const parent = node.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
 	if (!parent.arguments.includes(node)) return false;
-	return isNodeOfType(parent.callee, "MemberExpression") && isNodeOfType(parent.callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES$1.has(parent.callee.property.name);
+	return isNodeOfType(parent.callee, "MemberExpression") && isNodeOfType(parent.callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES.has(parent.callee.property.name);
 };
 const createLoopAwareVisitors = (innerVisitors, options = {}) => {
 	let loopDepth = 0;
@@ -14208,7 +13745,7 @@ const findIndexedArrayObject = (callbackBody, indexParameterName) => {
 	});
 	return indexedArrayObject;
 };
-const unwrapChainExpression$3 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const unwrapChainExpression$2 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
 const LENGTH_EQUALITY_OPERATORS = new Set(["===", "=="]);
 const LENGTH_MISMATCH_OPERATORS = new Set([
 	"!==",
@@ -14220,17 +13757,17 @@ const LENGTH_MISMATCH_OPERATORS = new Set([
 ]);
 const LENGTH_ANY_COMPARISON_OPERATORS = new Set([...LENGTH_EQUALITY_OPERATORS, ...LENGTH_MISMATCH_OPERATORS]);
 const isLengthComparison = (candidate, receiverArray, indexedArray, operators) => {
-	const binaryGuard = unwrapChainExpression$3(candidate);
+	const binaryGuard = unwrapChainExpression$2(candidate);
 	if (!isNodeOfType(binaryGuard, "BinaryExpression")) return false;
 	if (!operators.has(binaryGuard.operator)) return false;
-	const leftSide = unwrapChainExpression$3(binaryGuard.left);
-	const rightSide = unwrapChainExpression$3(binaryGuard.right);
+	const leftSide = unwrapChainExpression$2(binaryGuard.left);
+	const rightSide = unwrapChainExpression$2(binaryGuard.right);
 	if (!isMemberProperty(leftSide, "length")) return false;
 	if (!isMemberProperty(rightSide, "length")) return false;
-	const leftLengthObject = unwrapChainExpression$3(leftSide.object);
-	const rightLengthObject = unwrapChainExpression$3(rightSide.object);
-	const normalizedReceiver = unwrapChainExpression$3(receiverArray);
-	const normalizedIndexed = unwrapChainExpression$3(indexedArray);
+	const leftLengthObject = unwrapChainExpression$2(leftSide.object);
+	const rightLengthObject = unwrapChainExpression$2(rightSide.object);
+	const normalizedReceiver = unwrapChainExpression$2(receiverArray);
+	const normalizedIndexed = unwrapChainExpression$2(indexedArray);
 	const matchesReceiverThenIndexed = areExpressionsStructurallyEqual(leftLengthObject, normalizedReceiver) && areExpressionsStructurallyEqual(rightLengthObject, normalizedIndexed);
 	const matchesIndexedThenReceiver = areExpressionsStructurallyEqual(leftLengthObject, normalizedIndexed) && areExpressionsStructurallyEqual(rightLengthObject, normalizedReceiver);
 	return matchesReceiverThenIndexed || matchesIndexedThenReceiver;
@@ -14317,18 +13854,18 @@ const LENGTH_PRESERVING_METHOD_NAMES = new Set([
 	"toReversed"
 ]);
 const peelLengthPreservingDerivation = (expression) => {
-	let current = unwrapChainExpression$3(expression);
+	let current = unwrapChainExpression$2(expression);
 	for (;;) {
 		if (isNodeOfType(current, "ArrayExpression") && current.elements?.length === 1 && isNodeOfType(current.elements[0], "SpreadElement")) {
-			current = unwrapChainExpression$3(current.elements[0].argument);
+			current = unwrapChainExpression$2(current.elements[0].argument);
 			continue;
 		}
 		if (isNodeOfType(current, "CallExpression")) {
-			const callee = unwrapChainExpression$3(current.callee);
+			const callee = unwrapChainExpression$2(current.callee);
 			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-				const calleeObject = unwrapChainExpression$3(callee.object);
+				const calleeObject = unwrapChainExpression$2(callee.object);
 				if (isNodeOfType(calleeObject, "Identifier") && calleeObject.name === "Array" && callee.property.name === "from" && current.arguments?.length === 1) {
-					current = unwrapChainExpression$3(current.arguments[0]);
+					current = unwrapChainExpression$2(current.arguments[0]);
 					continue;
 				}
 				if (LENGTH_PRESERVING_METHOD_NAMES.has(callee.property.name)) {
@@ -14373,7 +13910,7 @@ const resolveComparedArraySource = (expression, scopeNode) => {
 		const initializer = findConstInitializer(current.name, scopeNode);
 		if (!initializer) return current;
 		const peeledInitializer = peelLengthPreservingDerivation(initializer);
-		if (peeledInitializer === unwrapChainExpression$3(initializer)) return current;
+		if (peeledInitializer === unwrapChainExpression$2(initializer)) return current;
 		current = peeledInitializer;
 	}
 	return current;
@@ -20103,6 +19640,54 @@ const nextjsNoAElement = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/collect-effect-invoked-functions.ts
+const PROMISE_CHAIN_METHOD_NAMES$1 = new Set([
+	"then",
+	"catch",
+	"finally"
+]);
+const collectEffectInvokedFunctions = (effectCallback) => {
+	const invokedFunctions = new Set([effectCallback]);
+	const localFunctionBindings = /* @__PURE__ */ new Map();
+	const calledBindingNames = /* @__PURE__ */ new Set();
+	const pendingFunctions = [effectCallback];
+	const enqueue = (candidate) => {
+		const strippedCandidate = candidate ? stripParenExpression(candidate) : candidate;
+		if (!isFunctionLike$1(strippedCandidate) || invokedFunctions.has(strippedCandidate)) return;
+		invokedFunctions.add(strippedCandidate);
+		pendingFunctions.push(strippedCandidate);
+	};
+	const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
+	while (pendingFunctions.length > 0) {
+		const currentFunction = pendingFunctions.pop();
+		if (!currentFunction) break;
+		walkAst(currentFunction, (child) => {
+			if (child !== currentFunction && isFunctionLike$1(child)) {
+				if (isNodeOfType(child, "FunctionDeclaration") && isNodeOfType(child.id, "Identifier")) localFunctionBindings.set(child.id.name, child);
+				return false;
+			}
+			if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
+				const initializer = child.init ? stripParenExpression(child.init) : null;
+				if (isFunctionLike$1(initializer)) localFunctionBindings.set(child.id.name, initializer);
+				return;
+			}
+			if (!isNodeOfType(child, "CallExpression")) return;
+			const callee = stripParenExpression(child.callee);
+			if (isFunctionLike$1(callee)) {
+				enqueue(callee);
+				return;
+			}
+			if (isNodeOfType(callee, "Identifier")) {
+				calledBindingNames.add(callee.name);
+				return;
+			}
+			if (isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
+		});
+		for (const calledName of calledBindingNames) enqueue(localFunctionBindings.get(calledName));
+	}
+	return invokedFunctions;
+};
+//#endregion
 //#region src/plugin/utils/contains-fetch-call.ts
 const isFetchCall$1 = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
@@ -21086,7 +20671,6 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 			continue;
 		}
 		if (isNodeOfType(statement, "ExportNamedDeclaration")) {
-			if (statement.exportKind === "type") continue;
 			const declaration = statement.declaration;
 			if (declaration && isNodeOfType(declaration, "VariableDeclaration")) {
 				recordVariableDeclaration(declaration);
@@ -21101,7 +20685,6 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 			}
 			for (const specifier of statement.specifiers ?? []) {
 				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-				if (specifier.exportKind === "type") continue;
 				const local = specifier.local;
 				const exported = specifier.exported;
 				if (!isNodeOfType(local, "Identifier")) continue;
@@ -21150,37 +20733,25 @@ const resolveImportedExportName = (importSpecifier) => {
 	if (isNodeOfType(importSpecifier, "ImportDefaultSpecifier")) return "default";
 	return null;
 };
-const findReExportTargetsForName = (programRoot, exportedName) => {
+const findReExportSourcesForName = (programRoot, exportedName) => {
 	if (!isNodeOfType(programRoot, "Program")) return [];
-	const exportAllTargets = [];
+	const exportAllSources = [];
 	for (const statement of programRoot.body ?? []) {
 		if (isNodeOfType(statement, "ExportNamedDeclaration") && statement.source) {
-			if (statement.exportKind === "type") continue;
 			const sourceValue = statement.source.value;
 			if (typeof sourceValue !== "string") continue;
 			for (const specifier of statement.specifiers ?? []) {
 				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-				if (specifier.exportKind === "type") continue;
 				const exported = specifier.exported;
-				if ((isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null) !== exportedName) continue;
-				const local = specifier.local;
-				const importedName = isNodeOfType(local, "Identifier") ? local.name : isNodeOfType(local, "Literal") && typeof local.value === "string" ? local.value : null;
-				if (importedName) return [{
-					importedName,
-					source: sourceValue
-				}];
+				if ((isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null) === exportedName) return [sourceValue];
 			}
 		}
 		if (isNodeOfType(statement, "ExportAllDeclaration") && statement.source) {
-			if (statement.exportKind === "type" || statement.exported) continue;
 			const sourceValue = statement.source.value;
-			if (typeof sourceValue === "string") exportAllTargets.push({
-				importedName: exportedName,
-				source: sourceValue
-			});
+			if (typeof sourceValue === "string") exportAllSources.push(sourceValue);
 		}
 	}
-	return exportAllTargets;
+	return exportAllSources;
 };
 //#endregion
 //#region src/plugin/utils/attach-parent-references.ts
@@ -21269,6 +20840,139 @@ const parseSourceFile = (absoluteFilePath) => {
 	return parsedProgram;
 };
 //#endregion
+//#region src/plugin/utils/is-barrel-index-module.ts
+const INDEX_MODULE_FILE_PATTERN = /^index\.(?:[cm]?[jt]sx?|mjs)$/;
+const BINDING_IMPORT_DECLARATION_PATTERN = /^\s*import\s+(type\s+)?(?!["'])([^;]*?)\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const BARREL_REEXPORT_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?(?:\*(?:\s+as\s+([\w$]+))?|\{([\s\S]*?)\})\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?\{([\s\S]*?)\}\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const barrelIndexModuleInfoCache = /* @__PURE__ */ new Map();
+const isIndexModuleFilePath = (filePath) => INDEX_MODULE_FILE_PATTERN.test(path.basename(filePath));
+const createNonBarrelInfo = () => ({
+	isBarrel: false,
+	exportsByName: /* @__PURE__ */ new Map(),
+	starExportSources: []
+});
+const addImportedBinding = (importedBindings, binding) => {
+	importedBindings.set(binding.localName, {
+		...binding,
+		didExport: false
+	});
+};
+const collectNamedImportBindings = (namedSpecifiersText, source, declarationIsTypeOnly, importedBindings) => {
+	for (const specifier of parseExportSpecifiers(namedSpecifiersText, declarationIsTypeOnly)) addImportedBinding(importedBindings, {
+		localName: specifier.exportedName,
+		importedName: specifier.localName,
+		source,
+		isTypeOnly: specifier.isTypeOnly
+	});
+};
+const collectImportBindings = (importClause, source, declarationIsTypeOnly, importedBindings) => {
+	const trimmedImportClause = importClause.trim();
+	const namespaceMatch = trimmedImportClause.match(/(?:^|,\s*)\*\s+as\s+([\w$]+)/);
+	if (namespaceMatch?.[1]) addImportedBinding(importedBindings, {
+		localName: namespaceMatch[1],
+		importedName: "*",
+		source,
+		isTypeOnly: declarationIsTypeOnly
+	});
+	const namedImportMatch = trimmedImportClause.match(/\{([\s\S]*?)\}/);
+	if (namedImportMatch?.[1]) collectNamedImportBindings(namedImportMatch[1], source, declarationIsTypeOnly, importedBindings);
+	const defaultImportName = trimmedImportClause.split(",")[0]?.trim();
+	if (defaultImportName && !defaultImportName.startsWith("{") && !defaultImportName.startsWith("*")) addImportedBinding(importedBindings, {
+		localName: defaultImportName,
+		importedName: "default",
+		source,
+		isTypeOnly: declarationIsTypeOnly
+	});
+};
+const replaceKnownDeclarations = (sourceText, importedBindings, exportsByName, starExportSources) => {
+	let withoutKnownDeclarations = sourceText.replace(BINDING_IMPORT_DECLARATION_PATTERN, (_match, typeKeyword, importClause, source) => {
+		collectImportBindings(importClause, source, Boolean(typeKeyword), importedBindings);
+		return "";
+	});
+	withoutKnownDeclarations = withoutKnownDeclarations.replace(BARREL_REEXPORT_DECLARATION_PATTERN, (_match, typeKeyword, namespaceExportName, specifiersText, source) => {
+		const isTypeOnly = Boolean(typeKeyword);
+		if (namespaceExportName) {
+			exportsByName.set(namespaceExportName, {
+				exportedName: namespaceExportName,
+				importedName: "*",
+				source,
+				isTypeOnly
+			});
+			return "";
+		}
+		if (specifiersText) {
+			for (const specifier of parseExportSpecifiers(specifiersText, isTypeOnly)) exportsByName.set(specifier.exportedName, {
+				exportedName: specifier.exportedName,
+				importedName: specifier.localName,
+				source,
+				isTypeOnly: specifier.isTypeOnly
+			});
+			return "";
+		}
+		starExportSources.push(source);
+		return "";
+	});
+	withoutKnownDeclarations = withoutKnownDeclarations.replace(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN, (_match, typeKeyword, specifiersText) => {
+		for (const specifier of parseExportSpecifiers(specifiersText, Boolean(typeKeyword))) {
+			const importedBinding = importedBindings.get(specifier.localName);
+			if (!importedBinding) return _match;
+			importedBinding.didExport = true;
+			exportsByName.set(specifier.exportedName, {
+				exportedName: specifier.exportedName,
+				importedName: importedBinding.importedName,
+				source: importedBinding.source,
+				isTypeOnly: specifier.isTypeOnly || importedBinding.isTypeOnly
+			});
+		}
+		return "";
+	});
+	return withoutKnownDeclarations;
+};
+const hasUnexportedRuntimeImport = (importedBindings) => {
+	for (const binding of importedBindings.values()) if (!binding.isTypeOnly && !binding.didExport) return true;
+	return false;
+};
+const classifyBarrelModule = (sourceText) => {
+	const strippedSource = stripJsComments(sourceText).trim();
+	if (!strippedSource) return createNonBarrelInfo();
+	const importedBindings = /* @__PURE__ */ new Map();
+	const exportsByName = /* @__PURE__ */ new Map();
+	const starExportSources = [];
+	if (replaceKnownDeclarations(strippedSource, importedBindings, exportsByName, starExportSources).trim() || hasUnexportedRuntimeImport(importedBindings)) return createNonBarrelInfo();
+	return {
+		isBarrel: exportsByName.size > 0 || starExportSources.length > 0,
+		exportsByName,
+		starExportSources
+	};
+};
+const getBarrelIndexModuleInfo = (filePath) => {
+	if (!isIndexModuleFilePath(filePath)) return createNonBarrelInfo();
+	recordContentProbe(filePath);
+	let fileStat;
+	try {
+		fileStat = fs.statSync(filePath);
+	} catch {
+		fileStat = null;
+	}
+	const cachedResult = barrelIndexModuleInfoCache.get(filePath);
+	if (cachedResult !== void 0 && fileStat !== null && cachedResult.mtimeMs === fileStat.mtimeMs && cachedResult.size === fileStat.size) return cachedResult.moduleInfo;
+	if (fileStat === null) return createNonBarrelInfo();
+	let moduleInfo = createNonBarrelInfo();
+	try {
+		moduleInfo = classifyBarrelModule(fs.readFileSync(filePath, "utf8"));
+	} catch {
+		moduleInfo = createNonBarrelInfo();
+	}
+	barrelIndexModuleInfoCache.set(filePath, {
+		mtimeMs: fileStat.mtimeMs,
+		size: fileStat.size,
+		moduleInfo
+	});
+	return moduleInfo;
+};
+const isBarrelIndexModule = (filePath) => getBarrelIndexModuleInfo(filePath).isBarrel;
+//#endregion
 //#region src/plugin/utils/resolve-relative-import-path.ts
 const MODULE_FILE_EXTENSIONS = [
 	".ts",
@@ -21385,6 +21089,35 @@ const resolveModuleFileFromAbsolutePath = (importPath) => {
 };
 const resolveRelativeImportPath = (filename, source) => resolveModuleFileFromAbsolutePath(path.resolve(path.dirname(filename), source));
 //#endregion
+//#region src/plugin/utils/resolve-barrel-export-file-path.ts
+const getUniqueFilePath = (filePaths) => {
+	const uniqueFilePaths = new Set(filePaths);
+	if (uniqueFilePaths.size !== 1) return null;
+	const [filePath] = uniqueFilePaths;
+	return filePath ?? null;
+};
+const resolveStarExportFilePath = (barrelFilePath, exportedName, source, visitedFilePaths) => {
+	const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, source);
+	if (!resolvedTargetPath) return null;
+	const nestedTargetPath = resolveBarrelExportFilePath(resolvedTargetPath, exportedName, new Set(visitedFilePaths));
+	if (nestedTargetPath) return nestedTargetPath;
+	return doesModuleExportName(resolvedTargetPath, exportedName) ? resolvedTargetPath : null;
+};
+const resolveBarrelExportFilePath = (barrelFilePath, exportedName, visitedFilePaths = /* @__PURE__ */ new Set()) => {
+	if (visitedFilePaths.has(barrelFilePath)) return null;
+	visitedFilePaths.add(barrelFilePath);
+	const moduleInfo = getBarrelIndexModuleInfo(barrelFilePath);
+	if (!moduleInfo.isBarrel) return null;
+	const target = moduleInfo.exportsByName.get(exportedName);
+	if (target) {
+		const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, target.source);
+		if (!resolvedTargetPath) return null;
+		return resolveBarrelExportFilePath(resolvedTargetPath, target.importedName, visitedFilePaths) ?? resolvedTargetPath;
+	}
+	if (exportedName === "default") return null;
+	return getUniqueFilePath(moduleInfo.starExportSources.map((source) => resolveStarExportFilePath(barrelFilePath, exportedName, source, visitedFilePaths)).filter((filePath) => Boolean(filePath)));
+};
+//#endregion
 //#region src/plugin/utils/resolve-tsconfig-alias.ts
 const TSCONFIG_FILE_NAMES = ["tsconfig.json", "jsconfig.json"];
 const isObjectRecord = (value) => typeof value === "object" && value !== null;
@@ -21563,29 +21296,25 @@ const resolveTsconfigAliasPath = (fromFilename, source) => {
 };
 //#endregion
 //#region src/plugin/utils/resolve-module-path.ts
-const resolveModulePath = (fromFilename, source) => {
-	if (path.isAbsolute(source)) return null;
-	return source.startsWith(".") ? resolveRelativeImportPath(fromFilename, source) : resolveTsconfigAliasPath(fromFilename, source);
-};
+const resolveModulePath = (fromFilename, source) => resolveRelativeImportPath(fromFilename, source) ?? resolveTsconfigAliasPath(fromFilename, source);
 //#endregion
 //#region src/plugin/utils/resolve-cross-file-function-export.ts
 const resolveFunctionExportInFile = (filePath, exportedName, visitedFilePaths) => {
 	if (visitedFilePaths.size >= 4) return null;
 	if (visitedFilePaths.has(filePath)) return null;
 	visitedFilePaths.add(filePath);
-	const programRoot = parseSourceFile(filePath);
+	const actualFilePath = resolveBarrelExportFilePath(filePath, exportedName) ?? filePath;
+	const programRoot = parseSourceFile(actualFilePath);
 	if (!programRoot) return null;
 	const exported = findExportedFunctionBody(programRoot, exportedName);
 	if (exported) return exported;
-	const resolvedCandidates = /* @__PURE__ */ new Set();
-	for (const target of findReExportTargetsForName(programRoot, exportedName)) {
-		const nextFilePath = resolveModulePath(filePath, target.source);
+	for (const reExportSource of findReExportSourcesForName(programRoot, exportedName)) {
+		const nextFilePath = resolveModulePath(actualFilePath, reExportSource);
 		if (!nextFilePath) continue;
-		const resolved = resolveFunctionExportInFile(nextFilePath, target.importedName, new Set(visitedFilePaths));
-		if (resolved) resolvedCandidates.add(resolved);
+		const resolved = resolveFunctionExportInFile(nextFilePath, exportedName, visitedFilePaths);
+		if (resolved) return resolved;
 	}
-	if (resolvedCandidates.size !== 1) return null;
-	return resolvedCandidates.values().next().value ?? null;
+	return null;
 };
 const resolveCrossFileFunctionExport = (fromFilename, source, exportedName) => {
 	const resolvedFilePath = resolveModulePath(fromFilename, source);
@@ -22370,26 +22099,6 @@ const isReactNamedImportReference = (ref, importedName) => Boolean(ref?.resolved
 	const importDeclaration = declarationNode.parent;
 	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
 }));
-const isReactNamespaceImportReference = (ref) => Boolean(ref?.resolved?.defs.some((def) => {
-	if (def.type !== "ImportBinding") return false;
-	const declarationNode = def.node;
-	if (!isNodeOfType(declarationNode, "ImportNamespaceSpecifier") && !isNodeOfType(declarationNode, "ImportDefaultSpecifier")) return false;
-	const importDeclaration = declarationNode.parent;
-	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
-}));
-const isGenuineReactHookDeclarator = (analysis, declarator, hookName) => {
-	if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) return false;
-	const callee = stripParenExpression(declarator.init.callee);
-	if (isNodeOfType(callee, "Identifier")) {
-		const reference = getRef(analysis, callee);
-		if (!reference?.resolved) return callee.name === hookName;
-		return isReactNamedImportReference(reference, hookName);
-	}
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== hookName) return false;
-	const namespaceReference = getRef(analysis, callee.object);
-	if (!namespaceReference?.resolved) return callee.object.name === "React";
-	return isReactNamespaceImportReference(namespaceReference);
-};
 const isHookCallee$1 = (analysis, node, hookName) => {
 	if (!node) return false;
 	if (isNodeOfType(node, "Identifier")) {
@@ -22788,46 +22497,6 @@ const PURE_GLOBAL_CALLEE_NAMES = new Set([
 	"parseInt"
 ]);
 const PURE_GLOBAL_NAMESPACE_NAMES = new Set(["JSON", "Math"]);
-const PURE_HELPER_NAMESPACE_MEMBER_NAMES = new Map([["JSON", new Set([
-	"isRawJSON",
-	"parse",
-	"rawJSON",
-	"stringify"
-])], ["Math", new Set([
-	"abs",
-	"acos",
-	"acosh",
-	"asin",
-	"asinh",
-	"atan",
-	"atan2",
-	"atanh",
-	"cbrt",
-	"ceil",
-	"clz32",
-	"cos",
-	"cosh",
-	"exp",
-	"floor",
-	"fround",
-	"hypot",
-	"imul",
-	"log",
-	"log10",
-	"log1p",
-	"log2",
-	"max",
-	"min",
-	"pow",
-	"round",
-	"sign",
-	"sin",
-	"sinh",
-	"sqrt",
-	"tan",
-	"tanh",
-	"trunc"
-])]]);
 const PURE_MEMBER_TRANSFORM_NAMES = new Set([
 	"concat",
 	"filter",
@@ -22874,42 +22543,6 @@ const getParameterBindingIdentity = (analysis, functionNode, parameter) => {
 	}
 	return parameter;
 };
-const isAsyncOrGeneratorFunction = (functionNode) => Boolean(functionNode.async === true || functionNode.generator === true);
-const isModuleFunction = (functionNode) => {
-	let ancestor = functionNode.parent;
-	while (ancestor) {
-		if (isFunctionLike$1(ancestor)) return false;
-		if (isNodeOfType(ancestor, "Program")) return true;
-		ancestor = ancestor.parent;
-	}
-	return false;
-};
-const getFunctionBindingNames = (functionNode) => {
-	const names = /* @__PURE__ */ new Set();
-	if ((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id) names.add(functionNode.id.name);
-	const parent = functionNode.parent;
-	if (parent && isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) names.add(parent.id.name);
-	return names;
-};
-const collectModuleBindingNames = (functionNode) => {
-	let program = functionNode.parent;
-	while (program && !isNodeOfType(program, "Program")) program = program.parent;
-	const bindingNames = /* @__PURE__ */ new Set();
-	if (!program || !isNodeOfType(program, "Program")) return bindingNames;
-	for (const statement of program.body ?? []) {
-		if (isNodeOfType(statement, "ImportDeclaration")) {
-			for (const specifier of statement.specifiers ?? []) if (isNodeOfType(specifier.local, "Identifier")) bindingNames.add(specifier.local.name);
-			continue;
-		}
-		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") || isNodeOfType(statement, "ExportDefaultDeclaration") ? statement.declaration : statement;
-		if (isNodeOfType(declaration, "VariableDeclaration")) {
-			for (const declarator of declaration.declarations ?? []) collectPatternNames(declarator.id, bindingNames);
-			continue;
-		}
-		if ((isNodeOfType(declaration, "FunctionDeclaration") || isNodeOfType(declaration, "ClassDeclaration")) && isNodeOfType(declaration.id, "Identifier")) bindingNames.add(declaration.id.name);
-	}
-	return bindingNames;
-};
 const buildSubstitutions = (analysis, functionNode, argumentExpressions, parentFrame) => {
 	const substitutions = /* @__PURE__ */ new Map();
 	const parameters = getFunctionParameters(functionNode);
@@ -23040,7 +22673,7 @@ const collectIntroducedBindings = (analysis, functionNode) => {
 	for (const parameter of getFunctionParameters(functionNode)) if (isNodeOfType(parameter, "Identifier")) introducedBindings.add(getParameterBindingIdentity(analysis, functionNode, parameter));
 	return introducedBindings;
 };
-const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilename) => {
+const collectBoundedEffectExecutionFrames = (analysis, effectNode) => {
 	const effectFunction = getEffectFn(analysis, effectNode);
 	if (!effectFunction || !isFunctionLike$1(effectFunction) || effectFunction.async === true) return [];
 	const invokedFunctionEvidence = collectEffectInvokedFunctions(effectFunction);
@@ -23049,8 +22682,7 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilena
 		invocation: null,
 		isDeferred: false,
 		introducedBindings: /* @__PURE__ */ new Set(),
-		substitutions: /* @__PURE__ */ new Map(),
-		currentFilename
+		substitutions: /* @__PURE__ */ new Map()
 	};
 	const frames = [rootFrame];
 	walkAst(effectFunction, (child) => {
@@ -23071,8 +22703,7 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilena
 				invocation: child,
 				isDeferred,
 				introducedBindings,
-				substitutions: buildSubstitutions(analysis, callable, argumentsForCallable, rootFrame),
-				currentFilename
+				substitutions: buildSubstitutions(analysis, callable, argumentsForCallable, rootFrame)
 			});
 		};
 		if (isFunctionLike$1(callee)) {
@@ -23125,174 +22756,6 @@ const isOpaqueHookCall = (callExpression) => {
 	const calleeName = getCallCalleeName$1(callExpression);
 	return Boolean(calleeName && /^use[A-Z0-9]/.test(calleeName) && calleeName !== "useMemo" && calleeName !== "useCallback" && calleeName !== "useEffectEvent");
 };
-const analyzeHelperStatements = (statements, environment, usedParameterIndices, analyzeExpression) => {
-	let canContinue = true;
-	for (const statement of statements) {
-		if (!canContinue) {
-			if (!isNodeOfType(statement, "EmptyStatement")) return {
-				canContinue: false,
-				isValid: false
-			};
-			continue;
-		}
-		if (isNodeOfType(statement, "EmptyStatement")) continue;
-		if (isNodeOfType(statement, "ReturnStatement")) {
-			if (!statement.argument || !analyzeExpression(statement.argument, environment, usedParameterIndices)) return {
-				canContinue: false,
-				isValid: false
-			};
-			canContinue = false;
-			continue;
-		}
-		if (isNodeOfType(statement, "BlockStatement")) {
-			const blockSummary = analyzeHelperStatements(statement.body ?? [], environment, usedParameterIndices, analyzeExpression);
-			if (!blockSummary.isValid) return blockSummary;
-			canContinue = blockSummary.canContinue;
-			continue;
-		}
-		if (isNodeOfType(statement, "IfStatement")) {
-			if (!analyzeExpression(statement.test, environment, usedParameterIndices)) return {
-				canContinue: false,
-				isValid: false
-			};
-			const consequentSummary = analyzeHelperStatements([statement.consequent], environment, usedParameterIndices, analyzeExpression);
-			if (!consequentSummary.isValid) return consequentSummary;
-			const alternateSummary = statement.alternate ? analyzeHelperStatements([statement.alternate], environment, usedParameterIndices, analyzeExpression) : {
-				canContinue: true,
-				isValid: true
-			};
-			if (!alternateSummary.isValid) return alternateSummary;
-			canContinue = consequentSummary.canContinue || alternateSummary.canContinue;
-			continue;
-		}
-		return {
-			canContinue: false,
-			isValid: false
-		};
-	}
-	return {
-		canContinue,
-		isValid: true
-	};
-};
-const analyzeHelperExpression = (expression, environment, usedParameterIndices) => {
-	const node = stripParenExpression(expression);
-	if (isNodeOfType(node, "Literal") || isNodeOfType(node, "TemplateElement")) return true;
-	if (isNodeOfType(node, "Identifier")) {
-		const parameterIndex = environment.parameterIndices.get(node.name);
-		if (parameterIndex !== void 0) {
-			if (parameterIndex !== null) usedParameterIndices.add(parameterIndex);
-			return true;
-		}
-		return node.name === "undefined" || node.name === "NaN" || node.name === "Infinity";
-	}
-	if (isNodeOfType(node, "ArrayExpression")) return (node.elements ?? []).every((element) => !element || analyzeHelperExpression(element, environment, usedParameterIndices));
-	if (isNodeOfType(node, "ObjectExpression")) return (node.properties ?? []).every((property) => {
-		if (isNodeOfType(property, "SpreadElement")) return analyzeHelperExpression(property.argument, environment, usedParameterIndices);
-		if (!isNodeOfType(property, "Property") || property.kind !== "init" || property.method === true) return false;
-		if (property.computed && !analyzeHelperExpression(property.key, environment, usedParameterIndices)) return false;
-		return analyzeHelperExpression(property.value, environment, usedParameterIndices);
-	});
-	if (isNodeOfType(node, "TemplateLiteral")) return (node.expressions ?? []).every((templateExpression) => analyzeHelperExpression(templateExpression, environment, usedParameterIndices));
-	if (isNodeOfType(node, "UnaryExpression")) return node.operator !== "delete" && analyzeHelperExpression(node.argument, environment, usedParameterIndices);
-	if (isNodeOfType(node, "BinaryExpression") || isNodeOfType(node, "LogicalExpression")) return analyzeHelperExpression(node.left, environment, usedParameterIndices) && analyzeHelperExpression(node.right, environment, usedParameterIndices);
-	if (isNodeOfType(node, "ConditionalExpression")) return analyzeHelperExpression(node.test, environment, usedParameterIndices) && analyzeHelperExpression(node.consequent, environment, usedParameterIndices) && analyzeHelperExpression(node.alternate, environment, usedParameterIndices);
-	if (isNodeOfType(node, "MemberExpression")) {
-		if (!analyzeHelperExpression(node.object, environment, usedParameterIndices)) return false;
-		return !node.computed || analyzeHelperExpression(node.property, environment, usedParameterIndices);
-	}
-	if (isFunctionLike$1(node)) {
-		if (isAsyncOrGeneratorFunction(node)) return false;
-		const callbackParameterIndices = new Map(environment.parameterIndices);
-		for (const parameter of getFunctionParameters(node)) {
-			if (!isNodeOfType(parameter, "Identifier")) return false;
-			callbackParameterIndices.set(parameter.name, null);
-		}
-		const callbackEnvironment = {
-			parameterIndices: callbackParameterIndices,
-			recursiveNames: environment.recursiveNames,
-			shadowedGlobalNames: environment.shadowedGlobalNames
-		};
-		if (!isNodeOfType(node.body, "BlockStatement")) return analyzeHelperExpression(node.body, callbackEnvironment, usedParameterIndices);
-		const callbackSummary = analyzeHelperStatements(node.body.body ?? [], callbackEnvironment, usedParameterIndices, analyzeHelperExpression);
-		return callbackSummary.isValid && !callbackSummary.canContinue;
-	}
-	if (isNodeOfType(node, "CallExpression")) {
-		const callee = stripParenExpression(node.callee);
-		const calleeRoot = getMemberRoot(callee);
-		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && !environment.parameterIndices.has(callee.name) && !environment.recursiveNames.has(callee.name) && !environment.shadowedGlobalNames.has(callee.name);
-		const namespaceName = isNodeOfType(calleeRoot, "Identifier") && !environment.parameterIndices.has(calleeRoot.name) && !environment.recursiveNames.has(calleeRoot.name) && !environment.shadowedGlobalNames.has(calleeRoot.name) ? calleeRoot.name : null;
-		const namespaceMemberName = getStaticMemberName(callee);
-		const isPureNamespaceCall = isNodeOfType(callee, "MemberExpression") && namespaceName !== null && namespaceMemberName !== null && PURE_HELPER_NAMESPACE_MEMBER_NAMES.get(namespaceName)?.has(namespaceMemberName) === true;
-		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
-		if (!isPureGlobalCall && !isPureNamespaceCall && !isPureMemberTransform) return false;
-		if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression") && !analyzeHelperExpression(callee.object, environment, usedParameterIndices)) return false;
-		return (node.arguments ?? []).every((argument) => analyzeHelperExpression(argument, environment, usedParameterIndices));
-	}
-	if (isNodeOfType(node, "SpreadElement")) return analyzeHelperExpression(node.argument, environment, usedParameterIndices);
-	return false;
-};
-const helperSummaryCache = /* @__PURE__ */ new WeakMap();
-const summarizeHelperReturn = (functionNode) => {
-	if (!isFunctionLike$1(functionNode) || !isModuleFunction(functionNode)) return null;
-	if (helperSummaryCache.has(functionNode)) return helperSummaryCache.get(functionNode) ?? null;
-	if (isAsyncOrGeneratorFunction(functionNode)) {
-		helperSummaryCache.set(functionNode, null);
-		return null;
-	}
-	const parameterIndices = /* @__PURE__ */ new Map();
-	const parameters = getFunctionParameters(functionNode);
-	for (let parameterIndex = 0; parameterIndex < parameters.length; parameterIndex += 1) {
-		const parameter = parameters[parameterIndex];
-		if (!parameter || !isNodeOfType(parameter, "Identifier") || parameterIndices.has(parameter.name)) {
-			helperSummaryCache.set(functionNode, null);
-			return null;
-		}
-		parameterIndices.set(parameter.name, parameterIndex);
-	}
-	const environment = {
-		parameterIndices,
-		recursiveNames: getFunctionBindingNames(functionNode),
-		shadowedGlobalNames: collectModuleBindingNames(functionNode)
-	};
-	const usedParameterIndices = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) {
-		if (!analyzeHelperExpression(functionNode.body, environment, usedParameterIndices)) {
-			helperSummaryCache.set(functionNode, null);
-			return null;
-		}
-	} else {
-		const controlFlowSummary = analyzeHelperStatements(functionNode.body.body ?? [], environment, usedParameterIndices, analyzeHelperExpression);
-		if (!controlFlowSummary.isValid || controlFlowSummary.canContinue) {
-			helperSummaryCache.set(functionNode, null);
-			return null;
-		}
-	}
-	const summary = { usedParameterIndices };
-	helperSummaryCache.set(functionNode, summary);
-	return summary;
-};
-const resolveValueHelperFunction = (analysis, callee, currentFilename) => {
-	if (!isNodeOfType(callee, "Identifier")) return null;
-	const reference = getRef(analysis, callee);
-	if (!reference?.resolved) return null;
-	const importDefinition = reference.resolved.defs.find((definition) => definition.type === "ImportBinding");
-	if (importDefinition) {
-		if (!currentFilename) return null;
-		const specifier = importDefinition.node;
-		if (!isNodeOfType(specifier, "ImportSpecifier") && !isNodeOfType(specifier, "ImportDefaultSpecifier")) return null;
-		const importDeclaration = specifier.parent;
-		if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return null;
-		if (importDeclaration.importKind === "type" || isNodeOfType(specifier, "ImportSpecifier") && specifier.importKind === "type") return null;
-		const source = importDeclaration.source?.value;
-		if (typeof source !== "string") return null;
-		const exportedName = resolveImportedExportName(specifier);
-		if (!exportedName) return null;
-		return resolveCrossFileFunctionExport(currentFilename, source, exportedName);
-	}
-	const callable = resolveWrappedCallable(analysis, callee);
-	return callable && isModuleFunction(callable) ? callable : null;
-};
 const isLocallyConstructedObjectMember = (reference, memberExpression) => isNodeOfType(memberExpression, "MemberExpression") && reference.resolved?.defs.some((definition) => {
 	const definitionNode = definition.node;
 	return isNodeOfType(definitionNode, "VariableDeclarator") && Boolean(definitionNode.init) && (isNodeOfType(definitionNode.init, "ObjectExpression") || isNodeOfType(definitionNode.init, "ArrayExpression"));
@@ -23378,55 +22841,38 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		const calleeRoot = getMemberRoot(callee);
 		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && getIdentifierBindingIdentity(analysis, callee) === null || isNodeOfType(calleeRoot, "Identifier") && PURE_GLOBAL_NAMESPACE_NAMES.has(calleeRoot.name) && getIdentifierBindingIdentity(analysis, calleeRoot) === null;
 		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
-		if (isPureGlobalCall || isPureMemberTransform) {
-			if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression")) mergeEvidence(evidence, collectValueEvidence(analysis, callee.object, frame, remainingCallFrames, new Set(visitedBindings)));
-			for (const argument of node.arguments ?? []) {
-				if (isFunctionLike$1(argument)) continue;
-				mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames, new Set(visitedBindings)));
-			}
+		if (isPureMemberTransform) mergeEvidence(evidence, collectValueEvidence(analysis, callee.object, frame, remainingCallFrames, new Set(visitedBindings)));
+		for (const argument of node.arguments ?? []) {
+			if (isFunctionLike$1(argument)) continue;
+			mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames, new Set(visitedBindings)));
+		}
+		if (isPureGlobalCall || isPureMemberTransform) return evidence;
+		if (isNodeOfType(callee, "MemberExpression")) {
+			evidence.hasUnknownSource = true;
 			return evidence;
 		}
 		if (remainingCallFrames <= 0) {
 			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		const localHelperFunction = resolveWrappedCallable(analysis, callee);
-		if (localHelperFunction && !isModuleFunction(localHelperFunction)) {
-			if (isAsyncOrGeneratorFunction(localHelperFunction) || functionInvokesItself(analysis, localHelperFunction)) {
-				evidence.hasUnknownSource = true;
-				return evidence;
-			}
-			const localHelperFrame = {
-				functionNode: localHelperFunction,
-				invocation: node,
-				isDeferred: false,
-				introducedBindings: /* @__PURE__ */ new Set(),
-				substitutions: buildSubstitutions(analysis, localHelperFunction, node.arguments ?? [], frame),
-				currentFilename: frame.currentFilename
-			};
-			const returnedExpressions = getReturnedExpressions(localHelperFunction);
-			if (returnedExpressions.length === 0) {
-				evidence.hasUnknownSource = true;
-				return evidence;
-			}
-			for (const returnedExpression of returnedExpressions) mergeEvidence(evidence, collectValueEvidence(analysis, returnedExpression, localHelperFrame, remainingCallFrames - 1, new Set(visitedBindings)));
+		const callable = resolveWrappedCallable(analysis, callee);
+		if (!callable || callable.async === true || functionInvokesItself(analysis, callable)) {
+			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		const helperFunction = resolveValueHelperFunction(analysis, callee, frame.currentFilename);
-		const helperSummary = helperFunction ? summarizeHelperReturn(helperFunction) : null;
-		if (!helperSummary) {
+		const valueFrame = {
+			functionNode: callable,
+			invocation: node,
+			isDeferred: false,
+			introducedBindings: /* @__PURE__ */ new Set(),
+			substitutions: buildSubstitutions(analysis, callable, node.arguments ?? [], frame)
+		};
+		const returnedExpressions = getReturnedExpressions(callable);
+		if (returnedExpressions.length === 0) {
 			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		const argumentsForHelper = node.arguments ?? [];
-		for (const parameterIndex of helperSummary.usedParameterIndices) {
-			const argument = argumentsForHelper[parameterIndex];
-			if (!argument) {
-				evidence.hasUnknownSource = true;
-				return evidence;
-			}
-			mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames - 1, new Set(visitedBindings)));
-		}
+		for (const returnedExpression of returnedExpressions) mergeEvidence(evidence, collectValueEvidence(analysis, returnedExpression, valueFrame, remainingCallFrames - 1, new Set(visitedBindings)));
 		return evidence;
 	}
 	if (isFunctionLike$1(node) || isNodeOfType(node, "AwaitExpression")) {
@@ -23444,20 +22890,6 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 	}
 	return evidence;
 };
-const collectRenderValueEvidence = (analysis, expression, componentFunction, currentFilename) => {
-	const evidence = collectValueEvidence(analysis, expression, {
-		functionNode: componentFunction,
-		invocation: null,
-		isDeferred: false,
-		introducedBindings: /* @__PURE__ */ new Set(),
-		substitutions: /* @__PURE__ */ new Map(),
-		currentFilename
-	}, 1);
-	return {
-		sourceReferences: evidence.sourceReferences,
-		isExclusivelyRenderKnown: evidence.sourceReferences.size > 0 && !evidence.hasUnknownSource && !evidence.hasDeferredIntroducedValue && !evidence.readsExternalValue
-	};
-};
 const findStateSetterReference = (analysis, callExpression) => {
 	if (!isNodeOfType(callExpression, "CallExpression")) return null;
 	const callee = stripParenExpression(callExpression.callee);
@@ -23520,8 +22952,8 @@ const areInMutuallyExclusiveBranches = (leftNode, rightNode) => {
 	}
 	return false;
 };
-const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) => {
-	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode, currentFilename);
+const collectEffectStateWriteFacts = (analysis, effectNode) => {
+	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode);
 	if (frames.length === 0) return [];
 	const effectHasCleanup = hasCleanup(analysis, effectNode);
 	const cleanupManagedStateDeclarators = /* @__PURE__ */ new Set();
@@ -23541,8 +22973,7 @@ const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) =>
 				invocation: callExpression,
 				isDeferred: frame.isDeferred,
 				introducedBindings: collectIntroducedBindings(analysis, writtenValue),
-				substitutions: /* @__PURE__ */ new Map(),
-				currentFilename
+				substitutions: /* @__PURE__ */ new Map()
 			};
 			valueEvidence = emptyEvidence();
 			const returnedExpressions = getReturnedExpressions(writtenValue);
@@ -23591,7 +23022,7 @@ const noAdjustStateOnPropChange = defineRule({
 		const dependencyReferences = getEffectDepsRefs(analysis, node);
 		if (!dependencyReferences) return;
 		if (!dependencyReferences.flatMap((reference) => isState(analysis, reference) ? [] : getUpstreamRefs(analysis, reference)).some((reference) => isProp(analysis, reference))) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
 			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 			context.report({
 				node: fact.callExpression,
@@ -24852,139 +24283,6 @@ const createRelativeImportSource = (filename, targetFilePath) => {
 	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 };
 //#endregion
-//#region src/plugin/utils/is-barrel-index-module.ts
-const INDEX_MODULE_FILE_PATTERN = /^index\.(?:[cm]?[jt]sx?|mjs)$/;
-const BINDING_IMPORT_DECLARATION_PATTERN = /^\s*import\s+(type\s+)?(?!["'])([^;]*?)\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const BARREL_REEXPORT_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?(?:\*(?:\s+as\s+([\w$]+))?|\{([\s\S]*?)\})\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?\{([\s\S]*?)\}\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const barrelIndexModuleInfoCache = /* @__PURE__ */ new Map();
-const isIndexModuleFilePath = (filePath) => INDEX_MODULE_FILE_PATTERN.test(path.basename(filePath));
-const createNonBarrelInfo = () => ({
-	isBarrel: false,
-	exportsByName: /* @__PURE__ */ new Map(),
-	starExportSources: []
-});
-const addImportedBinding = (importedBindings, binding) => {
-	importedBindings.set(binding.localName, {
-		...binding,
-		didExport: false
-	});
-};
-const collectNamedImportBindings = (namedSpecifiersText, source, declarationIsTypeOnly, importedBindings) => {
-	for (const specifier of parseExportSpecifiers(namedSpecifiersText, declarationIsTypeOnly)) addImportedBinding(importedBindings, {
-		localName: specifier.exportedName,
-		importedName: specifier.localName,
-		source,
-		isTypeOnly: specifier.isTypeOnly
-	});
-};
-const collectImportBindings = (importClause, source, declarationIsTypeOnly, importedBindings) => {
-	const trimmedImportClause = importClause.trim();
-	const namespaceMatch = trimmedImportClause.match(/(?:^|,\s*)\*\s+as\s+([\w$]+)/);
-	if (namespaceMatch?.[1]) addImportedBinding(importedBindings, {
-		localName: namespaceMatch[1],
-		importedName: "*",
-		source,
-		isTypeOnly: declarationIsTypeOnly
-	});
-	const namedImportMatch = trimmedImportClause.match(/\{([\s\S]*?)\}/);
-	if (namedImportMatch?.[1]) collectNamedImportBindings(namedImportMatch[1], source, declarationIsTypeOnly, importedBindings);
-	const defaultImportName = trimmedImportClause.split(",")[0]?.trim();
-	if (defaultImportName && !defaultImportName.startsWith("{") && !defaultImportName.startsWith("*")) addImportedBinding(importedBindings, {
-		localName: defaultImportName,
-		importedName: "default",
-		source,
-		isTypeOnly: declarationIsTypeOnly
-	});
-};
-const replaceKnownDeclarations = (sourceText, importedBindings, exportsByName, starExportSources) => {
-	let withoutKnownDeclarations = sourceText.replace(BINDING_IMPORT_DECLARATION_PATTERN, (_match, typeKeyword, importClause, source) => {
-		collectImportBindings(importClause, source, Boolean(typeKeyword), importedBindings);
-		return "";
-	});
-	withoutKnownDeclarations = withoutKnownDeclarations.replace(BARREL_REEXPORT_DECLARATION_PATTERN, (_match, typeKeyword, namespaceExportName, specifiersText, source) => {
-		const isTypeOnly = Boolean(typeKeyword);
-		if (namespaceExportName) {
-			exportsByName.set(namespaceExportName, {
-				exportedName: namespaceExportName,
-				importedName: "*",
-				source,
-				isTypeOnly
-			});
-			return "";
-		}
-		if (specifiersText) {
-			for (const specifier of parseExportSpecifiers(specifiersText, isTypeOnly)) exportsByName.set(specifier.exportedName, {
-				exportedName: specifier.exportedName,
-				importedName: specifier.localName,
-				source,
-				isTypeOnly: specifier.isTypeOnly
-			});
-			return "";
-		}
-		starExportSources.push(source);
-		return "";
-	});
-	withoutKnownDeclarations = withoutKnownDeclarations.replace(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN, (_match, typeKeyword, specifiersText) => {
-		for (const specifier of parseExportSpecifiers(specifiersText, Boolean(typeKeyword))) {
-			const importedBinding = importedBindings.get(specifier.localName);
-			if (!importedBinding) return _match;
-			importedBinding.didExport = true;
-			exportsByName.set(specifier.exportedName, {
-				exportedName: specifier.exportedName,
-				importedName: importedBinding.importedName,
-				source: importedBinding.source,
-				isTypeOnly: specifier.isTypeOnly || importedBinding.isTypeOnly
-			});
-		}
-		return "";
-	});
-	return withoutKnownDeclarations;
-};
-const hasUnexportedRuntimeImport = (importedBindings) => {
-	for (const binding of importedBindings.values()) if (!binding.isTypeOnly && !binding.didExport) return true;
-	return false;
-};
-const classifyBarrelModule = (sourceText) => {
-	const strippedSource = stripJsComments(sourceText).trim();
-	if (!strippedSource) return createNonBarrelInfo();
-	const importedBindings = /* @__PURE__ */ new Map();
-	const exportsByName = /* @__PURE__ */ new Map();
-	const starExportSources = [];
-	if (replaceKnownDeclarations(strippedSource, importedBindings, exportsByName, starExportSources).trim() || hasUnexportedRuntimeImport(importedBindings)) return createNonBarrelInfo();
-	return {
-		isBarrel: exportsByName.size > 0 || starExportSources.length > 0,
-		exportsByName,
-		starExportSources
-	};
-};
-const getBarrelIndexModuleInfo = (filePath) => {
-	if (!isIndexModuleFilePath(filePath)) return createNonBarrelInfo();
-	recordContentProbe(filePath);
-	let fileStat;
-	try {
-		fileStat = fs.statSync(filePath);
-	} catch {
-		fileStat = null;
-	}
-	const cachedResult = barrelIndexModuleInfoCache.get(filePath);
-	if (cachedResult !== void 0 && fileStat !== null && cachedResult.mtimeMs === fileStat.mtimeMs && cachedResult.size === fileStat.size) return cachedResult.moduleInfo;
-	if (fileStat === null) return createNonBarrelInfo();
-	let moduleInfo = createNonBarrelInfo();
-	try {
-		moduleInfo = classifyBarrelModule(fs.readFileSync(filePath, "utf8"));
-	} catch {
-		moduleInfo = createNonBarrelInfo();
-	}
-	barrelIndexModuleInfoCache.set(filePath, {
-		mtimeMs: fileStat.mtimeMs,
-		size: fileStat.size,
-		moduleInfo
-	});
-	return moduleInfo;
-};
-const isBarrelIndexModule = (filePath) => getBarrelIndexModuleInfo(filePath).isBarrel;
-//#endregion
 //#region src/react-native-dependency-names.ts
 const EXPO_MANAGED_DEPENDENCY_NAMES = new Set([
 	"expo",
@@ -25187,35 +24485,6 @@ const classifyReactNativeFileTarget = (context) => {
 };
 const isReactNativeFileActive = (context) => classifyReactNativeFileTarget(context) !== "web";
 //#endregion
-//#region src/plugin/utils/resolve-barrel-export-file-path.ts
-const getUniqueFilePath = (filePaths) => {
-	const uniqueFilePaths = new Set(filePaths);
-	if (uniqueFilePaths.size !== 1) return null;
-	const [filePath] = uniqueFilePaths;
-	return filePath ?? null;
-};
-const resolveStarExportFilePath = (barrelFilePath, exportedName, source, visitedFilePaths) => {
-	const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, source);
-	if (!resolvedTargetPath) return null;
-	const nestedTargetPath = resolveBarrelExportFilePath(resolvedTargetPath, exportedName, new Set(visitedFilePaths));
-	if (nestedTargetPath) return nestedTargetPath;
-	return doesModuleExportName(resolvedTargetPath, exportedName) ? resolvedTargetPath : null;
-};
-const resolveBarrelExportFilePath = (barrelFilePath, exportedName, visitedFilePaths = /* @__PURE__ */ new Set()) => {
-	if (visitedFilePaths.has(barrelFilePath)) return null;
-	visitedFilePaths.add(barrelFilePath);
-	const moduleInfo = getBarrelIndexModuleInfo(barrelFilePath);
-	if (!moduleInfo.isBarrel) return null;
-	const target = moduleInfo.exportsByName.get(exportedName);
-	if (target) {
-		const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, target.source);
-		if (!resolvedTargetPath) return null;
-		return resolveBarrelExportFilePath(resolvedTargetPath, target.importedName, visitedFilePaths) ?? resolvedTargetPath;
-	}
-	if (exportedName === "default") return null;
-	return getUniqueFilePath(moduleInfo.starExportSources.map((source) => resolveStarExportFilePath(barrelFilePath, exportedName, source, visitedFilePaths)).filter((filePath) => Boolean(filePath)));
-};
-//#endregion
 //#region src/plugin/rules/bundle-size/no-barrel-import.ts
 const TYPE_DECLARATION_FILE_PATTERN = /\.d\.[cm]?ts$/;
 const SERVER_ONLY_FILE_PATTERN = /\.server\.[cm]?[jt]sx?$/;
@@ -25545,7 +24814,7 @@ const isAsyncFunctionLike = (node) => {
 	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) return Boolean(node.async);
 	return false;
 };
-const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
+const SYNCHRONOUS_ITERATION_METHOD_NAMES$1 = new Set([
 	"forEach",
 	"map",
 	"filter",
@@ -25566,7 +24835,7 @@ const runsOnEffectDispatch = (functionNode) => {
 	if (parent.callee === functionNode) return true;
 	if (!(parent.arguments ?? []).some((argument) => argument === functionNode)) return false;
 	const callee = parent.callee;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.has(callee.property.name);
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES$1.has(callee.property.name);
 };
 const isTerminatingStatement = (statement) => isNodeOfType(statement, "BreakStatement") || isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "ContinueStatement");
 const analyzeBranchStatements = (branch, context) => analyzeStatementSequence(isNodeOfType(branch, "BlockStatement") ? branch.body ?? [] : [branch], context);
@@ -26510,6 +25779,57 @@ const noDefaultProps = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-derived-state.ts
+const getStateName$1 = (stateDeclarator) => {
+	if (!isNodeOfType(stateDeclarator, "VariableDeclarator")) return "<state>";
+	if (!isNodeOfType(stateDeclarator.id, "ArrayPattern")) return "<state>";
+	const stateBinding = stateDeclarator.id.elements?.[0];
+	if (stateBinding && isNodeOfType(stateBinding, "Identifier")) return stateBinding.name;
+	const setterBinding = stateDeclarator.id.elements?.[1];
+	if (!setterBinding || !isNodeOfType(setterBinding, "Identifier")) return "<state>";
+	if (!setterBinding.name.startsWith("set") || setterBinding.name.length <= 3) return setterBinding.name;
+	return setterBinding.name[3].toLowerCase() + setterBinding.name.slice(4);
+};
+const noDerivedState = defineRule({
+	id: "no-derived-state",
+	title: "Derived value copied into state",
+	severity: "warn",
+	tags: ["test-noise"],
+	recommendation: "Work out the value while rendering (or with useMemo if it's expensive) instead of copying it into useState through a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state",
+	create: (context) => ({ CallExpression(node) {
+		if (!isUseEffect(node)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
+			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
+			const stateName = getStateName$1(fact.stateDeclarator);
+			context.report({
+				node: fact.callExpression,
+				message: `Storing "${stateName}" in state when you can derive it from other values costs an extra render.`
+			});
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/rules/state-and-effects/no-derived-state-effect.ts
+const noDerivedStateEffect = defineRule({
+	id: "no-derived-state-effect",
+	title: "Derived state stored in an effect",
+	severity: "warn",
+	tags: ["test-noise"],
+	recommendation: "Work out derived values while rendering: `const x = fn(dep)`. To reset a component's state when a prop changes, give it a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
+	create: (context) => ({ CallExpression(node) {
+		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		if (!collectEffectStateWriteFacts(analysis, node).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
+		context.report({
+			node,
+			message: "You pay an extra render for state you can derive from other values."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/utils/is-component-function.ts
 const isFunctionAssignedToComponent = (functionNode) => {
 	let cursor = functionNode.parent ?? null;
@@ -26643,236 +25963,6 @@ const createComponentPropStackTracker = (callbacks) => {
 	};
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/collect-render-state-write-facts.ts
-const findReferenceDeclarator = (reference) => {
-	for (const definition of reference.resolved?.defs ?? []) {
-		const definitionNode = definition.node;
-		if (isNodeOfType(definitionNode, "VariableDeclarator")) return definitionNode;
-	}
-	return null;
-};
-const resolveSimpleRenderSource = (analysis, expression, visitedBindings = /* @__PURE__ */ new Set()) => {
-	const node = stripParenExpression(expression);
-	if (!isNodeOfType(node, "Identifier")) return null;
-	const reference = getRef(analysis, node);
-	if (!reference?.resolved || visitedBindings.has(reference.resolved)) return null;
-	if (isProp(analysis, reference)) {
-		if (isWholePropsObjectReference(analysis, reference)) return null;
-		return { bindingIdentity: reference.resolved };
-	}
-	if (isState(analysis, reference)) {
-		const stateDeclarator = getUseStateDecl(analysis, reference);
-		if (!stateDeclarator || !isGenuineReactHookDeclarator(analysis, stateDeclarator, "useState") || isExternallyDrivenState(analysis, reference)) return null;
-		return { bindingIdentity: reference.resolved };
-	}
-	if (reference.resolved.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init)) return null;
-	const declarator = findReferenceDeclarator(reference);
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !declarator.init) return null;
-	const nextVisitedBindings = new Set(visitedBindings);
-	nextVisitedBindings.add(reference.resolved);
-	return resolveSimpleRenderSource(analysis, declarator.init, nextVisitedBindings);
-};
-const doesEvidenceMatchSource = (evidence, source) => evidence.isExclusivelyRenderKnown && evidence.sourceReferences.size > 0 && [...evidence.sourceReferences].every((sourceReference) => sourceReference.resolved === source.bindingIdentity);
-const getDirectBranchStatements = (branch) => {
-	if (isNodeOfType(branch, "BlockStatement")) return branch.body ?? [];
-	return [branch];
-};
-const getDirectCallExpression = (statement) => {
-	if (!isNodeOfType(statement, "ExpressionStatement")) return null;
-	const expression = stripParenExpression(statement.expression);
-	return isNodeOfType(expression, "CallExpression") ? expression : null;
-};
-const getDirectAssignmentExpression = (statement) => {
-	if (!isNodeOfType(statement, "ExpressionStatement")) return null;
-	const expression = stripParenExpression(statement.expression);
-	return isNodeOfType(expression, "AssignmentExpression") && expression.operator === "=" ? expression : null;
-};
-const findDirectStateSetterReference = (analysis, callExpression) => {
-	if (!isNodeOfType(callExpression, "CallExpression")) return null;
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "Identifier")) return null;
-	const reference = getRef(analysis, callee);
-	return reference && isStateSetter(analysis, reference) ? reference : null;
-};
-const getStaticRefCurrentReference = (analysis, expression) => {
-	const node = stripParenExpression(expression);
-	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.object, "Identifier") || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return null;
-	const reference = getRef(analysis, node.object);
-	if (!reference) return null;
-	const declarator = findReferenceDeclarator(reference);
-	return declarator && isGenuineReactHookDeclarator(analysis, declarator, "useRef") ? reference : null;
-};
-const getStateTracker = (analysis, expression) => {
-	const node = stripParenExpression(expression);
-	if (!isNodeOfType(node, "Identifier")) return null;
-	const reference = getRef(analysis, node);
-	if (!reference || !isState(analysis, reference)) return null;
-	const declarator = getUseStateDecl(analysis, reference);
-	if (!declarator || !isGenuineReactHookDeclarator(analysis, declarator, "useState")) return null;
-	return {
-		kind: "state",
-		declarator
-	};
-};
-const getRefTracker = (analysis, expression) => {
-	const reference = getStaticRefCurrentReference(analysis, expression);
-	return reference ? {
-		kind: "ref",
-		reference
-	} : null;
-};
-const getTrackerInitializer = (tracker) => {
-	const declarator = tracker.kind === "state" ? tracker.declarator : findReferenceDeclarator(tracker.reference);
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) return null;
-	const initializer = declarator.init.arguments?.[0];
-	return initializer ? initializer : null;
-};
-const isTrackerSynchronized = (analysis, guard) => {
-	for (const statement of guard.statements) {
-		if (guard.tracker.kind === "state") {
-			const callExpression = getDirectCallExpression(statement);
-			if (!callExpression || !isNodeOfType(callExpression, "CallExpression")) continue;
-			const setterReference = findDirectStateSetterReference(analysis, callExpression);
-			if (!setterReference || getUseStateDecl(analysis, setterReference) !== guard.tracker.declarator || (callExpression.arguments ?? []).length !== 1) continue;
-			const writtenValue = callExpression.arguments?.[0];
-			if (writtenValue && resolveSimpleRenderSource(analysis, writtenValue)?.bindingIdentity === guard.source.bindingIdentity) return true;
-			continue;
-		}
-		const assignmentExpression = getDirectAssignmentExpression(statement);
-		if (!assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression")) continue;
-		if (getStaticRefCurrentReference(analysis, assignmentExpression.left)?.resolved !== guard.tracker.reference.resolved) continue;
-		if (resolveSimpleRenderSource(analysis, assignmentExpression.right)?.bindingIdentity === guard.source.bindingIdentity) return true;
-	}
-	return false;
-};
-const parseRenderTrackerGuard = (analysis, statement) => {
-	if (!isNodeOfType(statement, "IfStatement") || statement.alternate || !isNodeOfType(statement.test, "BinaryExpression") || statement.test.operator !== "!==" || !isNodeOfType(statement.consequent, "BlockStatement")) return null;
-	const left = statement.test.left;
-	const right = statement.test.right;
-	const candidates = [{
-		sourceExpression: left,
-		trackerExpression: right
-	}, {
-		sourceExpression: right,
-		trackerExpression: left
-	}];
-	for (const candidate of candidates) {
-		const source = resolveSimpleRenderSource(analysis, candidate.sourceExpression);
-		if (!source) continue;
-		const tracker = getStateTracker(analysis, candidate.trackerExpression) ?? getRefTracker(analysis, candidate.trackerExpression);
-		if (!tracker) continue;
-		const trackerInitializer = getTrackerInitializer(tracker);
-		if (!trackerInitializer || resolveSimpleRenderSource(analysis, trackerInitializer)?.bindingIdentity !== source.bindingIdentity) continue;
-		const guard = {
-			source,
-			tracker,
-			statements: getDirectBranchStatements(statement.consequent)
-		};
-		return isTrackerSynchronized(analysis, guard) ? guard : null;
-	}
-	return null;
-};
-const isExclusiveDestinationSetterReference = (setterReference, callExpression) => {
-	if (!setterReference.resolved || !isNodeOfType(callExpression, "CallExpression")) return false;
-	const references = setterReference.resolved.references.filter((reference) => !reference.init);
-	if (references.length !== 1) return false;
-	return references[0].identifier === callExpression.callee;
-};
-const getStateInitializer = (stateDeclarator) => {
-	if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression")) return null;
-	const initializer = stateDeclarator.init.arguments?.[0];
-	return initializer ? initializer : null;
-};
-const collectRenderStateWriteFacts = (analysis, componentBody, currentFilename) => {
-	if (!isNodeOfType(componentBody, "BlockStatement") || !componentBody.parent || !isFunctionLike$1(componentBody.parent)) return [];
-	const componentFunction = componentBody.parent;
-	const facts = [];
-	for (const statement of componentBody.body ?? []) {
-		const guard = parseRenderTrackerGuard(analysis, statement);
-		if (!guard) continue;
-		for (const branchStatement of guard.statements) {
-			const callExpression = getDirectCallExpression(branchStatement);
-			if (!callExpression || !isNodeOfType(callExpression, "CallExpression")) continue;
-			const setterReference = findDirectStateSetterReference(analysis, callExpression);
-			if (!setterReference || (callExpression.arguments ?? []).length !== 1 || !isExclusiveDestinationSetterReference(setterReference, callExpression)) continue;
-			const stateDeclarator = getUseStateDecl(analysis, setterReference);
-			if (!stateDeclarator || !isGenuineReactHookDeclarator(analysis, stateDeclarator, "useState") || guard.tracker.kind === "state" && stateDeclarator === guard.tracker.declarator) continue;
-			const writtenValue = callExpression.arguments?.[0];
-			const initializer = getStateInitializer(stateDeclarator);
-			if (!writtenValue || !initializer || isFunctionLike$1(writtenValue) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, writtenValue, componentFunction, currentFilename), guard.source) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, initializer, componentFunction, currentFilename), guard.source)) continue;
-			facts.push({
-				callExpression,
-				stateDeclarator
-			});
-		}
-	}
-	return facts;
-};
-//#endregion
-//#region src/plugin/rules/state-and-effects/no-derived-state.ts
-const getStateName$1 = (stateDeclarator) => {
-	if (!isNodeOfType(stateDeclarator, "VariableDeclarator")) return "<state>";
-	if (!isNodeOfType(stateDeclarator.id, "ArrayPattern")) return "<state>";
-	const stateBinding = stateDeclarator.id.elements?.[0];
-	if (stateBinding && isNodeOfType(stateBinding, "Identifier")) return stateBinding.name;
-	const setterBinding = stateDeclarator.id.elements?.[1];
-	if (!setterBinding || !isNodeOfType(setterBinding, "Identifier")) return "<state>";
-	if (!setterBinding.name.startsWith("set") || setterBinding.name.length <= 3) return setterBinding.name;
-	return setterBinding.name[3].toLowerCase() + setterBinding.name.slice(4);
-};
-const noDerivedState = defineRule({
-	id: "no-derived-state",
-	title: "Derived value copied into state",
-	severity: "warn",
-	tags: ["test-noise"],
-	recommendation: "Work out the value while rendering (or with useMemo if it's expensive) instead of copying it into state and synchronizing it during render or through an effect. See https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state",
-	create: (context) => {
-		const reportStateWrite = (callExpression, stateDeclarator) => {
-			const stateName = getStateName$1(stateDeclarator);
-			context.report({
-				node: callExpression,
-				message: `Storing "${stateName}" in state when you can derive it from other values costs an extra render.`
-			});
-		};
-		return {
-			...createComponentPropStackTracker({ onComponentEnter: (componentBody) => {
-				if (!componentBody) return;
-				const analysis = getProgramAnalysis(componentBody);
-				if (!analysis) return;
-				for (const fact of collectRenderStateWriteFacts(analysis, componentBody, context.filename)) reportStateWrite(fact.callExpression, fact.stateDeclarator);
-			} }).visitors,
-			CallExpression(node) {
-				if (!isUseEffect(node)) return;
-				const analysis = getProgramAnalysis(node);
-				if (!analysis) return;
-				for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
-					if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
-					reportStateWrite(fact.callExpression, fact.stateDeclarator);
-				}
-			}
-		};
-	}
-});
-//#endregion
-//#region src/plugin/rules/state-and-effects/no-derived-state-effect.ts
-const noDerivedStateEffect = defineRule({
-	id: "no-derived-state-effect",
-	title: "Derived state stored in an effect",
-	severity: "warn",
-	tags: ["test-noise"],
-	recommendation: "Work out derived values while rendering: `const x = fn(dep)`. To reset a component's state when a prop changes, give it a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
-	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
-		context.report({
-			node,
-			message: "You pay an extra render for state you can derive from other values."
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/utils/is-initial-only-prop-name.ts
 const isInitialOnlyPropName = (propName) => {
 	if (propName === "initialValue" || propName === "defaultValue" || propName === "seedValue") return true;
@@ -28378,14 +27468,14 @@ const hasDocumentClassListMutation = (node) => {
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-effect-event-handler.ts
 const hasEventLikeNode = (node) => findTriggeredSideEffectCalleeName(node) !== null || hasDocumentClassListMutation(node);
-const unwrapChainExpression$2 = (node) => {
+const unwrapChainExpression$1 = (node) => {
 	if (!node) return null;
 	if (isNodeOfType(node, "ChainExpression")) return node.expression;
 	return node;
 };
 const collectGuardExpressions = (node, into) => {
 	if (!node) return;
-	const unwrappedNode = unwrapChainExpression$2(node);
+	const unwrappedNode = unwrapChainExpression$1(node);
 	if (!unwrappedNode) return;
 	const rootIdentifierName = getRootIdentifierName(unwrappedNode);
 	if (rootIdentifierName) {
@@ -28416,7 +27506,7 @@ const isReturnOnlyStatement = (node) => {
 };
 const hasEventLikeRemainingStatements = (statements) => statements.some((statement) => !isNodeOfType(statement, "ReturnStatement") && hasEventLikeNode(statement));
 const doesGuardMatchDependency = (guardExpression, dependencyExpression) => {
-	const unwrappedDependencyExpression = unwrapChainExpression$2(dependencyExpression);
+	const unwrappedDependencyExpression = unwrapChainExpression$1(dependencyExpression);
 	if (!unwrappedDependencyExpression) return false;
 	if (areExpressionsStructurallyEqual(guardExpression.expression, unwrappedDependencyExpression)) return true;
 	return isNodeOfType(unwrappedDependencyExpression, "Identifier") && unwrappedDependencyExpression.name === guardExpression.rootIdentifierName;
@@ -30475,405 +29565,6 @@ const noGrayOnColoredBackground = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/find-enclosing-jsx-opening-element.ts
-const findEnclosingJsxOpeningElement = (node) => {
-	let cursor = node.parent;
-	while (cursor) {
-		if (isNodeOfType(cursor, "JSXElement")) return cursor.openingElement;
-		if (isNodeOfType(cursor, "JSXFragment")) return null;
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/has-client-render-evidence.ts
-const hasClientRenderEvidence = (componentOrHookNode, fileHasUseClientDirective) => {
-	if (fileHasUseClientDirective) return true;
-	const displayName = componentOrHookDisplayNameForFunction(componentOrHookNode);
-	if (displayName && isReactHookName(displayName)) return true;
-	let callsHook = false;
-	walkAst((isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null) ?? componentOrHookNode, (child) => {
-		if (callsHook) return false;
-		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && isReactHookName(child.callee.name)) {
-			callsHook = true;
-			return false;
-		}
-	});
-	return callsHook;
-};
-//#endregion
-//#region src/plugin/utils/has-suppress-hydration-warning-attribute.ts
-const hasSuppressHydrationWarningAttribute = (openingElement) => {
-	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
-	for (const attr of openingElement.attributes ?? []) if (isNodeOfType(attr, "JSXAttribute") && isNodeOfType(attr.name, "JSXIdentifier") && attr.name.name === "suppressHydrationWarning") return true;
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/read-initial-state-boolean.ts
-const readLogicalResult = (operator, leftResult, rightResult) => {
-	if (operator === "&&") {
-		if (leftResult === false || rightResult === false) return false;
-		if (leftResult === true && rightResult === true) return true;
-		return null;
-	}
-	if (leftResult === true || rightResult === true) return true;
-	if (leftResult === false && rightResult === false) return false;
-	return null;
-};
-const readIdentifierInitialStateBoolean = (identifier, scopes, visitedBindings, allowLazyInitializer) => {
-	if (!isNodeOfType(identifier, "Identifier")) return null;
-	if (identifier.name === "undefined" && scopes.isGlobalReference(identifier)) return false;
-	const binding = findVariableInitializer(identifier, identifier.name);
-	if (!binding || visitedBindings.has(binding.bindingIdentifier)) return null;
-	visitedBindings.add(binding.bindingIdentifier);
-	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
-	if (!declarator?.init || scopes.symbolFor(identifier)?.declarationNode !== declarator) return null;
-	const initializer = stripParenExpression(declarator.init);
-	if (isNodeOfType(declarator.id, "ArrayPattern") && declarator.id.elements?.[0] === binding.bindingIdentifier && isReactApiCall(initializer, "useState", scopes, { allowGlobalReactNamespace: true }) && isNodeOfType(initializer, "CallExpression")) {
-		const initialState = initializer.arguments?.[0];
-		if (!initialState) return false;
-		if (initialState.type === "SpreadElement") return null;
-		return readInitialStateBooleanInternal(initialState, scopes, visitedBindings, true);
-	}
-	const declaration = declarator.parent;
-	if (!isNodeOfType(declarator.id, "Identifier") || declarator.id !== binding.bindingIdentifier || !isNodeOfType(declaration, "VariableDeclaration") || declaration.kind !== "const") return null;
-	return readInitialStateBooleanInternal(initializer, scopes, visitedBindings, allowLazyInitializer);
-};
-const readInitialStateBooleanInternal = (expression, scopes, visitedBindings, allowLazyInitializer) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Literal")) return Boolean(unwrappedExpression.value);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) return readIdentifierInitialStateBoolean(unwrappedExpression, scopes, visitedBindings, allowLazyInitializer);
-	if (allowLazyInitializer && (isNodeOfType(unwrappedExpression, "ArrowFunctionExpression") || isNodeOfType(unwrappedExpression, "FunctionExpression"))) {
-		if (unwrappedExpression.async || isNodeOfType(unwrappedExpression, "FunctionExpression") && unwrappedExpression.generator) return null;
-		if (!isNodeOfType(unwrappedExpression.body, "BlockStatement")) return readInitialStateBooleanInternal(unwrappedExpression.body, scopes, visitedBindings, false);
-		if (unwrappedExpression.body.body.length !== 1) return null;
-		const returnStatement = unwrappedExpression.body.body[0];
-		if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return null;
-		return readInitialStateBooleanInternal(returnStatement.argument, scopes, visitedBindings, false);
-	}
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readInitialStateBooleanInternal(unwrappedExpression.argument, scopes, visitedBindings, false);
-		return argumentResult === null ? null : !argumentResult;
-	}
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression") && (unwrappedExpression.operator === "&&" || unwrappedExpression.operator === "||")) return readLogicalResult(unwrappedExpression.operator, readInitialStateBooleanInternal(unwrappedExpression.left, scopes, new Set(visitedBindings), false), readInitialStateBooleanInternal(unwrappedExpression.right, scopes, new Set(visitedBindings), false));
-	return null;
-};
-const readInitialStateBoolean = (expression, scopes) => readInitialStateBooleanInternal(expression, scopes, /* @__PURE__ */ new Set(), false);
-//#endregion
-//#region src/plugin/utils/is-after-client-only-early-return.ts
-const isAfterClientOnlyEarlyReturn = (node, componentOrHookNode, scopes) => {
-	const body = isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null;
-	if (!isNodeOfType(body, "BlockStatement")) return false;
-	const ancestors = /* @__PURE__ */ new Set();
-	let currentNode = node;
-	while (currentNode) {
-		ancestors.add(currentNode);
-		currentNode = currentNode.parent ?? null;
-	}
-	for (const statement of body.body ?? []) {
-		if (ancestors.has(statement)) return false;
-		if (!isNodeOfType(statement, "IfStatement")) continue;
-		const initialConditionResult = readInitialStateBoolean(statement.test, scopes);
-		if (initialConditionResult === true && statementAlwaysExits(statement.consequent)) return true;
-		if (initialConditionResult === false && statement.alternate && statementAlwaysExits(statement.alternate)) return true;
-	}
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/is-gated-by-falsy-initial-state.ts
-const isGatedByFalsyInitialState = (node, scopes) => {
-	let cursor = node;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === cursor && (parent.operator === "&&" && readInitialStateBoolean(parent.left, scopes) === false || parent.operator === "||" && readInitialStateBoolean(parent.left, scopes) === true)) return true;
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === cursor && readInitialStateBoolean(parent.test, scopes) === false || parent.alternate === cursor && readInitialStateBoolean(parent.test, scopes) === true)) return true;
-		if (isNodeOfType(parent, "IfStatement") && (parent.consequent === cursor && readInitialStateBoolean(parent.test, scopes) === false || parent.alternate === cursor && readInitialStateBoolean(parent.test, scopes) === true)) return true;
-		cursor = parent;
-		parent = parent.parent ?? null;
-	}
-	return false;
-};
-//#endregion
-//#region src/plugin/rules/performance/no-hydration-branch-on-browser-global.ts
-const evaluateEquality = (operator, left, right) => {
-	if (operator === "===" || operator === "==") return left === right;
-	if (operator === "!==" || operator === "!=") return left !== right;
-	return null;
-};
-const readTypeofBrowserGlobal = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "UnaryExpression") || unwrappedExpression.operator !== "typeof") return null;
-	const argument = stripParenExpression(unwrappedExpression.argument);
-	if (isNodeOfType(argument, "Identifier")) return (argument.name === "window" || argument.name === "document") && context.scopes.isGlobalReference(argument) ? argument.name : null;
-	if (!isNodeOfType(argument, "MemberExpression") || argument.computed || !isNodeOfType(argument.object, "Identifier") || argument.object.name !== "globalThis" || !context.scopes.isGlobalReference(argument.object) || !isNodeOfType(argument.property, "Identifier") || argument.property.name !== "window" && argument.property.name !== "document") return null;
-	return argument.property.name;
-};
-const matchBrowserPredicate = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const innerMatch = matchBrowserPredicate(unwrappedExpression.argument, context);
-		return innerMatch ? {
-			browserGlobalName: innerMatch.browserGlobalName,
-			clientResult: !innerMatch.clientResult,
-			serverResult: !innerMatch.serverResult
-		} : null;
-	}
-	if (!isNodeOfType(unwrappedExpression, "BinaryExpression")) return null;
-	const leftGlobalName = readTypeofBrowserGlobal(unwrappedExpression.left, context);
-	const rightGlobalName = readTypeofBrowserGlobal(unwrappedExpression.right, context);
-	const leftString = isNodeOfType(unwrappedExpression.left, "Literal") ? unwrappedExpression.left.value : null;
-	const rightString = isNodeOfType(unwrappedExpression.right, "Literal") ? unwrappedExpression.right.value : null;
-	const browserGlobalName = leftGlobalName && typeof rightString === "string" ? leftGlobalName : rightGlobalName && typeof leftString === "string" ? rightGlobalName : null;
-	const comparedType = leftGlobalName && typeof rightString === "string" ? rightString : rightGlobalName && typeof leftString === "string" ? leftString : null;
-	if (!browserGlobalName || !comparedType) return null;
-	const clientResult = evaluateEquality(unwrappedExpression.operator, "object", comparedType);
-	const serverResult = evaluateEquality(unwrappedExpression.operator, "undefined", comparedType);
-	if (clientResult === null || serverResult === null || clientResult === serverResult) return null;
-	return {
-		browserGlobalName,
-		clientResult,
-		serverResult
-	};
-};
-const readLogicalConditionResult = (operator, leftResult, rightResult) => {
-	if (operator === "&&") {
-		if (leftResult === false || rightResult === false) return false;
-		if (leftResult === true && rightResult === true) return true;
-		return null;
-	}
-	if (leftResult === true || rightResult === true) return true;
-	if (leftResult === false && rightResult === false) return false;
-	return null;
-};
-const readHydrationConditionResult = (expression, context, runtime) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
-	if (predicateMatch) return predicateMatch[`${runtime}Result`];
-	const staticResult = readInitialStateBoolean(unwrappedExpression, context.scopes);
-	if (staticResult !== null) return staticResult;
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime);
-		return argumentResult === null ? null : !argumentResult;
-	}
-	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime), readHydrationConditionResult(unwrappedExpression.right, context, runtime));
-};
-const matchHydrationCondition = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
-	if (predicateMatch) return {
-		predicateMatch,
-		predicateNode: unwrappedExpression
-	};
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationCondition(unwrappedExpression.argument, context);
-	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	const leftMatch = matchHydrationCondition(unwrappedExpression.left, context);
-	const rightMatch = matchHydrationCondition(unwrappedExpression.right, context);
-	if (leftMatch && rightMatch) {
-		const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client");
-		const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server");
-		return clientResult !== null && serverResult !== null && clientResult !== serverResult ? leftMatch : null;
-	}
-	const nestedMatch = leftMatch ?? rightMatch;
-	if (!nestedMatch) return null;
-	const otherResult = readInitialStateBoolean(leftMatch ? unwrappedExpression.right : unwrappedExpression.left, context.scopes);
-	if (unwrappedExpression.operator === "&&" && otherResult === false || unwrappedExpression.operator === "||" && otherResult === true) return null;
-	return nestedMatch;
-};
-const areNodeArraysEquivalent = (leftNodes, rightNodes) => leftNodes.length === rightNodes.length && leftNodes.every((leftNode, index) => areRenderedBranchesEquivalent(leftNode, rightNodes[index]));
-const areRenderedBranchesEquivalent = (leftNode, rightNode) => {
-	if (!leftNode || !rightNode) return leftNode === rightNode;
-	const left = stripParenExpression(leftNode);
-	const right = stripParenExpression(rightNode);
-	if (areExpressionsStructurallyEqual(left, right)) return true;
-	if (left.type !== right.type) return false;
-	if (isNodeOfType(left, "JSXText") && isNodeOfType(right, "JSXText")) return left.value === right.value;
-	if (isNodeOfType(left, "JSXExpressionContainer") && isNodeOfType(right, "JSXExpressionContainer")) {
-		if (!isAstNode(left.expression) || !isAstNode(right.expression)) return left.expression.type === right.expression.type;
-		return areRenderedBranchesEquivalent(left.expression, right.expression);
-	}
-	if (isNodeOfType(left, "JSXElement") && isNodeOfType(right, "JSXElement")) {
-		if (flattenJsxName$1(left.openingElement.name) !== flattenJsxName$1(right.openingElement.name)) return false;
-		if (!areNodeArraysEquivalent(left.openingElement.attributes, right.openingElement.attributes)) return false;
-		return areNodeArraysEquivalent(left.children, right.children);
-	}
-	if (isNodeOfType(left, "JSXFragment") && isNodeOfType(right, "JSXFragment")) return areNodeArraysEquivalent(left.children, right.children);
-	if (isNodeOfType(left, "JSXAttribute") && isNodeOfType(right, "JSXAttribute")) {
-		if (flattenJsxName$1(left.name) !== flattenJsxName$1(right.name)) return false;
-		return areRenderedBranchesEquivalent(left.value, right.value);
-	}
-	if (isNodeOfType(left, "JSXSpreadAttribute") && isNodeOfType(right, "JSXSpreadAttribute")) return areRenderedBranchesEquivalent(left.argument, right.argument);
-	if (isNodeOfType(left, "TemplateLiteral") && isNodeOfType(right, "TemplateLiteral")) {
-		if (left.quasis.length !== right.quasis.length) return false;
-		if (!left.quasis.every((quasi, index) => quasi.value.cooked === right.quasis[index]?.value.cooked && quasi.value.raw === right.quasis[index]?.value.raw)) return false;
-		return areNodeArraysEquivalent(left.expressions, right.expressions);
-	}
-	return false;
-};
-const isRenderedValue = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (isNodeOfType(unwrappedNode, "Literal")) return unwrappedNode.value !== null && unwrappedNode.value !== true && unwrappedNode.value !== false && unwrappedNode.value !== "";
-	if (isNodeOfType(unwrappedNode, "TemplateLiteral")) return unwrappedNode.expressions.length > 0 || unwrappedNode.quasis[0]?.value.cooked !== "";
-	return isNodeOfType(unwrappedNode, "JSXElement") || isNodeOfType(unwrappedNode, "JSXFragment");
-};
-const findRenderedValueInAndBranch = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (isRenderedValue(unwrappedNode)) return unwrappedNode;
-	if (!isNodeOfType(unwrappedNode, "LogicalExpression") || unwrappedNode.operator !== "&&") return null;
-	return findRenderedValueInAndBranch(unwrappedNode.right);
-};
-const findEnclosingJsxAttribute = (node) => {
-	let currentNode = node.parent;
-	while (currentNode) {
-		if (isNodeOfType(currentNode, "JSXAttribute")) return currentNode;
-		if (isNodeOfType(currentNode, "JSXElement") || isNodeOfType(currentNode, "JSXFragment") || isFunctionLike$1(currentNode)) return null;
-		currentNode = currentNode.parent;
-	}
-	return null;
-};
-const isInRenderedOutput = (node, componentOrHookNode, scopes) => {
-	let currentNode = node;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "JSXExpressionContainer")) {
-			const attribute = findEnclosingJsxAttribute(parentNode);
-			return attribute ? !isEventHandlerAttribute(attribute) : true;
-		}
-		if (isNodeOfType(parentNode, "ReturnStatement")) {
-			if (findEnclosingFunction(parentNode) === componentOrHookNode) return true;
-		}
-		if (parentNode === componentOrHookNode) return isFunctionLike$1(componentOrHookNode) && !isNodeOfType(componentOrHookNode.body, "BlockStatement") && componentOrHookNode.body === currentNode;
-		if (isFunctionLike$1(parentNode) && !executesDuringRender(parentNode, scopes)) return false;
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const getReturnedValues = (statement) => {
-	if (!statement) return [];
-	if (isNodeOfType(statement, "ReturnStatement")) return statement.argument ? [statement.argument] : [];
-	if (isNodeOfType(statement, "IfStatement")) return [...getReturnedValues(statement.consequent), ...getReturnedValues(statement.alternate)];
-	if (!isNodeOfType(statement, "BlockStatement")) return [];
-	const returnedValues = [];
-	for (const childStatement of statement.body) {
-		returnedValues.push(...getReturnedValues(childStatement));
-		if (statementAlwaysExits(childStatement)) break;
-	}
-	return returnedValues;
-};
-const findFollowingReturnedValues = (ifStatement) => {
-	const parentNode = ifStatement.parent;
-	if (!isNodeOfType(parentNode, "BlockStatement")) return [];
-	const statementIndex = parentNode.body.findIndex((statement) => statement === ifStatement);
-	if (statementIndex < 0) return [];
-	const returnedValues = [];
-	for (const statement of parentNode.body.slice(statementIndex + 1)) {
-		returnedValues.push(...getReturnedValues(statement));
-		if (statementAlwaysExits(statement)) break;
-	}
-	return returnedValues;
-};
-const areConditionExpressionsEquivalent = (leftExpression, rightExpression) => {
-	const left = stripParenExpression(leftExpression);
-	const right = stripParenExpression(rightExpression);
-	if (areExpressionsStructurallyEqual(left, right)) return true;
-	if (left.type !== right.type) return false;
-	if (isNodeOfType(left, "UnaryExpression") && isNodeOfType(right, "UnaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.argument, right.argument);
-	if (isNodeOfType(left, "LogicalExpression") && isNodeOfType(right, "LogicalExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left) && areConditionExpressionsEquivalent(left.right, right.right);
-	if (isNodeOfType(left, "BinaryExpression") && isNodeOfType(right, "BinaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left) && areConditionExpressionsEquivalent(left.right, right.right);
-	return false;
-};
-const areReturnTreesEquivalent = (leftStatement, rightStatement) => {
-	if (!leftStatement || !rightStatement) return leftStatement === rightStatement;
-	if (isNodeOfType(leftStatement, "ReturnStatement") && isNodeOfType(rightStatement, "ReturnStatement")) return areRenderedBranchesEquivalent(leftStatement.argument, rightStatement.argument);
-	if (isNodeOfType(leftStatement, "IfStatement") && isNodeOfType(rightStatement, "IfStatement")) return areConditionExpressionsEquivalent(leftStatement.test, rightStatement.test) && areReturnTreesEquivalent(leftStatement.consequent, rightStatement.consequent) && areReturnTreesEquivalent(leftStatement.alternate, rightStatement.alternate);
-	if (!isNodeOfType(leftStatement, "BlockStatement") || !isNodeOfType(rightStatement, "BlockStatement")) return false;
-	const leftReturningStatements = leftStatement.body.filter((statement) => getReturnedValues(statement).length > 0);
-	const rightReturningStatements = rightStatement.body.filter((statement) => getReturnedValues(statement).length > 0);
-	return leftReturningStatements.length === rightReturningStatements.length && leftReturningStatements.every((statement, index) => areReturnTreesEquivalent(statement, rightReturningStatements[index]));
-};
-const isStructuralRenderedValue = (node) => {
-	if (!node) return false;
-	const unwrappedNode = stripParenExpression(node);
-	return isNodeOfType(unwrappedNode, "JSXElement") || isNodeOfType(unwrappedNode, "JSXFragment");
-};
-const branchRootsSuppressSameElement = (leftBranch, rightBranch) => {
-	if (!rightBranch) return false;
-	const left = stripParenExpression(leftBranch);
-	const right = stripParenExpression(rightBranch);
-	return isNodeOfType(left, "JSXElement") && isNodeOfType(right, "JSXElement") && flattenJsxName$1(left.openingElement.name) === flattenJsxName$1(right.openingElement.name) && hasSuppressHydrationWarningAttribute(left.openingElement) && hasSuppressHydrationWarningAttribute(right.openingElement);
-};
-const noHydrationBranchOnBrowserGlobal = defineRule({
-	id: "no-hydration-branch-on-browser-global",
-	title: "Server and client render different branches",
-	severity: "error",
-	category: "Correctness",
-	requires: ["ssr"],
-	recommendation: "Render the same initial output on the server and client, then switch after mount or use useSyncExternalStore with a stable server snapshot.",
-	create: (context) => {
-		if (isTestlikeFilename(context.filename)) return {};
-		if (classifyReactNativeFileTarget(context) === "react-native") return {};
-		let fileHasUseClientDirective = false;
-		let fileIsEmailTemplate = false;
-		const reportedNodes = /* @__PURE__ */ new Set();
-		const reportHydrationBranch = (conditionNode, leftBranch, rightBranch, requiresRenderedContext) => {
-			const conditionMatch = matchHydrationCondition(conditionNode, context);
-			if (!conditionMatch) return;
-			const { predicateMatch, predicateNode } = conditionMatch;
-			if (reportedNodes.has(predicateNode)) return;
-			if (rightBranch && areRenderedBranchesEquivalent(leftBranch, rightBranch)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(predicateNode, context.scopes);
-			if (!componentOrHookNode) return;
-			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (requiresRenderedContext && !isInRenderedOutput(predicateNode, componentOrHookNode, context.scopes)) return;
-			if (!isRenderedValue(leftBranch) && (!rightBranch || !isRenderedValue(rightBranch))) {
-				const attribute = findEnclosingJsxAttribute(predicateNode);
-				if (!attribute || isEventHandlerAttribute(attribute)) return;
-			}
-			if (fileIsEmailTemplate || isGatedByFalsyInitialState(predicateNode, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(predicateNode, componentOrHookNode, context.scopes)) return;
-			const openingElement = findEnclosingJsxOpeningElement(predicateNode);
-			if (hasSuppressHydrationWarningAttribute(openingElement) && !isStructuralRenderedValue(leftBranch) && !isStructuralRenderedValue(rightBranch)) return;
-			if (branchRootsSuppressSameElement(leftBranch, rightBranch)) return;
-			if (isGeneratedImageRenderContext(context, openingElement ?? leftBranch)) return;
-			reportedNodes.add(predicateNode);
-			context.report({
-				node: predicateNode,
-				message: `\`typeof ${predicateMatch.browserGlobalName}\` selects different rendered output on the server and during hydration. Render the same initial output, then switch after mount.`
-			});
-		};
-		return {
-			Program(node) {
-				fileHasUseClientDirective = hasDirective(node, "use client");
-				fileIsEmailTemplate = hasEmailTemplateImport(node);
-			},
-			ConditionalExpression(node) {
-				reportHydrationBranch(node.test, node.consequent, node.alternate, true);
-			},
-			LogicalExpression(node) {
-				if (node.operator !== "&&" && node.operator !== "||") return;
-				const renderedValue = node.operator === "&&" ? findRenderedValueInAndBranch(node.right) : isRenderedValue(node.right) ? node.right : null;
-				if (!renderedValue) return;
-				reportHydrationBranch(node, renderedValue, null, true);
-			},
-			IfStatement(node) {
-				if (node.alternate && areReturnTreesEquivalent(node.consequent, node.alternate)) return;
-				const consequentValues = getReturnedValues(node.consequent);
-				const alternateValues = node.alternate ? getReturnedValues(node.alternate) : findFollowingReturnedValues(node);
-				if (consequentValues.length === 0 || alternateValues.length === 0) return;
-				const componentOrHookNode = findRenderPhaseComponentOrHook(node.test, context.scopes);
-				if (!componentOrHookNode) return;
-				const enclosingFunction = findEnclosingFunction(node);
-				if (enclosingFunction !== componentOrHookNode && (!enclosingFunction || !isInRenderedOutput(enclosingFunction, componentOrHookNode, context.scopes))) return;
-				for (const consequentValue of consequentValues) for (const alternateValue of alternateValues) {
-					if (!isRenderedValue(consequentValue) && !isRenderedValue(alternateValue)) continue;
-					reportHydrationBranch(node.test, consequentValue, alternateValue, false);
-				}
-			}
-		};
-	}
-});
-//#endregion
 //#region src/plugin/rules/performance/no-img-lazy-with-high-fetchpriority.ts
 const MESSAGE$22 = "`<img loading=\"lazy\">` defers the request while `fetchPriority=\"high\"` asks the browser to rush it, so the two directives contradict each other. Drop one: keep `fetchPriority=\"high\"` (and eager loading) for an LCP image, or `loading=\"lazy\"` for a below-the-fold one.";
 const noImgLazyWithHighFetchpriority = defineRule({
@@ -30894,131 +29585,6 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-impure-state-updater.ts
-const TIMER_FUNCTION_NAMES = new Set([
-	"cancelAnimationFrame",
-	"clearInterval",
-	"clearTimeout",
-	"queueMicrotask",
-	"requestAnimationFrame",
-	"setInterval",
-	"setTimeout"
-]);
-const STORAGE_MUTATION_METHOD_NAMES = new Set([
-	"clear",
-	"removeItem",
-	"setItem"
-]);
-const STORAGE_RECEIVER_NAMES = new Set(["localStorage", "sessionStorage"]);
-const EXTERNAL_READ_METHOD_NAMES = new Set(["getBoundingClientRect", "getClientRects"]);
-const NOTIFICATION_RECEIVER_NAMES = new Set([
-	"message",
-	"notification",
-	"toast"
-]);
-const NOTIFICATION_METHOD_NAMES = new Set([
-	"error",
-	"info",
-	"loading",
-	"open",
-	"show",
-	"success",
-	"warning"
-]);
-const getMemberCall = (node) => {
-	if (!isNodeOfType(node, "CallExpression")) return null;
-	if (!isNodeOfType(node.callee, "MemberExpression") || node.callee.computed) return null;
-	if (!isNodeOfType(node.callee.property, "Identifier")) return null;
-	return {
-		methodName: node.callee.property.name,
-		receiver: stripParenExpression(node.callee.object)
-	};
-};
-const isNotificationReceiver = (receiver, scopes) => {
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (!NOTIFICATION_RECEIVER_NAMES.has(receiver.name)) return false;
-	const symbol = scopes.symbolFor(receiver);
-	if (symbol?.kind === "import") return true;
-	if (!isNodeOfType(symbol?.initializer, "CallExpression")) return false;
-	const callee = symbol.initializer.callee;
-	return isNodeOfType(callee, "Identifier") && /^use(?:Message|Notification|Toast)$/.test(callee.name);
-};
-const getKnownImpureCall = (callExpression, scopes) => {
-	if (isNodeOfType(callExpression.callee, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.name) && scopes.isGlobalReference(callExpression.callee)) return `${callExpression.callee.name}()`;
-	const memberCall = getMemberCall(callExpression);
-	if (!memberCall) return null;
-	const { methodName, receiver } = memberCall;
-	if (STORAGE_MUTATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && STORAGE_RECEIVER_NAMES.has(receiver.name) && scopes.isGlobalReference(receiver)) return `${receiver.name}.${methodName}()`;
-	if (EXTERNAL_READ_METHOD_NAMES.has(methodName)) return `.${methodName}()`;
-	if (NOTIFICATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && isNotificationReceiver(receiver, scopes)) return `${receiver.name}.${methodName}()`;
-	return null;
-};
-const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) => {
-	let rootIdentifier = null;
-	if (isNodeOfType(assignmentTarget, "Identifier")) rootIdentifier = assignmentTarget;
-	else if (isNodeOfType(assignmentTarget, "MemberExpression") && isNodeOfType(assignmentTarget.object, "Identifier")) rootIdentifier = assignmentTarget.object;
-	if (!rootIdentifier) return null;
-	const updaterScope = scopes.ownScopeFor(updater);
-	if (!updaterScope) return null;
-	const symbol = scopes.symbolFor(rootIdentifier);
-	if (!symbol) return `the external value "${rootIdentifier.name}"`;
-	if (symbol.kind === "parameter" && symbol.scope === updaterScope) return `the updater argument "${rootIdentifier.name}"`;
-	return isDescendantScope(symbol.scope, updaterScope) ? null : `the captured value "${rootIdentifier.name}"`;
-};
-const findImpureUpdaterOperation = (updater, scopes) => {
-	const analysis = getProgramAnalysis(updater);
-	let operation = null;
-	walkAst(updater, (child) => {
-		if (operation) return false;
-		if (child !== updater && isFunctionLike$1(child) && !executesDuringRender(child, scopes)) return false;
-		if (isNodeOfType(child, "CallExpression")) {
-			if (isNodeOfType(child.callee, "Identifier") && analysis) {
-				const calleeReference = getRef(analysis, child.callee);
-				if (calleeReference && isStateSetterCall(analysis, calleeReference)) {
-					operation = `the nested state update "${child.callee.name}()"`;
-					return false;
-				}
-			}
-			const impureCall = getKnownImpureCall(child, scopes);
-			if (impureCall) {
-				operation = impureCall;
-				return false;
-			}
-		}
-		if (isNodeOfType(child, "AssignmentExpression")) {
-			operation = getExternalAssignmentDescription(child.left, updater, scopes);
-			if (operation) return false;
-		}
-		if (isNodeOfType(child, "UpdateExpression")) {
-			operation = getExternalAssignmentDescription(child.argument, updater, scopes);
-			if (operation) return false;
-		}
-	});
-	return operation;
-};
-const noImpureStateUpdater = defineRule({
-	id: "no-impure-state-updater",
-	title: "State updater has side effects",
-	severity: "error",
-	recommendation: "Keep state updater callbacks pure and return only the next state. Move notifications, storage, timers, ref writes, and other external work into the event or effect that queues the update.",
-	create: (context) => ({ CallExpression(node) {
-		const updater = node.arguments?.[0];
-		if (!updater || !isFunctionLike$1(updater)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis || !isNodeOfType(node.callee, "Identifier")) return;
-		const calleeReference = getRef(analysis, node.callee);
-		if (!calleeReference || !isStateSetterCall(analysis, calleeReference)) return;
-		const stateDeclarator = getUseStateDecl(analysis, calleeReference);
-		if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression") || !isReactApiCall(stateDeclarator.init, "useState", context.scopes, { allowGlobalReactNamespace: true })) return;
-		const operation = findImpureUpdaterOperation(updater, context.scopes);
-		if (!operation) return;
-		context.report({
-			node: updater,
-			message: `This state updater performs ${operation}. React may run updater functions more than once, so side effects here can repeat or observe inconsistent external state.`
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/rules/correctness/no-indeterminate-attribute.ts
 const MESSAGE$21 = "The `indeterminate` HTML attribute does not set a checkbox's visual state. Assign the `HTMLInputElement.indeterminate` DOM property instead.";
 const REACT_USE_REF_OPTIONS = {
@@ -31185,7 +29751,7 @@ const noInitializeState = defineRule({
 		if (!dependencies || !isNodeOfType(dependencies, "ArrayExpression") || (dependencies.elements ?? []).length !== 0) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
 			if (!fact.isRenderKnownCopy || fact.matchesStateInitializer || fact.resetsSourceState) continue;
 			const stateName = getStateName(fact.stateDeclarator);
 			context.report({
@@ -31844,6 +30410,111 @@ const noLegacyContextApi = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/executes-during-render.ts
+const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
+	"map",
+	"filter",
+	"forEach",
+	"flatMap",
+	"reduce",
+	"reduceRight",
+	"some",
+	"every",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"sort",
+	"toSorted"
+]);
+const executesDuringRender = (functionNode) => {
+	const parent = functionNode.parent;
+	if (!isNodeOfType(parent, "CallExpression")) return false;
+	if (parent.callee === functionNode) return true;
+	if (isHookCall$2(parent, "useMemo") && parent.arguments?.[0] === functionNode) return true;
+	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.has(parent.callee.property.name) && parent.arguments?.[0] === functionNode;
+};
+//#endregion
+//#region src/plugin/utils/has-suppress-hydration-warning-attribute.ts
+const hasSuppressHydrationWarningAttribute = (openingElement) => {
+	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	for (const attr of openingElement.attributes ?? []) if (isNodeOfType(attr, "JSXAttribute") && isNodeOfType(attr.name, "JSXIdentifier") && attr.name.name === "suppressHydrationWarning") return true;
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/find-declarator-for-binding.ts
+const findDeclaratorForBinding = (bindingIdentifier) => {
+	let ancestor = bindingIdentifier.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "VariableDeclarator")) return ancestor;
+		if (isNodeOfType(ancestor, "FunctionDeclaration") || isNodeOfType(ancestor, "FunctionExpression") || isNodeOfType(ancestor, "ArrowFunctionExpression") || isNodeOfType(ancestor, "Program")) return null;
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/references-falsy-initial-state.ts
+const isFalsyLiteral = (node) => {
+	if (!node) return true;
+	if (isNodeOfType(node, "Literal")) return !node.value;
+	return isNodeOfType(node, "Identifier") && node.name === "undefined";
+};
+const isFalsyInitialStateBinding = (identifier) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const binding = findVariableInitializer(identifier, identifier.name);
+	if (!binding) return false;
+	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
+	if (!declarator?.init) return false;
+	const init = stripParenExpression(declarator.init);
+	if (!isHookCall$2(init, "useState") || !isNodeOfType(init, "CallExpression")) return false;
+	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
+	if (declarator.id.elements?.[0] !== binding.bindingIdentifier) return false;
+	return isFalsyLiteral(init.arguments?.[0]);
+};
+const referencesFalsyInitialState = (expression) => flattenLogicalAndChain(stripParenExpression(expression)).some((operand) => isFalsyInitialStateBinding(stripParenExpression(operand)));
+//#endregion
+//#region src/plugin/utils/is-gated-by-falsy-initial-state.ts
+const isGatedByFalsyInitialState = (node) => {
+	let cursor = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&" && parent.right === cursor && referencesFalsyInitialState(parent.left)) return true;
+		if (isNodeOfType(parent, "ConditionalExpression") && parent.consequent === cursor && referencesFalsyInitialState(parent.test)) return true;
+		if (isNodeOfType(parent, "IfStatement") && parent.consequent === cursor && referencesFalsyInitialState(parent.test)) return true;
+		cursor = parent;
+		parent = parent.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/references-client-only-flag.ts
+const CLIENT_ONLY_FLAG_NAME_PATTERN = /^(?:is|has|did)?_?(?:client|mounted|hydrated|browser)(?:_?(?:side|ready|only))?$/i;
+const referencesClientOnlyFlag = (expression) => {
+	const unwrapped = stripParenExpression(expression);
+	if (isNodeOfType(unwrapped, "Identifier")) return CLIENT_ONLY_FLAG_NAME_PATTERN.test(unwrapped.name);
+	if (isNodeOfType(unwrapped, "MemberExpression")) {
+		const property = unwrapped.property;
+		return isNodeOfType(property, "Identifier") && CLIENT_ONLY_FLAG_NAME_PATTERN.test(property.name);
+	}
+	if (isNodeOfType(unwrapped, "UnaryExpression") && unwrapped.operator === "!") return referencesClientOnlyFlag(unwrapped.argument);
+	if (isNodeOfType(unwrapped, "LogicalExpression")) return referencesClientOnlyFlag(unwrapped.left) || referencesClientOnlyFlag(unwrapped.right);
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/is-inside-client-only-guard.ts
+const isInsideClientOnlyGuard = (node) => {
+	let cursor = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&" && parent.right === cursor && referencesClientOnlyFlag(parent.left)) return true;
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === cursor || parent.alternate === cursor) && referencesClientOnlyFlag(parent.test)) return true;
+		if (isNodeOfType(parent, "IfStatement") && parent.consequent === cursor && referencesClientOnlyFlag(parent.test)) return true;
+		cursor = parent;
+		parent = parent.parent ?? null;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/performance/no-locale-format-in-render.ts
 const LOCALE_FORMAT_METHOD_NAMES = new Set([
 	"toLocaleString",
@@ -31973,12 +30644,75 @@ const matchDateDefaultStringification = (node) => {
 	}
 	return null;
 };
+const findRenderPhaseComponentOrHook = (node) => {
+	let functionNode = findEnclosingFunction(node);
+	while (functionNode) {
+		if (componentOrHookDisplayNameForFunction(functionNode)) return functionNode;
+		if (!executesDuringRender(functionNode)) return null;
+		functionNode = findEnclosingFunction(functionNode);
+	}
+	return null;
+};
+const hasClientRenderEvidence = (componentOrHookNode, fileHasUseClientDirective) => {
+	if (fileHasUseClientDirective) return true;
+	const displayName = componentOrHookDisplayNameForFunction(componentOrHookNode);
+	if (displayName && isReactHookName(displayName)) return true;
+	let callsHook = false;
+	walkAst((isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null) ?? componentOrHookNode, (child) => {
+		if (callsHook) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && isReactHookName(child.callee.name)) {
+			callsHook = true;
+			return false;
+		}
+	});
+	return callsHook;
+};
+const isAfterClientOnlyEarlyReturn = (node, componentOrHookNode) => {
+	const body = isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null;
+	if (!isNodeOfType(body, "BlockStatement")) return false;
+	const ancestors = /* @__PURE__ */ new Set();
+	let cursor = node;
+	while (cursor) {
+		ancestors.add(cursor);
+		cursor = cursor.parent ?? null;
+	}
+	for (const statement of body.body ?? []) {
+		if (ancestors.has(statement)) return false;
+		if (!isNodeOfType(statement, "IfStatement")) continue;
+		if (!referencesClientOnlyFlag(statement.test) && !referencesFalsyInitialState(statement.test)) continue;
+		let returnsEarly = false;
+		walkAst(statement.consequent, (child) => {
+			if (isFunctionLike$1(child)) return false;
+			if (isNodeOfType(child, "ReturnStatement")) {
+				returnsEarly = true;
+				return false;
+			}
+		});
+		if (returnsEarly) return true;
+	}
+	return false;
+};
+const findEnclosingJsxOpeningElement = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isNodeOfType(cursor, "JSXElement")) return cursor.openingElement;
+		if (isNodeOfType(cursor, "JSXFragment")) return null;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
 const noLocaleFormatInRender = defineRule({
 	id: "no-locale-format-in-render",
 	title: "Locale/timezone formatting during render",
 	severity: "warn",
 	category: "Correctness",
-	requires: ["ssr"],
+	disabledWhen: [
+		"vite",
+		"cra",
+		"expo",
+		"react-native",
+		"unknown"
+	],
 	recommendation: "Format locale/timezone-dependent values in a post-mount useEffect + state, or pass an explicit locale and timeZone so the server and the browser render the same text. Only runs on SSR-capable projects.",
 	create: (context) => {
 		if (isTestlikeFilename(context.filename)) return {};
@@ -31988,12 +30722,13 @@ const noLocaleFormatInRender = defineRule({
 		const reportedNodes = /* @__PURE__ */ new Set();
 		const reportIfRenderPhase = (match) => {
 			if (reportedNodes.has(match.node)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(match.node, context.scopes);
+			const componentOrHookNode = findRenderPhaseComponentOrHook(match.node);
 			if (!componentOrHookNode) return;
 			if (fileIsEmailTemplate) return;
 			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (isGatedByFalsyInitialState(match.node, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(match.node, componentOrHookNode, context.scopes)) return;
+			if (isInsideClientOnlyGuard(match.node)) return;
+			if (isGatedByFalsyInitialState(match.node)) return;
+			if (isAfterClientOnlyEarlyReturn(match.node, componentOrHookNode)) return;
 			if (hasSuppressHydrationWarningAttribute(findEnclosingJsxOpeningElement(match.node))) return;
 			if (isGeneratedImageRenderContext(context, findEnclosingJsxOpeningElement(match.node)?.parent ?? match.node)) return;
 			reportedNodes.add(match.node);
@@ -32020,7 +30755,7 @@ const noLocaleFormatInRender = defineRule({
 				if (!isNodeOfType(expression, "CallExpression")) return;
 				if (!isNodeOfType(expression.callee, "Identifier")) return;
 				const helperName = expression.callee.name;
-				const componentOrHookNode = findRenderPhaseComponentOrHook(node, context.scopes);
+				const componentOrHookNode = findRenderPhaseComponentOrHook(node);
 				if (!componentOrHookNode) return;
 				const helperNode = findVariableInitializer(expression.callee, helperName)?.initializer;
 				if (!helperNode || !isFunctionLike$1(helperNode)) return;
@@ -32032,8 +30767,9 @@ const noLocaleFormatInRender = defineRule({
 					if (!match || reportedNodes.has(match.node)) return;
 					if (fileIsEmailTemplate) return;
 					if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-					if (isGatedByFalsyInitialState(node, context.scopes)) return;
-					if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode, context.scopes)) return;
+					if (isInsideClientOnlyGuard(node)) return;
+					if (isGatedByFalsyInitialState(node)) return;
+					if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode)) return;
 					if (hasSuppressHydrationWarningAttribute(findEnclosingJsxOpeningElement(node))) return;
 					reportedNodes.add(match.node);
 					context.report({
@@ -32135,6 +30871,9 @@ const noLongTransitionDuration = defineRule({
 const BOOLEAN_PROP_PREFIX_PATTERN = /^(?:is|has|should|can|show|hide|enable|disable|with)[A-Z]/;
 const isBooleanPrefixedPropName = (propName) => BOOLEAN_PROP_PREFIX_PATTERN.test(propName);
 //#endregion
+//#region src/plugin/utils/is-event-handler-attribute.ts
+const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
+//#endregion
 //#region src/plugin/rules/architecture/no-many-boolean-props.ts
 const IMPERATIVE_CALLBACK_PREFIX_PATTERN = /^(?:show|hide|enable|disable)[A-Z]/;
 const collectCallbackUsedNames = (componentBody, propsParam, scopes) => {
@@ -32266,7 +31005,7 @@ const noMatchMediaInStateInitializer = defineRule({
 	title: "matchMedia in state initializer",
 	severity: "warn",
 	category: "Correctness",
-	requires: ["ssr"],
+	disabledWhen: ["vite", "cra"],
 	recommendation: "Prefer CSS media queries for layout, or subscribe with `useSyncExternalStore` and provide a stable server snapshot.",
 	create: (context) => {
 		if (isTestlikeFilename(context.filename)) return {};
@@ -32817,41 +31556,6 @@ const noMutableInDeps = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-result-discarded-call.ts
-const isResultDiscardedCall = (callExpression) => {
-	let node = callExpression;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "ExpressionStatement")) return true;
-		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void") return true;
-		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
-		if (isNodeOfType(parent, "ChainExpression")) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "SequenceExpression")) {
-			const expressions = parent.expressions ?? [];
-			if (expressions[expressions.length - 1] !== node) return true;
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		return false;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/lodash-mutator-call.ts
 const LODASH_MUTATOR_NAMES = new Set([
 	"set",
@@ -34142,7 +32846,7 @@ const isUseRefIdentifier = (identifier) => {
 };
 const COMMAND_PROP_NAME_PATTERN = /^(fetch|load|refetch|dispatch|register|render)([A-Z_]|$)/;
 const SETTER_NAMED_PROP_PATTERN = /^set[A-Z]/;
-const unwrapChainExpression$1 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const unwrapChainExpression = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
 const FUNCTION_WRAPPER_HOOK_NAMES$1 = new Set([
 	"useCallback",
 	"useMemo",
@@ -34177,7 +32881,7 @@ const isDirectParentCallbackRef = (analysis, ref) => {
 	return Boolean(ref.resolved?.defs.some((def) => {
 		const node = def.node;
 		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-		const initializer = unwrapChainExpression$1(node.init);
+		const initializer = unwrapChainExpression(node.init);
 		const wrappedFunction = getWrapperHookWrappedFunction(initializer);
 		if (wrappedFunction) {
 			if (wrappedFunction.async) return false;
@@ -34187,170 +32891,10 @@ const isDirectParentCallbackRef = (analysis, ref) => {
 		return getDownstreamRefs(analysis, initializer).some((initializerRef) => getUpstreamRefs(analysis, initializerRef).some((upstreamRef) => isProp(analysis, upstreamRef)));
 	}));
 };
-const getDeclarationKind = (declarator) => {
-	const declaration = declarator.parent;
-	return declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : null;
-};
-const hasMutableBindingWrite = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
-const getDestructuredPropertyName = (bindingIdentifier) => {
-	const property = bindingIdentifier.parent;
-	if (!property || !isNodeOfType(property, "Property")) return null;
-	if (property.computed) return isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" ? String(property.key.value) : null;
-	return isNodeOfType(property.key, "Identifier") ? property.key.name : null;
-};
-const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @__PURE__ */ new Set()) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const callbackReference = getRef(analysis, unwrappedExpression);
-		const callbackVariable = callbackReference?.resolved;
-		if (!callbackReference || !callbackVariable || visitedVariables.has(callbackVariable)) return null;
-		if (isProp(analysis, callbackReference)) {
-			if (isWholePropsObjectReference(analysis, callbackReference)) return null;
-			const bindingIdentifier = callbackVariable.defs.find((definition) => definition.type === "Parameter")?.name;
-			return (bindingIdentifier && getDestructuredPropertyName(bindingIdentifier)) ?? unwrappedExpression.name;
-		}
-		if (hasMutableBindingWrite(callbackReference)) return null;
-		const definitions = callbackVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
-		if (definitions.length !== 1) return null;
-		const declarator = definitions[0];
-		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || getDeclarationKind(declarator) !== "const" || !declarator.init) return null;
-		visitedVariables.add(callbackVariable);
-		if (isNodeOfType(declarator.id, "ObjectPattern")) {
-			const bindingIdentifier = callbackVariable.defs[0]?.name;
-			const propertyName = bindingIdentifier ? getDestructuredPropertyName(bindingIdentifier) : null;
-			const propsReference = getDownstreamRefs(analysis, declarator.init).find((candidateReference) => isWholePropsObjectReference(analysis, candidateReference));
-			return propertyName && propsReference ? propertyName : null;
-		}
-		if (!isNodeOfType(declarator.id, "Identifier")) return null;
-		return getParentCallbackPropName(analysis, declarator.init, visitedVariables);
-	}
-	if (!isNodeOfType(unwrappedExpression, "MemberExpression")) return null;
-	const callbackName = getStaticMemberPropertyName(unwrappedExpression);
-	if (!callbackName) return null;
-	const receiver = stripParenExpression(unwrappedExpression.object);
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const receiverReference = getRef(analysis, receiver);
-	if (!receiverReference || !isWholePropsObjectReference(analysis, receiverReference)) return null;
-	return callbackName;
-};
-const isNullishRefInitializer = (initializer) => {
-	if (!initializer) return true;
-	const unwrappedInitializer = stripParenExpression(initializer);
-	if (isNodeOfType(unwrappedInitializer, "Literal")) return unwrappedInitializer.value === null;
-	if (!isNodeOfType(unwrappedInitializer, "Identifier")) return false;
-	return unwrappedInitializer.name === "undefined";
-};
-const getDirectComponentBodyStatement = (node, componentBody) => {
-	let current = node;
-	while (current?.parent && current.parent !== componentBody) current = current.parent;
-	return current?.parent === componentBody ? current : null;
-};
-const getVariableForDeclarator = (analysis, declarator) => {
-	for (const scope of analysis.scopeManager.scopes) {
-		const variable = scope.variables.find((candidateVariable) => candidateVariable.defs.some((definition) => definition.node === declarator));
-		if (variable) return variable;
-	}
-	return null;
-};
-const getRefMember = (identifier) => {
-	const receiver = findTransparentExpressionRoot(identifier);
-	const member = receiver.parent;
-	if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== receiver) return null;
-	return member;
-};
-const getRefMemberAssignment = (identifier) => {
-	const member = getRefMember(identifier);
-	if (!member) return null;
-	const memberRoot = findTransparentExpressionRoot(member);
-	const assignment = memberRoot.parent;
-	if (!assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.left !== memberRoot) return null;
-	return assignment;
-};
-const getRefAliasDeclarator = (identifier) => {
-	const initializer = findTransparentExpressionRoot(identifier);
-	const declarator = initializer.parent;
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== initializer || !isNodeOfType(declarator.id, "Identifier") || getDeclarationKind(declarator) !== "const") return null;
-	return declarator;
-};
-const getRefBindingProvenance = (analysis, receiver, isReactUseRefCall) => {
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const receiverReference = getRef(analysis, receiver);
-	if (!receiverReference?.resolved || hasMutableBindingWrite(receiverReference)) return null;
-	const variables = /* @__PURE__ */ new Set();
-	let currentVariable = receiverReference.resolved;
-	let refCall = null;
-	while (currentVariable && !variables.has(currentVariable)) {
-		variables.add(currentVariable);
-		const definitions = currentVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
-		if (definitions.length !== 1) return null;
-		const declarator = definitions[0];
-		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.id, "Identifier") || !declarator.init) return null;
-		if (isNodeOfType(declarator.init, "CallExpression") && isReactUseRefCall(declarator.init)) {
-			refCall = declarator.init;
-			break;
-		}
-		if (getDeclarationKind(declarator) !== "const" || !isNodeOfType(stripParenExpression(declarator.init), "Identifier")) return null;
-		const upstreamReference = getRef(analysis, stripParenExpression(declarator.init));
-		if (!upstreamReference?.resolved || hasMutableBindingWrite(upstreamReference)) return null;
-		currentVariable = upstreamReference.resolved;
-	}
-	if (!refCall) return null;
-	const pendingVariables = [...variables];
-	while (pendingVariables.length > 0) {
-		const variable = pendingVariables.pop();
-		if (!variable) continue;
-		for (const candidateReference of variable.references) {
-			const aliasDeclarator = getRefAliasDeclarator(candidateReference.identifier);
-			if (!aliasDeclarator) continue;
-			const aliasVariable = getVariableForDeclarator(analysis, aliasDeclarator);
-			if (!aliasVariable || variables.has(aliasVariable)) continue;
-			if (aliasVariable.references.some((aliasReference) => aliasReference.isWrite() && !aliasReference.init)) return null;
-			variables.add(aliasVariable);
-			pendingVariables.push(aliasVariable);
-		}
-	}
-	return {
-		refCall,
-		variables
-	};
-};
-const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactUseRefCall) => {
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || getStaticMemberPropertyName(callee) !== "current") return null;
-	const bindingProvenance = getRefBindingProvenance(analysis, stripParenExpression(callee.object), isReactUseRefCall);
-	if (!bindingProvenance) return null;
-	const { refCall, variables } = bindingProvenance;
-	const componentFunction = findEnclosingFunction(effectCall);
-	if (!componentFunction || !isFunctionLike$1(componentFunction) || !isComponentFunction$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
-	if (!getDirectComponentBodyStatement(effectCall, componentFunction.body)) return null;
-	const callbackPropNames = /* @__PURE__ */ new Set();
-	const initializer = refCall.arguments?.[0];
-	const initializerCallbackName = initializer ? getParentCallbackPropName(analysis, initializer) : null;
-	if (initializerCallbackName) callbackPropNames.add(initializerCallbackName);
-	else if (!isNullishRefInitializer(initializer)) return null;
-	for (const variable of variables) for (const candidateReference of variable.references) {
-		if (candidateReference.init) continue;
-		if (candidateReference.isWrite()) return null;
-		const identifier = candidateReference.identifier;
-		if (getRefAliasDeclarator(identifier)) continue;
-		const member = getRefMember(identifier);
-		if (!member || getStaticMemberPropertyName(member) !== "current") return null;
-		const memberParent = findTransparentExpressionRoot(member).parent;
-		if (memberParent && (isNodeOfType(memberParent, "UpdateExpression") || isNodeOfType(memberParent, "UnaryExpression") && memberParent.operator === "delete")) return null;
-		const assignment = getRefMemberAssignment(identifier);
-		if (!assignment) continue;
-		const assignmentStatement = findTransparentExpressionRoot(assignment).parent;
-		if (assignment.operator !== "=" || !assignmentStatement || !isNodeOfType(assignmentStatement, "ExpressionStatement") || assignmentStatement.parent !== componentFunction.body) return null;
-		const assignedCallbackName = getParentCallbackPropName(analysis, assignment.right);
-		if (!assignedCallbackName) return null;
-		callbackPropNames.add(assignedCallbackName);
-	}
-	return callbackPropNames.size > 0 ? { callbackPropNames } : null;
-};
 const isWrapperHookCallbackRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-	return getWrapperHookWrappedFunction(unwrapChainExpression$1(node.init)) !== null;
+	return getWrapperHookWrappedFunction(unwrapChainExpression(node.init)) !== null;
 }));
 const isHandlerBagArgument = (analysis, argument) => {
 	if (!isNodeOfType(argument, "ObjectExpression")) return false;
@@ -34372,7 +32916,7 @@ const HOOK_NAME_PATTERN$1 = /^use[A-Z0-9]/;
 const isParentWiredHookResultRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-	const init = unwrapChainExpression$1(node.init);
+	const init = unwrapChainExpression(node.init);
 	if (!isNodeOfType(init, "CallExpression")) return false;
 	const callee = init.callee;
 	if (!isNodeOfType(callee, "Identifier") || !HOOK_NAME_PATTERN$1.test(callee.name)) return false;
@@ -34402,79 +32946,71 @@ const noPassDataToParent = defineRule({
 	severity: "warn",
 	tags: ["test-noise"],
 	recommendation: "Fetch the data in the parent and pass it down as a prop (or return it from the hook), instead of handing it back up through a prop callback in a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#passing-data-to-the-parent",
-	create: (context) => {
-		const isReactUseRefCall = (node) => isReactApiCall(node, "useRef", context.scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true
-		});
-		return { CallExpression(node) {
-			if (!isUseEffect(node)) return;
-			const analysis = getProgramAnalysis(node);
-			if (!analysis) return;
-			if (hasCleanup(analysis, node)) return;
-			const effectFnRefs = getEffectFnRefs(analysis, node);
-			if (!effectFnRefs) return;
-			const effectFn = getEffectFn(analysis, node);
-			if (!effectFn) return;
-			for (const ref of effectFnRefs) {
-				const callExpr = getCallExpr(ref);
-				if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
-				const callbackRefProvenance = getCallbackRefProvenance(analysis, node, callExpr, isReactUseRefCall);
-				if (isRefCall(analysis, ref) && !callbackRefProvenance) continue;
-				if (!isSynchronous(ref.identifier, effectFn)) continue;
-				const calleeNode = unwrapChainExpression$1(callExpr.callee);
-				const identifier = ref.identifier;
-				if (callbackRefProvenance) {
-					if ([...callbackRefProvenance.callbackPropNames].some((callbackPropName) => COMMAND_PROP_NAME_PATTERN.test(callbackPropName))) continue;
-				} else if (calleeNode === identifier) {
-					if (!isDirectParentCallbackRef(analysis, ref)) continue;
-					if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
-				} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
-					if (!isWholePropsObjectReference(analysis, ref)) continue;
-					if (isCustomHookParameter(ref)) continue;
-				} else continue;
-				const methodName = getCallMethodName(calleeNode);
-				const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
-				if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
-				if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
-				if (!callbackRefProvenance && isNamespacedApiCallee(calleeNode)) continue;
-				const isSetterNamedCallee = callbackRefProvenance ? [...callbackRefProvenance.callbackPropNames].every((callbackPropName) => SETTER_NAMED_PROP_PATTERN.test(callbackPropName)) : Boolean((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) && SETTER_NAMED_PROP_PATTERN.test((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) ?? ""));
-				const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
-				const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
-					if (isFunctionLike$1(argument)) {
-						if (!isSetterNamedCallee) return [];
-						return getFunctionalUpdaterDataRefs(analysis, argument);
-					}
-					if (isHandlerBagArgument(analysis, argument)) return [];
-					if (isParentWiredHookResultArgument(analysis, argument)) return [];
-					if (isNodeOfType(argument, "Identifier")) {
-						const argumentRef = getRef(analysis, argument);
-						if (argumentRef && resolveToFunction(argumentRef)) return [];
-					}
-					return getDownstreamRefs(analysis, argument);
-				}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
-				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
-				if (!argsUpstreamRefs.some((argRef) => {
-					if (isUseStateIdentifier(argRef.identifier)) return false;
-					if (isProp(analysis, argRef)) return false;
-					if (isUseRefIdentifier(argRef.identifier)) return false;
-					if (isRefCurrent(argRef)) return false;
-					if (isConstant(argRef)) return false;
-					if (isParentWiredHookResultRef(analysis, argRef)) return false;
-					if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
-					if (resolvesToFunctionBinding(argRef)) return false;
-					const argIdentifier = argRef.identifier;
-					if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
-					if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
-					return true;
-				})) continue;
-				context.report({
-					node: callExpr,
-					message: "Handing data back to a parent from a useEffect costs your users an extra render."
-				});
-			}
-		} };
-	}
+	create: (context) => ({ CallExpression(node) {
+		if (!isUseEffect(node)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		if (hasCleanup(analysis, node)) return;
+		const effectFnRefs = getEffectFnRefs(analysis, node);
+		if (!effectFnRefs) return;
+		const effectFn = getEffectFn(analysis, node);
+		if (!effectFn) return;
+		for (const ref of effectFnRefs) {
+			const callExpr = getCallExpr(ref);
+			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
+			if (isRefCall(analysis, ref)) continue;
+			if (!isSynchronous(ref.identifier, effectFn)) continue;
+			const calleeNode = unwrapChainExpression(callExpr.callee);
+			const identifier = ref.identifier;
+			if (calleeNode === identifier) {
+				if (!isDirectParentCallbackRef(analysis, ref)) continue;
+				if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
+			} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
+				if (!isWholePropsObjectReference(analysis, ref)) continue;
+				if (isCustomHookParameter(ref)) continue;
+			} else continue;
+			const methodName = getCallMethodName(calleeNode);
+			const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
+			if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
+			if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
+			if (isNamespacedApiCallee(calleeNode)) continue;
+			const calleeName = isNodeOfType(identifier, "Identifier") ? identifier.name : methodName;
+			const isSetterNamedCallee = Boolean(calleeName && SETTER_NAMED_PROP_PATTERN.test(calleeName));
+			const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
+			const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
+				if (isFunctionLike$1(argument)) {
+					if (!isSetterNamedCallee) return [];
+					return getFunctionalUpdaterDataRefs(analysis, argument);
+				}
+				if (isHandlerBagArgument(analysis, argument)) return [];
+				if (isParentWiredHookResultArgument(analysis, argument)) return [];
+				if (isNodeOfType(argument, "Identifier")) {
+					const argumentRef = getRef(analysis, argument);
+					if (argumentRef && resolveToFunction(argumentRef)) return [];
+				}
+				return getDownstreamRefs(analysis, argument);
+			}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
+			if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
+			if (!argsUpstreamRefs.some((argRef) => {
+				if (isUseStateIdentifier(argRef.identifier)) return false;
+				if (isProp(analysis, argRef)) return false;
+				if (isUseRefIdentifier(argRef.identifier)) return false;
+				if (isRefCurrent(argRef)) return false;
+				if (isConstant(argRef)) return false;
+				if (isParentWiredHookResultRef(analysis, argRef)) return false;
+				if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
+				if (resolvesToFunctionBinding(argRef)) return false;
+				const argIdentifier = argRef.identifier;
+				if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
+				if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
+				return true;
+			})) continue;
+			context.report({
+				node: callExpr,
+				message: "Handing data back to a parent from a useEffect costs your users an extra render."
+			});
+		}
+	} })
 });
 //#endregion
 //#region src/plugin/utils/is-call-result-consumed-as-argument.ts
@@ -35028,66 +33564,6 @@ const noPropCallbackInEffect = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-prop-callback-in-render.ts
-const isPreservedThroughConciseArrow = (callExpression, scopes) => {
-	let node = callExpression;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "ChainExpression")) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "SequenceExpression")) {
-			const expressions = parent.expressions ?? [];
-			if (expressions[expressions.length - 1] !== node) return false;
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (!isNodeOfType(parent, "ArrowFunctionExpression") || parent.body !== node) return !isResultDiscardedCall(node);
-		const invocation = parent.parent;
-		if (!isNodeOfType(invocation, "CallExpression") || !executesDuringRender(parent, scopes)) return true;
-		if (invocation.arguments?.[0] === parent || invocation.arguments?.[1] === parent) {
-			const callee = stripParenExpression(invocation.callee);
-			return !(isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "forEach" && invocation.arguments[0] === parent);
-		}
-		node = invocation;
-		parent = node.parent;
-	}
-	return false;
-};
-const noPropCallbackInRender = defineRule({
-	id: "no-prop-callback-in-render",
-	title: "Prop callback invoked during render",
-	severity: "error",
-	recommendation: "Invoke the callback from the event or asynchronous operation that produced the value, or from an effect when synchronizing with an external system. Render must stay pure because React can replay or discard it.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isResultDiscardedCall(node)) return;
-		if (isPreservedThroughConciseArrow(node, context.scopes)) return;
-		if (!findRenderPhaseComponentOrHook(node, context.scopes)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		const callee = stripParenExpression(node.callee);
-		if (isFunctionLike$1(callee)) return;
-		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference))) return;
-		context.report({
-			node,
-			message: "This prop callback runs during render. React can replay or discard render work, so the callback can fire more than once or for UI that never commits."
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/rules/architecture/no-prop-types.ts
 const PROP_TYPES_PROPERTY = "propTypes";
 const isPropTypesKey = (key, computed) => {
@@ -35782,63 +34258,6 @@ const noRedundantShouldComponentUpdate = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
-const resolveReactRefSymbol = (memberExpression, scopes) => {
-	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
-	if (!isNodeOfType(memberExpression, "MemberExpression") || memberExpression.computed || !isNodeOfType(memberExpression.property, "Identifier") || memberExpression.property.name !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
-	const symbol = resolveConstIdentifierAlias(receiver, scopes);
-	if (!symbol?.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
-};
-const isSameRefCurrentMember = (node, refSymbol, scopes) => {
-	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return false;
-	const receiver = stripParenExpression(node.object);
-	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
-};
-const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
-	if (assignmentExpression.operator !== "=" || !isNodeOfType(assignmentExpression.right, "NewExpression")) return false;
-	let descendant = assignmentExpression;
-	let ancestor = descendant.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant && isNodeOfType(ancestor.test, "BinaryExpression") && (ancestor.test.operator === "===" || ancestor.test.operator === "==")) {
-			const { left, right } = ancestor.test;
-			if (isSameRefCurrentMember(left, refSymbol, scopes) && isNodeOfType(right, "Literal") && right.value === null || isSameRefCurrentMember(right, refSymbol, scopes) && isNodeOfType(left, "Literal") && left.value === null) return true;
-		}
-		descendant = ancestor;
-		ancestor = descendant.parent;
-	}
-	return false;
-};
-const noRefCurrentInRender = defineRule({
-	id: "no-ref-current-in-render",
-	title: "Ref mutated during render",
-	severity: "error",
-	recommendation: "Move ref writes into an event handler or effect. Render must stay pure because React can replay or discard it. The predictable null-guarded lazy initialization pattern remains supported.",
-	create: (context) => {
-		const report = (memberExpression) => {
-			if (!resolveReactRefSymbol(memberExpression, context.scopes)) return;
-			if (!findRenderPhaseComponentOrHook(memberExpression, context.scopes)) return;
-			context.report({
-				node: memberExpression,
-				message: "This ref is mutated during render. React can replay or discard render work, so the mutation can leak from UI that never commits."
-			});
-		};
-		return {
-			AssignmentExpression(node) {
-				const refSymbol = resolveReactRefSymbol(node.left, context.scopes);
-				if (!refSymbol) return;
-				if (isDocumentedLazyInitialization(node, refSymbol, context.scopes)) return;
-				report(node.left);
-			},
-			UpdateExpression(node) {
-				report(node.argument);
-			}
-		};
-	}
-});
-//#endregion
 //#region src/plugin/rules/architecture/no-render-in-render.ts
 const isInsideComponentContext = (node) => {
 	let cursor = node.parent;
@@ -37853,140 +36272,6 @@ const noUnescapedEntities = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/rules/performance/no-unguarded-browser-global-in-render-or-hook-init.ts
-const BROWSER_GLOBAL_NAMES = new Set([
-	"window",
-	"document",
-	"localStorage",
-	"sessionStorage",
-	"navigator",
-	"matchMedia"
-]);
-const getTypeofBrowserGlobalName = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "UnaryExpression") || unwrappedExpression.operator !== "typeof") return null;
-	const argument = stripParenExpression(unwrappedExpression.argument);
-	if (isNodeOfType(argument, "Identifier")) return BROWSER_GLOBAL_NAMES.has(argument.name) && context.scopes.isGlobalReference(argument) ? argument.name : null;
-	if (!isNodeOfType(argument, "MemberExpression") || argument.computed || !isNodeOfType(argument.object, "Identifier") || argument.object.name !== "globalThis" || !context.scopes.isGlobalReference(argument.object) || !isNodeOfType(argument.property, "Identifier") || !BROWSER_GLOBAL_NAMES.has(argument.property.name)) return null;
-	return argument.property.name;
-};
-const browserGuardCoversGlobal = (guardName, browserGlobalName) => guardName === browserGlobalName || guardName === "window" || guardName === "document";
-const mergeAvailability = (leftAvailability, rightAvailability) => {
-	if (leftAvailability === null) return rightAvailability;
-	if (rightAvailability === null) return leftAvailability;
-	return leftAvailability === rightAvailability ? leftAvailability : null;
-};
-const readAvailabilityWhenPredicate = (expression, browserGlobalName, context, predicateResult) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return readAvailabilityWhenPredicate(unwrappedExpression.argument, browserGlobalName, context, !predicateResult);
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		if (unwrappedExpression.operator === "&&" && predicateResult) return mergeAvailability(readAvailabilityWhenPredicate(unwrappedExpression.left, browserGlobalName, context, true), readAvailabilityWhenPredicate(unwrappedExpression.right, browserGlobalName, context, true));
-		if (unwrappedExpression.operator === "||" && !predicateResult) return mergeAvailability(readAvailabilityWhenPredicate(unwrappedExpression.left, browserGlobalName, context, false), readAvailabilityWhenPredicate(unwrappedExpression.right, browserGlobalName, context, false));
-		return null;
-	}
-	if (!isNodeOfType(unwrappedExpression, "BinaryExpression")) return null;
-	const leftTypeofName = getTypeofBrowserGlobalName(unwrappedExpression.left, context);
-	const rightTypeofName = getTypeofBrowserGlobalName(unwrappedExpression.right, context);
-	const leftComparedType = isNodeOfType(unwrappedExpression.left, "Literal") && typeof unwrappedExpression.left.value === "string" ? unwrappedExpression.left.value : null;
-	const rightComparedType = isNodeOfType(unwrappedExpression.right, "Literal") && typeof unwrappedExpression.right.value === "string" ? unwrappedExpression.right.value : null;
-	const guardName = leftTypeofName && rightComparedType ? leftTypeofName : rightTypeofName && leftComparedType ? rightTypeofName : null;
-	const comparedType = leftTypeofName && rightComparedType ? rightComparedType : rightTypeofName && leftComparedType ? leftComparedType : null;
-	if (!guardName || !browserGuardCoversGlobal(guardName, browserGlobalName)) return null;
-	if (!comparedType) return null;
-	const isEquality = unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==";
-	const isInequality = unwrappedExpression.operator === "!==" || unwrappedExpression.operator === "!=";
-	if (!isEquality && !isInequality) return null;
-	const browserType = guardName === "matchMedia" ? "function" : "object";
-	const browserResult = isEquality ? browserType === comparedType : browserType !== comparedType;
-	if (browserResult === (isEquality ? comparedType === "undefined" : comparedType !== "undefined")) return null;
-	return predicateResult === browserResult;
-};
-const isInsideAvailabilityGuard = (node, browserGlobalName, context) => {
-	let currentNode = node;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isFunctionLike$1(parentNode) && !executesDuringRender(parentNode, context.scopes)) break;
-		if (isNodeOfType(parentNode, "LogicalExpression") && (parentNode.operator === "&&" || parentNode.operator === "||") && parentNode.right === currentNode && readAvailabilityWhenPredicate(parentNode.left, browserGlobalName, context, parentNode.operator === "&&") === true) return true;
-		if (isNodeOfType(parentNode, "ConditionalExpression")) {
-			if (parentNode.consequent === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, true) === true || parentNode.alternate === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, false) === true) return true;
-		}
-		if (isNodeOfType(parentNode, "IfStatement")) {
-			if (parentNode.consequent === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, true) === true || parentNode.alternate === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, false) === true) return true;
-		}
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const isAfterAvailabilityEarlyExit = (node, componentOrHookNode, browserGlobalName, context) => {
-	const enclosingFunction = findEnclosingFunction(node);
-	if (!enclosingFunction || enclosingFunction !== componentOrHookNode && !executesDuringRender(enclosingFunction, context.scopes) || !isFunctionLike$1(enclosingFunction) || !isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
-	let currentNode = node;
-	while (currentNode !== enclosingFunction) {
-		const parentNode = currentNode.parent;
-		if (!parentNode) return false;
-		if (isNodeOfType(parentNode, "BlockStatement")) for (const statement of parentNode.body) {
-			if (statement === currentNode) break;
-			if (!isNodeOfType(statement, "IfStatement")) continue;
-			if (readAvailabilityWhenPredicate(statement.test, browserGlobalName, context, false) === true && statementAlwaysExits(statement.consequent)) return true;
-			if (readAvailabilityWhenPredicate(statement.test, browserGlobalName, context, true) === true && statement.alternate && statementAlwaysExits(statement.alternate)) return true;
-		}
-		currentNode = parentNode;
-	}
-	return false;
-};
-const isTypeofProbe = (node) => {
-	const expressionRoot = findTransparentExpressionRoot(node);
-	const parentNode = expressionRoot.parent;
-	return isNodeOfType(parentNode, "UnaryExpression") && parentNode.operator === "typeof" && parentNode.argument === expressionRoot;
-};
-const noUnguardedBrowserGlobalInRenderOrHookInit = defineRule({
-	id: "no-unguarded-browser-global-in-render-or-hook-init",
-	title: "Browser global read during server render",
-	severity: "error",
-	category: "Correctness",
-	requires: ["ssr"],
-	recommendation: "Move browser-only reads into an effect or event, guard them behind a client-only render path, or use useSyncExternalStore with a stable server snapshot.",
-	create: (context) => {
-		if (isTestlikeFilename(context.filename)) return {};
-		if (classifyReactNativeFileTarget(context) === "react-native") return {};
-		let fileIsEmailTemplate = false;
-		const reportedNodes = /* @__PURE__ */ new Set();
-		const reportBrowserRead = (node, browserGlobalName) => {
-			if (reportedNodes.has(node) || isTypeofProbe(node)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(node, context.scopes);
-			if (!componentOrHookNode) return;
-			if (fileIsEmailTemplate) return;
-			if (isGeneratedImageRenderContext(context, findEnclosingJsxOpeningElement(node) ?? node)) return;
-			if (isGatedByFalsyInitialState(node, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode, context.scopes)) return;
-			if (isInsideAvailabilityGuard(node, browserGlobalName, context)) return;
-			if (isAfterAvailabilityEarlyExit(node, componentOrHookNode, browserGlobalName, context)) return;
-			reportedNodes.add(node);
-			context.report({
-				node,
-				message: `\`${browserGlobalName}\` is read while React is rendering on the server, where browser globals are unavailable. Move the read into an effect or event, or provide a stable server snapshot.`
-			});
-		};
-		return {
-			Program(node) {
-				fileIsEmailTemplate = hasEmailTemplateImport(node);
-			},
-			Identifier(node) {
-				if (!BROWSER_GLOBAL_NAMES.has(node.name)) return;
-				if (!context.scopes.isGlobalReference(node)) return;
-				reportBrowserRead(node, node.name);
-			},
-			MemberExpression(node) {
-				if (node.computed) return;
-				const objectNode = stripParenExpression(node.object);
-				if (!isNodeOfType(objectNode, "Identifier") || objectNode.name !== "globalThis" || !context.scopes.isGlobalReference(objectNode) || !isNodeOfType(node.property, "Identifier") || !BROWSER_GLOBAL_NAMES.has(node.property.name)) return;
-				reportBrowserRead(node, node.property.name);
-			}
-		};
-	}
-});
-//#endregion
 //#region src/plugin/constants/dom-aria-properties.ts
 const ARIA_PROPERTY_NAMES = new Set([
 	"activedescendant",
@@ -41829,123 +40114,6 @@ const preferUseEffectEvent = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/is-cleanup-return.ts
-const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
-	"each",
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"flatMap",
-	"forEach",
-	"map",
-	"reduce",
-	"reduceRight",
-	"some",
-	"sort",
-	"toSorted"
-]);
-const STATIC_ITERATOR_CALLBACK_METHOD_NAMES = new Set([
-	"from",
-	"fromAsync",
-	"groupBy"
-]);
-const unwrapChainExpression = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
-const isNullLiteral = (node) => isNodeOfType(node, "Literal") && node.value === null;
-const isListenerRemovalViaNullHandler = (callNode) => {
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	const callee = unwrapChainExpression(callNode.callee);
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "on" && isNullLiteral(callNode.arguments?.[1]);
-};
-const REFERENCE_BASED_REMOVAL_METHOD_NAMES = new Set([
-	"off",
-	"removeEventListener",
-	"removeListener"
-]);
-const isNoOpInlineHandlerRemoval = (callNode, methodName) => {
-	if (!REFERENCE_BASED_REMOVAL_METHOD_NAMES.has(methodName)) return false;
-	const handlerArgument = callNode.arguments?.[1];
-	return isNodeOfType(handlerArgument, "ArrowFunctionExpression") || isNodeOfType(handlerArgument, "FunctionExpression");
-};
-const isReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	const callNode = unwrapChainExpression(node);
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	if (isListenerRemovalViaNullHandler(callNode)) return true;
-	const callee = unwrapChainExpression(callNode.callee);
-	if (isNodeOfType(callee, "Identifier")) {
-		if (TIMER_CLEANUP_CALLEE_NAMES.has(callee.name)) return true;
-		if (CLEANUP_LIKE_RELEASE_CALLEE_NAMES.has(callee.name)) return true;
-		if (knownCleanupFunctionNames.has(callee.name)) return true;
-		return false;
-	}
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-		if (isNoOpInlineHandlerRemoval(callNode, callee.property.name)) return false;
-		if (BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier") && knownBoundSubscriptionNames.has(callee.object.name)) return true;
-		return GLOBAL_RELEASE_METHOD_NAMES.has(callee.property.name);
-	}
-	return false;
-};
-const isStaticIteratorCallbackCallee = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && (callee.object.name === "Array" || callee.object.name === "Map" || callee.object.name === "Object") && STATIC_ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
-const isIteratorCallbackArgument = (node) => {
-	const parentNode = node.parent;
-	if (!isNodeOfType(parentNode, "CallExpression")) return false;
-	if (!parentNode.arguments?.some((argument) => argument === node)) return false;
-	const callee = unwrapChainExpression(parentNode.callee);
-	if (parentNode.arguments[1] === node && isStaticIteratorCallbackCallee(callee)) return true;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
-};
-const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	let didFindRelease = false;
-	walkAst(node, (child) => {
-		if (didFindRelease) return false;
-		if (child !== node && isFunctionLike$1(child) && !isIteratorCallbackArgument(child)) return false;
-		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
-			didFindRelease = true;
-			return false;
-		}
-	});
-	return didFindRelease;
-};
-const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	if (!isFunctionLike$1(node)) return false;
-	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
-};
-const isProvablyNoOpCleanupFunction = (node) => {
-	if (!isFunctionLike$1(node)) return false;
-	let sawNoOpRemoval = false;
-	let sawOtherCall = false;
-	walkAst(node.body, (child) => {
-		if (sawOtherCall) return false;
-		if (isFunctionLike$1(child)) return false;
-		const callNode = unwrapChainExpression(child);
-		if (!isNodeOfType(callNode, "CallExpression")) return;
-		const callee = unwrapChainExpression(callNode.callee);
-		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && isNoOpInlineHandlerRemoval(callNode, callee.property.name)) {
-			sawNoOpRemoval = true;
-			return;
-		}
-		sawOtherCall = true;
-	});
-	return sawNoOpRemoval && !sawOtherCall;
-};
-const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames, options = {}) => {
-	if (!returnedValue) return false;
-	const unwrappedValue = unwrapChainExpression(returnedValue);
-	if (isNodeOfType(unwrappedValue, "Literal") && unwrappedValue.value === null) return false;
-	if (isNodeOfType(unwrappedValue, "Identifier")) {
-		if (unwrappedValue.name === "undefined") return false;
-		if (knownCleanupFunctionNames.has(unwrappedValue.name)) return true;
-		return options.allowOpaqueReturn === true && !knownBoundSubscriptionNames.has(unwrappedValue.name);
-	}
-	if (isCleanupReturningSubscribeLikeCallExpression(unwrappedValue)) return true;
-	if (isProvablyNoOpCleanupFunction(unwrappedValue)) return false;
-	if (options.allowOpaqueReturn === true && !isSubscribeLikeCallExpression(unwrappedValue)) return true;
-	if (isCleanupFunctionLike(unwrappedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames)) return true;
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/prefer-use-sync-external-store.ts
 const findUseEffectsInComponent = (componentBody) => {
 	const effectCalls = [];
@@ -43414,7 +41582,7 @@ const renderingHydrationMismatchTime = defineRule({
 	title: "Time or random value in JSX",
 	severity: "warn",
 	category: "Correctness",
-	requires: ["ssr"],
+	disabledWhen: ["vite", "cra"],
 	recommendation: "Move time or random values into useEffect+useState so they only run in the browser, or add suppressHydrationWarning to the parent if it's intentional",
 	create: (context) => {
 		const isTestlikeFile = isTestlikeFilename(context.filename);
@@ -43428,7 +41596,8 @@ const renderingHydrationMismatchTime = defineRule({
 			const matched = NONDETERMINISTIC_RENDER_PATTERNS.find((pattern) => pattern.matches(node.expression));
 			if (matched) {
 				if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
-				if (isGatedByFalsyInitialState(node, context.scopes)) return;
+				if (isInsideClientOnlyGuard(node)) return;
+				if (isGatedByFalsyInitialState(node)) return;
 				if (isInsideMotionTransitionAttribute(node)) return;
 				context.report({
 					node,
@@ -43437,10 +41606,11 @@ const renderingHydrationMismatchTime = defineRule({
 				return;
 			}
 			walkAst(node.expression, (child) => {
-				if (isFunctionLike$1(child) && !executesDuringRender(child, context.scopes)) return false;
+				if (isFunctionLike$1(child) && !executesDuringRender(child)) return false;
 				for (const pattern of NONDETERMINISTIC_RENDER_PATTERNS) if (pattern.matches(child)) {
 					if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
-					if (isGatedByFalsyInitialState(child, context.scopes)) return;
+					if (isInsideClientOnlyGuard(child)) return;
+					if (isGatedByFalsyInitialState(child)) return;
 					if (isInsideMotionTransitionAttribute(child)) return;
 					if (pattern.display === "new Date()" && isYearOnlyDateRead(child)) return;
 					context.report({
@@ -56777,18 +54947,6 @@ const reactDoctorRules = [
 			category: "Accessibility"
 		}
 	},
-	{
-		key: "react-doctor/no-hydration-branch-on-browser-global",
-		id: "no-hydration-branch-on-browser-global",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noHydrationBranchOnBrowserGlobal,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noHydrationBranchOnBrowserGlobal.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-img-lazy-with-high-fetchpriority",
 		id: "no-img-lazy-with-high-fetchpriority",
@@ -56801,18 +54959,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noImgLazyWithHighFetchpriority.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-impure-state-updater",
-		id: "no-impure-state-updater",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noImpureStateUpdater,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noImpureStateUpdater.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-indeterminate-attribute",
 		id: "no-indeterminate-attribute",
@@ -57229,18 +55375,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noPropCallbackInEffect.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-prop-callback-in-render",
-		id: "no-prop-callback-in-render",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noPropCallbackInRender,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noPropCallbackInRender.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-prop-types",
 		id: "no-prop-types",
@@ -57332,18 +55466,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noRedundantShouldComponentUpdate.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-ref-current-in-render",
-		id: "no-ref-current-in-render",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noRefCurrentInRender,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noRefCurrentInRender.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-render-in-render",
 		id: "no-render-in-render",
@@ -57588,18 +55710,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noUnescapedEntities.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-unguarded-browser-global-in-render-or-hook-init",
-		id: "no-unguarded-browser-global-in-render-or-hook-init",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noUnguardedBrowserGlobalInRenderOrHookInit,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noUnguardedBrowserGlobalInRenderOrHookInit.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-unknown-property",
 		id: "no-unknown-property",
@@ -59932,17 +58042,10 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"nextjs-no-use-search-params-without-suspense",
 	"no-dynamic-import-path",
 	"no-full-lodash-import",
-	"no-hydration-branch-on-browser-global",
 	"no-indeterminate-attribute",
 	"no-locale-format-in-render",
 	"no-match-media-in-state-initializer",
-	"no-adjust-state-on-prop-change",
-	"no-derived-state",
-	"no-derived-state-effect",
-	"no-event-handler",
-	"no-initialize-state",
 	"no-mutating-reducer-state",
-	"no-unguarded-browser-global-in-render-or-hook-init",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
 	"rn-no-legacy-shadow-styles",
@@ -59994,9 +58097,6 @@ const collectNextjsSearchParamsDependencies = ({ absoluteFilePath, staticImports
 	if (hasAncestorSuspenseLayout(absoluteFilePath)) return;
 	for (const entry of flattenImportEntries(staticImports)) resolveCrossFileFunctionExport(absoluteFilePath, entry.source, entry.exportedName);
 };
-const collectEffectValueHelperDependencies = ({ absoluteFilePath, staticImports }) => {
-	for (const entry of flattenImportEntries(staticImports)) resolveCrossFileFunctionExport(absoluteFilePath, entry.source, entry.exportedName);
-};
 const collectMutatingReducerDependencies = ({ absoluteFilePath, sourceText, staticImports, program }) => {
 	const namedUseReducerLocals = /* @__PURE__ */ new Set();
 	const reactObjectLocals = /* @__PURE__ */ new Set();
@@ -60079,17 +58179,10 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["nextjs-no-use-search-params-without-suspense", collectNextjsSearchParamsDependencies],
 	["no-dynamic-import-path", collectNearestManifestDependencies],
 	["no-full-lodash-import", collectNearestManifestDependencies],
-	["no-hydration-branch-on-browser-global", collectNearestManifestDependencies],
 	["no-indeterminate-attribute", collectNearestManifestDependencies],
 	["no-locale-format-in-render", collectNearestManifestDependencies],
 	["no-match-media-in-state-initializer", collectNearestManifestDependencies],
-	["no-adjust-state-on-prop-change", collectEffectValueHelperDependencies],
-	["no-derived-state", collectEffectValueHelperDependencies],
-	["no-derived-state-effect", collectEffectValueHelperDependencies],
-	["no-event-handler", collectEffectValueHelperDependencies],
-	["no-initialize-state", collectEffectValueHelperDependencies],
 	["no-mutating-reducer-state", collectMutatingReducerDependencies],
-	["no-unguarded-browser-global-in-render-or-hook-init", collectNearestManifestDependencies],
 	["prefer-dynamic-import", collectNearestManifestDependencies],
 	["rendering-hydration-mismatch-time", collectNearestManifestDependencies],
 	["rn-no-legacy-shadow-styles", collectLegacyArchDependencies],