oxlint-plugin-react-doctor 0.7.4-dev.70b5d99 → 0.7.4-dev.7bbb792

package/dist/index.js

@@ -1915,7 +1915,10 @@ const isGeneratedImageRenderContext = (context, node) => {
 	if (!node) return false;
 	const programRoot = findProgramRoot(node);
 	if (!programRoot) return false;
-	return collectGeneratedImageJsxNodes(programRoot).has(node);
+	const generatedImageJsxNodes = collectGeneratedImageJsxNodes(programRoot);
+	if (generatedImageJsxNodes.has(node)) return true;
+	if (isNodeOfType(node, "JSXElement")) return generatedImageJsxNodes.has(node.openingElement);
+	return false;
 };
 //#endregion
 //#region src/plugin/utils/object-has-accessible-child.ts
@@ -8403,6 +8406,54 @@ 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;
@@ -8458,46 +8509,90 @@ 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-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;
-};
+//#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/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
@@ -8532,125 +8627,9 @@ 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",
@@ -8661,7 +8640,66 @@ 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 findSubscribeLikeUsages = (callback) => {
+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 usages = [];
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	let cleanupArgument = null;
@@ -8670,13 +8708,22 @@ const findSubscribeLikeUsages = (callback) => {
 		const lastCallbackStatement = callbackStatements[callbackStatements.length - 1];
 		if (isNodeOfType(lastCallbackStatement, "ReturnStatement") && lastCallbackStatement.argument) cleanupArgument = lastCallbackStatement.argument;
 	}
+	const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
 	walkAst(callback, (child) => {
-		if (child === cleanupArgument && !isSubscribeLikeCallExpression(child)) return false;
+		if (child !== callback && isFunctionLike$1(child)) {
+			if (child === cleanupArgument) return false;
+			if (!effectInvokedFunctions.has(child) && !isSynchronousIteratorCallback(child)) return false;
+		}
 		if (isSocketConstruction(child)) {
 			usages.push({
 				kind: "socket",
 				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
+				handleKey: findAssignedResourceKey(child, context),
+				receiverKey: null,
+				registrationVerbName: null,
+				eventKey: null,
+				handlerKey: null
 			});
 			return;
 		}
@@ -8685,118 +8732,348 @@ const findSubscribeLikeUsages = (callback) => {
 			usages.push({
 				kind: "timer",
 				node: child,
-				resourceName: child.callee.name
+				resourceName: child.callee.name,
+				handleKey: findAssignedResourceKey(child, context),
+				receiverKey: null,
+				registrationVerbName: child.callee.name,
+				eventKey: null,
+				handlerKey: null
 			});
 			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)) 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);
-			}
-		}
-	});
-	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);
+		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
+			});
 		}
 	});
-	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) => {
+	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) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
-	const releaseStarts = [];
+	const releaseCalls = [];
 	walkInsideStatementBlocks(callback.body, (child) => {
-		if (!isReleaseLikeCall(child, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return;
-		const releaseStart = getRangeStart(child);
-		if (releaseStart !== null) releaseStarts.push(releaseStart);
+		if (!isNodeOfType(isNodeOfType(child, "ChainExpression") ? child.expression : child, "CallExpression")) return;
+		releaseCalls.push(child);
 	});
-	if (releaseStarts.length === 0) return usages;
+	if (releaseCalls.length === 0) return usages;
 	return usages.filter((usage) => {
 		const usageStart = getRangeStart(usage.node);
 		if (usageStart === null) return true;
-		return !releaseStarts.some((releaseStart) => releaseStart > usageStart);
+		const matchingReleaseCalls = releaseCalls.filter((releaseCall) => {
+			const releaseStart = getRangeStart(releaseCall);
+			return releaseStart !== null && releaseStart > usageStart && doesReleaseCallMatchUsage(releaseCall, usage, context);
+		});
+		return !doMatchingNodesCoverEveryPathAfterUsage(usage.node, matchingReleaseCalls, context);
 	});
 };
-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;
+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;
+		}
 	});
+	return didCleanupFunctionMatch;
 };
-const effectHasCleanupReturn = (callback, usages) => {
+const effectHasCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	if (!isNodeOfType(callback.body, "BlockStatement")) return isCleanupReturningSubscribeLikeCallExpression(callback.body);
-	const cleanupBindings = collectCleanupBindings(callback);
-	let didFindCleanupReturn = 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 = [];
 	walkInsideStatementBlocks(callback.body, (child) => {
-		if (didFindCleanupReturn) return;
 		if (!isNodeOfType(child, "ReturnStatement")) return;
-		if (!cleanupReturnRunsAfterUsage(child, usages)) return;
-		if (isCleanupReturn(child.argument, cleanupBindings.cleanupFunctionNames, cleanupBindings.subscriptionNames, { allowOpaqueReturn: true })) didFindCleanupReturn = true;
+		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);
 	});
-	return didFindCleanupReturn;
+	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));
 };
-const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
-const isSelfReleasingListenerOptionProperty = (property) => {
+const isSelfReleasingListenerOptionProperty = (property, context) => {
 	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 true;
+	if (keyName === "signal") return !isLocalAbortControllerExpression(property.value, context);
 	if (keyName !== "once") return false;
 	return isNodeOfType(property.value, "Literal") && property.value.value === true;
 };
-const hasSelfReleasingListenerOptions = (node) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some(isSelfReleasingListenerOptionProperty));
+const hasSelfReleasingListenerOptions = (node, context) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some((property) => isSelfReleasingListenerOptionProperty(property, context)));
 const PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB = new Map([
 	["addEventListener", new Set(["removeEventListener", "abort"])],
 	["addListener", new Set([
@@ -8822,85 +9099,185 @@ 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 callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	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;
+	}
 	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 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 didFindPairedRelease;
+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 fileReleaseVerbNamesCache = /* @__PURE__ */ new WeakMap();
-const collectFileReleaseVerbNames = (anyNode) => {
-	let programNode = anyNode;
+const fileContainsReleaseForUsage = (usage, context) => {
+	let programNode = usage.node;
 	while (programNode.parent) programNode = programNode.parent;
-	const cached = fileReleaseVerbNamesCache.get(programNode);
-	if (cached) return cached;
-	const releaseVerbNames = /* @__PURE__ */ new Set();
+	let didFindRelease = false;
 	walkAst(programNode, (child) => {
-		const releaseVerbName = getReleaseVerbName(child);
-		if (releaseVerbName !== null) releaseVerbNames.add(releaseVerbName);
+		if (didFindRelease) return false;
+		if (doesReleaseCallMatchUsage(child, usage, context) && isReleaseReachableForUsage(child, usage, context)) {
+			didFindRelease = true;
+			return false;
+		}
 	});
-	fileReleaseVerbNamesCache.set(programNode, releaseVerbNames);
-	return releaseVerbNames;
+	return didFindRelease;
+};
+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 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;
+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;
+	}
 	return false;
 };
-const findRetainedFunctionLeak = (retainedFunction) => {
+const findRetainedFunctionLeak = (retainedFunction, context) => {
 	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 (child === conciseReturnValue && isNodeOfType(child, "CallExpression")) return;
-		if (isSocketConstruction(child) && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, SOCKET_RELEASE_VERB_NAMES)) {
-			leak = {
+		if (isSocketConstruction(child) && !doesResourceResultEscape(child, false)) {
+			const socketUsage = {
 				kind: "socket",
 				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
+				handleKey: findAssignedResourceKey(child, context),
+				receiverKey: null,
+				registrationVerbName: null,
+				eventKey: null,
+				handlerKey: null
 			};
-			return false;
+			if (!hasReleaseForUsage(socketUsage)) {
+				leak = socketUsage;
+				return false;
+			}
 		}
 		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, INTERVAL_RELEASE_VERB_NAMES)) {
-			leak = {
+		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
+			const timerUsage = {
 				kind: "timer",
 				node: child,
-				resourceName: "setInterval"
+				resourceName: "setInterval",
+				handleKey: findAssignedResourceKey(child, context),
+				receiverKey: null,
+				registrationVerbName: "setInterval",
+				eventKey: null,
+				handlerKey: null
 			};
-			return false;
+			if (!hasReleaseForUsage(timerUsage)) {
+				leak = timerUsage;
+				return false;
+			}
 		}
-		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 = {
+		if (isSubscribeOrObserveCall(child) && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
+			const registrationDetails = getCallRegistrationDetails(child, context);
+			const subscriptionUsage = {
 				kind: "subscribe",
 				node: child,
-				resourceName: registrationVerbName
+				resourceName: registrationDetails.registrationVerbName ?? "subscribe",
+				handleKey: findAssignedResourceKey(child, context),
+				...registrationDetails
 			};
+			if (!hasSelfReleasingListenerOptions(child, context) && !hasReleaseForUsage(subscriptionUsage)) leak = subscriptionUsage;
 			return false;
 		}
 	});
@@ -8912,6 +9289,26 @@ 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",
@@ -8920,7 +9317,8 @@ 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) => {
-			const leak = findRetainedFunctionLeak(retainedFunction);
+			if (!isPotentiallyReachableFunction(retainedFunction, context)) return;
+			const leak = findRetainedFunctionLeak(retainedFunction, context);
 			if (!leak) return;
 			const resourceNoun = RESOURCE_NOUN_BY_KIND[leak.kind];
 			context.report({
@@ -8932,30 +9330,31 @@ const effectNeedsCleanup = defineRule({
 			CallExpression(node) {
 				if (isHookCall$2(node, "useCallback")) {
 					const retainedCallback = getEffectCallback(node);
-					if (retainedCallback) reportRetainedLeak(retainedCallback);
+					if (retainedCallback && !isInlineRetainedHandlerFunction(retainedCallback, context)) reportRetainedLeak(retainedCallback);
 					return;
 				}
-				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
+				if (!isHookCall$2(node, CLEANUP_EFFECT_HOOK_NAMES)) return;
 				const callback = getEffectCallback(node);
 				if (!callback) return;
-				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback));
+				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback, context), context);
 				if (usages.length === 0) return;
-				if (effectHasCleanupReturn(callback, usages)) return;
-				const firstUsage = usages[0];
+				const firstUsage = findFirstUsageWithoutCleanup(callback, usages, context);
+				if (!firstUsage) return;
 				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
+				const hookName = getCalleeName$2(node) ?? "effect";
 				context.report({
 					node,
-					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in useEffect without returning cleanup. Return a cleanup function so it does not leak after unmount.`
+					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} 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)) reportRetainedLeak(node);
+				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
 			},
 			FunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
+				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
 			}
 		};
 	}
@@ -9569,13 +9968,18 @@ const unwrapExpression$3 = (node) => {
 	return current;
 };
 /**
-* Get the hook name from a call expression's callee, regardless of
-* whether the hook is called as `useFoo()` (Identifier) or
-* `React.useFoo()` (MemberExpression).
+* Get the hook name from a direct, wrapped, namespaced, or immutable
+* React import alias call.
 */
-const getHookName = (callee) => {
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+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;
 	return null;
 };
 const FUNCTION_SCOPE_KINDS = new Set([
@@ -9760,7 +10164,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) => {
+const symbolHasStableHookOrigin = (symbol, scopes) => {
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
 	let declarator = symbol.declarationNode;
 	while (declarator && declarator.type !== "VariableDeclarator") declarator = declarator.parent ?? null;
@@ -9773,7 +10177,7 @@ const symbolHasStableHookOrigin = (symbol) => {
 		if (isNodeOfType(initializer, "TemplateLiteral") && getStaticTemplateLiteralValue(initializer) !== null) return true;
 	}
 	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const initializerHookName = getHookName(initializer.callee);
+	const initializerHookName = getHookName(initializer.callee, scopes);
 	if (!initializerHookName) return false;
 	if (initializerHookName === "useRef") return true;
 	if (initializerHookName === "useEffectEvent") return true;
@@ -9808,7 +10212,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);
+	const initializerHookName = getHookName(initializer.callee, scopes);
 	if (!initializerHookName || !MEMOIZING_HOOK_NAMES.has(initializerHookName)) return false;
 	const depsArgument = initializer.arguments[1];
 	if (!depsArgument || !isAstNode(depsArgument)) return false;
@@ -9838,7 +10242,7 @@ const getObjectPropertyValue = (objectExpression, propertyName) => {
 	}
 	return null;
 };
-const isStableRefContainerCapture = (symbol, depKey) => {
+const isStableRefContainerCapture = (symbol, depKey, scopes) => {
 	if (symbol.kind !== "const") return false;
 	if (!depKey.startsWith(`${symbol.name}.`)) return false;
 	if (symbol.references.some((reference) => reference.flag !== "read")) return false;
@@ -9852,7 +10256,7 @@ const isStableRefContainerCapture = (symbol, depKey) => {
 		if (!propertyValue) return false;
 		currentValue = propertyValue;
 	}
-	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee) === "useRef";
+	return isNodeOfType(currentValue, "CallExpression") && getHookName(currentValue.callee, scopes) === "useRef";
 };
 const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	if (visitedSymbolIds.has(symbol.id)) return true;
@@ -9870,7 +10274,13 @@ const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 	}
 	return true;
 };
-const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
+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);
 //#endregion
 //#region src/plugin/utils/symbol-has-react-use-effect-event-origin.ts
 const symbolHasReactUseEffectEventOrigin = (symbol, scopes) => {
@@ -10058,10 +10468,18 @@ const collectCaptureDepKeys = (callback, scopes) => {
 		}
 		const depKey = computeDepKey(reference);
 		if (!depKey) continue;
-		if (isStableRefContainerCapture(symbol, depKey)) {
+		if (isStableRefContainerCapture(symbol, depKey, scopes)) {
 			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 {
@@ -10090,12 +10508,60 @@ 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) === "useCallback");
+	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && getHookName(initializer.callee, scopes) === "useCallback");
 };
-const isExtraEffectDepAllowed = (node, scopes) => {
+const isExtraReactiveDepAllowed = (node, scopes) => {
 	const rootIdentifier = getMemberRootIdentifier(node);
 	if (!rootIdentifier) return false;
 	const symbol = scopes.symbolFor(rootIdentifier);
@@ -10123,10 +10589,17 @@ 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) => {
-	if (!symbolHasStableHookOrigin(symbol)) return false;
+const isStableSetterLikeSymbol = (symbol, scopes) => {
+	if (!symbolHasStableHookOrigin(symbol, scopes)) return false;
 	return symbol.name.startsWith("set") || symbol.name.startsWith("dispatch") || symbol.name.startsWith("startTransition");
 };
 const findStableSetterReference = (node, scopes) => {
@@ -10136,7 +10609,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)) {
+			if (symbol && isStableSetterLikeSymbol(symbol, scopes)) {
 				setterName = symbol.name;
 				return;
 			}
@@ -10252,11 +10725,11 @@ const hasRefCurrentAssignmentInComponent = (refSymbol) => {
 	}
 	return false;
 };
-const isSeededDataRefSymbol = (refSymbol) => {
+const isSeededDataRefSymbol = (refSymbol, scopes) => {
 	if (!refSymbol) return false;
 	const initializer = refSymbol.initializer ? unwrapExpression$3(refSymbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	if (getHookName(initializer.callee) !== "useRef") return false;
+	if (getHookName(initializer.callee, scopes) !== "useRef") return false;
 	const firstArgument = initializer.arguments[0];
 	if (!firstArgument || !isAstNode(firstArgument)) return false;
 	const strippedArgument = unwrapExpression$3(firstArgument);
@@ -10296,7 +10769,9 @@ const isOuterFunctionScopeDep = (node, callback, scopes) => {
 	const componentOrHookScope = componentOrHookFunction ? scopes.ownScopeFor(componentOrHookFunction) : null;
 	return Boolean(componentOrHookScope && !isDescendantScope(symbol.scope, componentOrHookScope));
 };
-const hasMemberCallForRoot = (node, rootName) => {
+const hasMemberCallForRoot = (node, rootName, scopes) => {
+	const rootSymbol = closureCaptures(node, scopes).find((reference) => reference.resolvedSymbol?.name === rootName)?.resolvedSymbol ?? null;
+	if (!rootSymbol) return false;
 	let didFindMemberCall = false;
 	const visit = (current) => {
 		if (didFindMemberCall) return;
@@ -10312,7 +10787,7 @@ const hasMemberCallForRoot = (node, rootName) => {
 					}
 					chainObject = unwrapExpression$3(chainObject.object);
 				}
-				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName) {
+				if (!doesChainPassThroughCurrent && chainObject && isNodeOfType(chainObject, "Identifier") && chainObject.name === rootName && scopes.symbolFor(chainObject) === rootSymbol) {
 					didFindMemberCall = true;
 					return;
 				}
@@ -10330,9 +10805,11 @@ const hasMemberCallForRoot = (node, rootName) => {
 	visit(node);
 	return didFindMemberCall;
 };
-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 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 exhaustiveDeps = defineRule({
 	id: "exhaustive-deps",
@@ -10387,7 +10864,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);
+			const hookName = getHookName(node.callee, context.scopes);
 			if (!hookName || !isHookOfInterest(hookName, node.callee)) return;
 			const callbackArgumentIndex = getCallbackArgumentIndex(hookName);
 			const depsArgumentIndex = getDepsArgumentIndex(hookName);
@@ -10444,7 +10921,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.report({
+				if (refCurrentInCleanup && shouldCheckRefCleanup && !hasRefCurrentAssignment(callbackToAnalyze, refCurrentInCleanup.refCurrentName) && !hasRefCurrentAssignmentInComponent(refCurrentInCleanup.refSymbol) && !isSeededDataRefSymbol(refCurrentInCleanup.refSymbol, context.scopes)) context.report({
 					node: callbackToAnalyze,
 					message: buildRefCleanupMessage(refCurrentInCleanup.refCurrentName)
 				});
@@ -10543,7 +11020,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)) {
+					if (refSymbol && symbolHasStableHookOrigin(refSymbol, context.scopes)) {
 						if (!didReportRefCurrentDep) {
 							context.report({
 								node: elementNode,
@@ -10581,7 +11058,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);
+			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument, context.scopes);
 			const missingCaptureKeys = [];
 			for (const captureKey of captureKeys) {
 				let isCoveredByDeclared = false;
@@ -10667,7 +11144,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 (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName) && isExtraEffectDepAllowed(reportNode, context.scopes)) continue;
+				if (isExtraDepAllowedForHook(hookName, 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;
@@ -12339,20 +12816,6 @@ 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]/;
@@ -13497,7 +13960,7 @@ const jsHoistIntl = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/create-loop-aware-visitors.ts
-const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
+const ITERATOR_CALLBACK_METHOD_NAMES$1 = new Set([
 	"map",
 	"flatMap",
 	"forEach",
@@ -13516,7 +13979,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.has(parent.callee.property.name);
+	return isNodeOfType(parent.callee, "MemberExpression") && isNodeOfType(parent.callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES$1.has(parent.callee.property.name);
 };
 const createLoopAwareVisitors = (innerVisitors, options = {}) => {
 	let loopDepth = 0;
@@ -13745,7 +14208,7 @@ const findIndexedArrayObject = (callbackBody, indexParameterName) => {
 	});
 	return indexedArrayObject;
 };
-const unwrapChainExpression$2 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const unwrapChainExpression$3 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
 const LENGTH_EQUALITY_OPERATORS = new Set(["===", "=="]);
 const LENGTH_MISMATCH_OPERATORS = new Set([
 	"!==",
@@ -13757,17 +14220,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$2(candidate);
+	const binaryGuard = unwrapChainExpression$3(candidate);
 	if (!isNodeOfType(binaryGuard, "BinaryExpression")) return false;
 	if (!operators.has(binaryGuard.operator)) return false;
-	const leftSide = unwrapChainExpression$2(binaryGuard.left);
-	const rightSide = unwrapChainExpression$2(binaryGuard.right);
+	const leftSide = unwrapChainExpression$3(binaryGuard.left);
+	const rightSide = unwrapChainExpression$3(binaryGuard.right);
 	if (!isMemberProperty(leftSide, "length")) return false;
 	if (!isMemberProperty(rightSide, "length")) return false;
-	const leftLengthObject = unwrapChainExpression$2(leftSide.object);
-	const rightLengthObject = unwrapChainExpression$2(rightSide.object);
-	const normalizedReceiver = unwrapChainExpression$2(receiverArray);
-	const normalizedIndexed = unwrapChainExpression$2(indexedArray);
+	const leftLengthObject = unwrapChainExpression$3(leftSide.object);
+	const rightLengthObject = unwrapChainExpression$3(rightSide.object);
+	const normalizedReceiver = unwrapChainExpression$3(receiverArray);
+	const normalizedIndexed = unwrapChainExpression$3(indexedArray);
 	const matchesReceiverThenIndexed = areExpressionsStructurallyEqual(leftLengthObject, normalizedReceiver) && areExpressionsStructurallyEqual(rightLengthObject, normalizedIndexed);
 	const matchesIndexedThenReceiver = areExpressionsStructurallyEqual(leftLengthObject, normalizedIndexed) && areExpressionsStructurallyEqual(rightLengthObject, normalizedReceiver);
 	return matchesReceiverThenIndexed || matchesIndexedThenReceiver;
@@ -13854,18 +14317,18 @@ const LENGTH_PRESERVING_METHOD_NAMES = new Set([
 	"toReversed"
 ]);
 const peelLengthPreservingDerivation = (expression) => {
-	let current = unwrapChainExpression$2(expression);
+	let current = unwrapChainExpression$3(expression);
 	for (;;) {
 		if (isNodeOfType(current, "ArrayExpression") && current.elements?.length === 1 && isNodeOfType(current.elements[0], "SpreadElement")) {
-			current = unwrapChainExpression$2(current.elements[0].argument);
+			current = unwrapChainExpression$3(current.elements[0].argument);
 			continue;
 		}
 		if (isNodeOfType(current, "CallExpression")) {
-			const callee = unwrapChainExpression$2(current.callee);
+			const callee = unwrapChainExpression$3(current.callee);
 			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-				const calleeObject = unwrapChainExpression$2(callee.object);
+				const calleeObject = unwrapChainExpression$3(callee.object);
 				if (isNodeOfType(calleeObject, "Identifier") && calleeObject.name === "Array" && callee.property.name === "from" && current.arguments?.length === 1) {
-					current = unwrapChainExpression$2(current.arguments[0]);
+					current = unwrapChainExpression$3(current.arguments[0]);
 					continue;
 				}
 				if (LENGTH_PRESERVING_METHOD_NAMES.has(callee.property.name)) {
@@ -13910,7 +14373,7 @@ const resolveComparedArraySource = (expression, scopeNode) => {
 		const initializer = findConstInitializer(current.name, scopeNode);
 		if (!initializer) return current;
 		const peeledInitializer = peelLengthPreservingDerivation(initializer);
-		if (peeledInitializer === unwrapChainExpression$2(initializer)) return current;
+		if (peeledInitializer === unwrapChainExpression$3(initializer)) return current;
 		current = peeledInitializer;
 	}
 	return current;
@@ -19640,54 +20103,6 @@ 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;
@@ -20671,6 +21086,7 @@ 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);
@@ -20685,6 +21101,7 @@ 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;
@@ -20733,25 +21150,37 @@ const resolveImportedExportName = (importSpecifier) => {
 	if (isNodeOfType(importSpecifier, "ImportDefaultSpecifier")) return "default";
 	return null;
 };
-const findReExportSourcesForName = (programRoot, exportedName) => {
+const findReExportTargetsForName = (programRoot, exportedName) => {
 	if (!isNodeOfType(programRoot, "Program")) return [];
-	const exportAllSources = [];
+	const exportAllTargets = [];
 	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) return [sourceValue];
+				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(statement, "ExportAllDeclaration") && statement.source) {
+			if (statement.exportKind === "type" || statement.exported) continue;
 			const sourceValue = statement.source.value;
-			if (typeof sourceValue === "string") exportAllSources.push(sourceValue);
+			if (typeof sourceValue === "string") exportAllTargets.push({
+				importedName: exportedName,
+				source: sourceValue
+			});
 		}
 	}
-	return exportAllSources;
+	return exportAllTargets;
 };
 //#endregion
 //#region src/plugin/utils/attach-parent-references.ts
@@ -20840,139 +21269,6 @@ 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",
@@ -21089,35 +21385,6 @@ 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;
@@ -21296,25 +21563,29 @@ const resolveTsconfigAliasPath = (fromFilename, source) => {
 };
 //#endregion
 //#region src/plugin/utils/resolve-module-path.ts
-const resolveModulePath = (fromFilename, source) => resolveRelativeImportPath(fromFilename, source) ?? resolveTsconfigAliasPath(fromFilename, source);
+const resolveModulePath = (fromFilename, source) => {
+	if (path.isAbsolute(source)) return null;
+	return source.startsWith(".") ? 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 actualFilePath = resolveBarrelExportFilePath(filePath, exportedName) ?? filePath;
-	const programRoot = parseSourceFile(actualFilePath);
+	const programRoot = parseSourceFile(filePath);
 	if (!programRoot) return null;
 	const exported = findExportedFunctionBody(programRoot, exportedName);
 	if (exported) return exported;
-	for (const reExportSource of findReExportSourcesForName(programRoot, exportedName)) {
-		const nextFilePath = resolveModulePath(actualFilePath, reExportSource);
+	const resolvedCandidates = /* @__PURE__ */ new Set();
+	for (const target of findReExportTargetsForName(programRoot, exportedName)) {
+		const nextFilePath = resolveModulePath(filePath, target.source);
 		if (!nextFilePath) continue;
-		const resolved = resolveFunctionExportInFile(nextFilePath, exportedName, visitedFilePaths);
-		if (resolved) return resolved;
+		const resolved = resolveFunctionExportInFile(nextFilePath, target.importedName, new Set(visitedFilePaths));
+		if (resolved) resolvedCandidates.add(resolved);
 	}
-	return null;
+	if (resolvedCandidates.size !== 1) return null;
+	return resolvedCandidates.values().next().value ?? null;
 };
 const resolveCrossFileFunctionExport = (fromFilename, source, exportedName) => {
 	const resolvedFilePath = resolveModulePath(fromFilename, source);
@@ -22099,6 +22370,26 @@ 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")) {
@@ -22497,6 +22788,46 @@ 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",
@@ -22543,6 +22874,42 @@ 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);
@@ -22673,7 +23040,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) => {
+const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilename) => {
 	const effectFunction = getEffectFn(analysis, effectNode);
 	if (!effectFunction || !isFunctionLike$1(effectFunction) || effectFunction.async === true) return [];
 	const invokedFunctionEvidence = collectEffectInvokedFunctions(effectFunction);
@@ -22682,7 +23049,8 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode) => {
 		invocation: null,
 		isDeferred: false,
 		introducedBindings: /* @__PURE__ */ new Set(),
-		substitutions: /* @__PURE__ */ new Map()
+		substitutions: /* @__PURE__ */ new Map(),
+		currentFilename
 	};
 	const frames = [rootFrame];
 	walkAst(effectFunction, (child) => {
@@ -22703,7 +23071,8 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode) => {
 				invocation: child,
 				isDeferred,
 				introducedBindings,
-				substitutions: buildSubstitutions(analysis, callable, argumentsForCallable, rootFrame)
+				substitutions: buildSubstitutions(analysis, callable, argumentsForCallable, rootFrame),
+				currentFilename
 			});
 		};
 		if (isFunctionLike$1(callee)) {
@@ -22756,6 +23125,174 @@ 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"));
@@ -22841,38 +23378,55 @@ 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 (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;
+		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)));
+			}
 			return evidence;
 		}
 		if (remainingCallFrames <= 0) {
 			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		const callable = resolveWrappedCallable(analysis, callee);
-		if (!callable || callable.async === true || functionInvokesItself(analysis, callable)) {
-			evidence.hasUnknownSource = true;
+		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)));
 			return evidence;
 		}
-		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) {
+		const helperFunction = resolveValueHelperFunction(analysis, callee, frame.currentFilename);
+		const helperSummary = helperFunction ? summarizeHelperReturn(helperFunction) : null;
+		if (!helperSummary) {
 			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		for (const returnedExpression of returnedExpressions) mergeEvidence(evidence, collectValueEvidence(analysis, returnedExpression, valueFrame, remainingCallFrames - 1, new Set(visitedBindings)));
+		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)));
+		}
 		return evidence;
 	}
 	if (isFunctionLike$1(node) || isNodeOfType(node, "AwaitExpression")) {
@@ -22890,6 +23444,20 @@ 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);
@@ -22952,8 +23520,8 @@ const areInMutuallyExclusiveBranches = (leftNode, rightNode) => {
 	}
 	return false;
 };
-const collectEffectStateWriteFacts = (analysis, effectNode) => {
-	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode);
+const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) => {
+	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode, currentFilename);
 	if (frames.length === 0) return [];
 	const effectHasCleanup = hasCleanup(analysis, effectNode);
 	const cleanupManagedStateDeclarators = /* @__PURE__ */ new Set();
@@ -22973,7 +23541,8 @@ const collectEffectStateWriteFacts = (analysis, effectNode) => {
 				invocation: callExpression,
 				isDeferred: frame.isDeferred,
 				introducedBindings: collectIntroducedBindings(analysis, writtenValue),
-				substitutions: /* @__PURE__ */ new Map()
+				substitutions: /* @__PURE__ */ new Map(),
+				currentFilename
 			};
 			valueEvidence = emptyEvidence();
 			const returnedExpressions = getReturnedExpressions(writtenValue);
@@ -23022,7 +23591,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)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 			context.report({
 				node: fact.callExpression,
@@ -24283,6 +24852,139 @@ 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",
@@ -24485,6 +25187,35 @@ 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?$/;
@@ -24814,7 +25545,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$1 = new Set([
+const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
 	"forEach",
 	"map",
 	"filter",
@@ -24835,7 +25566,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$1.has(callee.property.name);
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.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);
@@ -25779,57 +26510,6 @@ 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;
@@ -25963,6 +26643,236 @@ 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;
@@ -27468,14 +28378,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$1 = (node) => {
+const unwrapChainExpression$2 = (node) => {
 	if (!node) return null;
 	if (isNodeOfType(node, "ChainExpression")) return node.expression;
 	return node;
 };
 const collectGuardExpressions = (node, into) => {
 	if (!node) return;
-	const unwrappedNode = unwrapChainExpression$1(node);
+	const unwrappedNode = unwrapChainExpression$2(node);
 	if (!unwrappedNode) return;
 	const rootIdentifierName = getRootIdentifierName(unwrappedNode);
 	if (rootIdentifierName) {
@@ -27506,7 +28416,7 @@ const isReturnOnlyStatement = (node) => {
 };
 const hasEventLikeRemainingStatements = (statements) => statements.some((statement) => !isNodeOfType(statement, "ReturnStatement") && hasEventLikeNode(statement));
 const doesGuardMatchDependency = (guardExpression, dependencyExpression) => {
-	const unwrappedDependencyExpression = unwrapChainExpression$1(dependencyExpression);
+	const unwrappedDependencyExpression = unwrapChainExpression$2(dependencyExpression);
 	if (!unwrappedDependencyExpression) return false;
 	if (areExpressionsStructurallyEqual(guardExpression.expression, unwrappedDependencyExpression)) return true;
 	return isNodeOfType(unwrappedDependencyExpression, "Identifier") && unwrappedDependencyExpression.name === guardExpression.rootIdentifierName;
@@ -29565,6 +30475,405 @@ 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({
@@ -29585,6 +30894,131 @@ 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 = {
@@ -29751,7 +31185,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)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.matchesStateInitializer || fact.resetsSourceState) continue;
 			const stateName = getStateName(fact.stateDeclarator);
 			context.report({
@@ -30410,111 +31844,6 @@ 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",
@@ -30644,75 +31973,12 @@ 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",
-	disabledWhen: [
-		"vite",
-		"cra",
-		"expo",
-		"react-native",
-		"unknown"
-	],
+	requires: ["ssr"],
 	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 {};
@@ -30722,13 +31988,12 @@ const noLocaleFormatInRender = defineRule({
 		const reportedNodes = /* @__PURE__ */ new Set();
 		const reportIfRenderPhase = (match) => {
 			if (reportedNodes.has(match.node)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(match.node);
+			const componentOrHookNode = findRenderPhaseComponentOrHook(match.node, context.scopes);
 			if (!componentOrHookNode) return;
 			if (fileIsEmailTemplate) return;
 			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (isInsideClientOnlyGuard(match.node)) return;
-			if (isGatedByFalsyInitialState(match.node)) return;
-			if (isAfterClientOnlyEarlyReturn(match.node, componentOrHookNode)) return;
+			if (isGatedByFalsyInitialState(match.node, context.scopes)) return;
+			if (isAfterClientOnlyEarlyReturn(match.node, componentOrHookNode, context.scopes)) return;
 			if (hasSuppressHydrationWarningAttribute(findEnclosingJsxOpeningElement(match.node))) return;
 			if (isGeneratedImageRenderContext(context, findEnclosingJsxOpeningElement(match.node)?.parent ?? match.node)) return;
 			reportedNodes.add(match.node);
@@ -30755,7 +32020,7 @@ const noLocaleFormatInRender = defineRule({
 				if (!isNodeOfType(expression, "CallExpression")) return;
 				if (!isNodeOfType(expression.callee, "Identifier")) return;
 				const helperName = expression.callee.name;
-				const componentOrHookNode = findRenderPhaseComponentOrHook(node);
+				const componentOrHookNode = findRenderPhaseComponentOrHook(node, context.scopes);
 				if (!componentOrHookNode) return;
 				const helperNode = findVariableInitializer(expression.callee, helperName)?.initializer;
 				if (!helperNode || !isFunctionLike$1(helperNode)) return;
@@ -30767,9 +32032,8 @@ const noLocaleFormatInRender = defineRule({
 					if (!match || reportedNodes.has(match.node)) return;
 					if (fileIsEmailTemplate) return;
 					if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-					if (isInsideClientOnlyGuard(node)) return;
-					if (isGatedByFalsyInitialState(node)) return;
-					if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode)) return;
+					if (isGatedByFalsyInitialState(node, context.scopes)) return;
+					if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode, context.scopes)) return;
 					if (hasSuppressHydrationWarningAttribute(findEnclosingJsxOpeningElement(node))) return;
 					reportedNodes.add(match.node);
 					context.report({
@@ -30871,9 +32135,6 @@ 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) => {
@@ -31005,7 +32266,7 @@ const noMatchMediaInStateInitializer = defineRule({
 	title: "matchMedia in state initializer",
 	severity: "warn",
 	category: "Correctness",
-	disabledWhen: ["vite", "cra"],
+	requires: ["ssr"],
 	recommendation: "Prefer CSS media queries for layout, or subscribe with `useSyncExternalStore` and provide a stable server snapshot.",
 	create: (context) => {
 		if (isTestlikeFilename(context.filename)) return {};
@@ -31556,6 +32817,41 @@ 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",
@@ -32846,7 +34142,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 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const unwrapChainExpression$1 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
 const FUNCTION_WRAPPER_HOOK_NAMES$1 = new Set([
 	"useCallback",
 	"useMemo",
@@ -32881,7 +34177,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(node.init);
+		const initializer = unwrapChainExpression$1(node.init);
 		const wrappedFunction = getWrapperHookWrappedFunction(initializer);
 		if (wrappedFunction) {
 			if (wrappedFunction.async) return false;
@@ -32891,10 +34187,170 @@ 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(node.init)) !== null;
+	return getWrapperHookWrappedFunction(unwrapChainExpression$1(node.init)) !== null;
 }));
 const isHandlerBagArgument = (analysis, argument) => {
 	if (!isNodeOfType(argument, "ObjectExpression")) return false;
@@ -32916,7 +34372,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(node.init);
+	const init = unwrapChainExpression$1(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;
@@ -32946,71 +34402,79 @@ 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) => ({ 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."
-			});
-		}
-	} })
+	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."
+				});
+			}
+		} };
+	}
 });
 //#endregion
 //#region src/plugin/utils/is-call-result-consumed-as-argument.ts
@@ -34258,6 +35722,63 @@ 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;
@@ -36272,6 +37793,140 @@ 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",
@@ -40114,6 +41769,123 @@ 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 = [];
@@ -41582,7 +43354,7 @@ const renderingHydrationMismatchTime = defineRule({
 	title: "Time or random value in JSX",
 	severity: "warn",
 	category: "Correctness",
-	disabledWhen: ["vite", "cra"],
+	requires: ["ssr"],
 	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);
@@ -41596,8 +43368,7 @@ const renderingHydrationMismatchTime = defineRule({
 			const matched = NONDETERMINISTIC_RENDER_PATTERNS.find((pattern) => pattern.matches(node.expression));
 			if (matched) {
 				if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
-				if (isInsideClientOnlyGuard(node)) return;
-				if (isGatedByFalsyInitialState(node)) return;
+				if (isGatedByFalsyInitialState(node, context.scopes)) return;
 				if (isInsideMotionTransitionAttribute(node)) return;
 				context.report({
 					node,
@@ -41606,11 +43377,10 @@ const renderingHydrationMismatchTime = defineRule({
 				return;
 			}
 			walkAst(node.expression, (child) => {
-				if (isFunctionLike$1(child) && !executesDuringRender(child)) return false;
+				if (isFunctionLike$1(child) && !executesDuringRender(child, context.scopes)) return false;
 				for (const pattern of NONDETERMINISTIC_RENDER_PATTERNS) if (pattern.matches(child)) {
 					if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
-					if (isInsideClientOnlyGuard(child)) return;
-					if (isGatedByFalsyInitialState(child)) return;
+					if (isGatedByFalsyInitialState(child, context.scopes)) return;
 					if (isInsideMotionTransitionAttribute(child)) return;
 					if (pattern.display === "new Date()" && isYearOnlyDateRead(child)) return;
 					context.report({
@@ -54947,6 +56717,18 @@ 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",
@@ -54959,6 +56741,18 @@ 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",
@@ -55466,6 +57260,18 @@ 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",
@@ -55710,6 +57516,18 @@ 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",
@@ -58042,10 +59860,17 @@ 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",
@@ -58097,6 +59922,9 @@ 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();
@@ -58179,10 +60007,17 @@ 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],