oxlint-plugin-react-doctor 0.7.4-dev.b47d053 → 0.7.4-dev.d4f2209

package/dist/index.js

@@ -553,7 +553,7 @@ const EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS = new Set([
 	"ResizeObserver",
 	"PerformanceObserver"
 ]);
-const STORAGE_OBJECTS$1 = new Set(["localStorage", "sessionStorage"]);
+const STORAGE_OBJECTS = new Set(["localStorage", "sessionStorage"]);
 //#endregion
 //#region src/plugin/constants/react.ts
 const INDEX_PARAMETER_NAMES = new Set([
@@ -5139,8 +5139,10 @@ const STORAGE_GLOBALS = new Set([
 const SENSITIVE_KEY_PATTERN = /token|jwt|secret|password|passwd|credential|api[-_]?key|bearer|private[-_]?key/i;
 const NON_AUTH_TOKEN_PATTERN = /csrf|xsrf|device|fcm|apns|push|design|tokeniz|syntax|css|theme|color/i;
 const STRONG_AUTH_KEY_PATTERN = /jwt|secret|password|passwd|credential|private[-_]?key|api[-_]?key|bearer|access[-_]?token|refresh[-_]?token|auth[-_]?token|id[-_]?token|session/i;
+const PRODUCT_API_KEY_COLLECTION_PATTERN = /[._:-](?:created|generated|saved)[-_]?api[-_]?keys$/i;
 const isAuthCredentialKey = (key) => {
 	if (!SENSITIVE_KEY_PATTERN.test(key)) return false;
+	if (PRODUCT_API_KEY_COLLECTION_PATTERN.test(key)) return false;
 	if (NON_AUTH_TOKEN_PATTERN.test(key) && !STRONG_AUTH_KEY_PATTERN.test(key)) return false;
 	return true;
 };
@@ -6135,7 +6137,6 @@ const isGlobalMethodCall = (node, objectName, methodName) => {
 //#region src/plugin/rules/client/client-localstorage-no-version.ts
 const VERSIONED_KEY_PATTERN = /(?:[._:-]v\d+|@\d+|\bv\d+\b)/i;
 const CAMEL_CASE_VERSIONED_KEY_PATTERN = /[a-z]V\d+/;
-const STORAGE_OBJECTS = new Set(["localStorage", "sessionStorage"]);
 const isVersionedKey = (key) => VERSIONED_KEY_PATTERN.test(key) || CAMEL_CASE_VERSIONED_KEY_PATTERN.test(key);
 const isJsonStringifyCall = (node) => isGlobalMethodCall(node, "JSON", "stringify");
 const resolveStringKey = (keyArg, context) => {
@@ -6158,7 +6159,7 @@ const clientLocalstorageNoVersion = defineRule({
 		if (!isNodeOfType(node.callee, "MemberExpression")) return;
 		const receiver = stripParenExpression(node.callee.object);
 		if (!isNodeOfType(receiver, "Identifier")) return;
-		if (!STORAGE_OBJECTS.has(receiver.name)) return;
+		if (receiver.name !== "localStorage") return;
 		if (!isNodeOfType(node.callee.property, "Identifier")) return;
 		if (node.callee.property.name !== "setItem") return;
 		const keyArg = node.arguments?.[0];
@@ -8406,6 +8407,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;
@@ -8461,46 +8510,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) => {
@@ -8535,125 +8628,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",
@@ -8664,7 +8641,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;
@@ -8673,13 +8709,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;
 		}
@@ -8688,118 +8733,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([
@@ -8825,85 +9100,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 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 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 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;
 		}
 	});
@@ -8915,6 +9290,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",
@@ -8923,7 +9318,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({
@@ -8935,30 +9331,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);
 			}
 		};
 	}
@@ -9572,13 +9969,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([
@@ -9763,7 +10165,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;
@@ -9776,7 +10178,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;
@@ -9811,7 +10213,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;
@@ -9841,7 +10243,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;
@@ -9855,7 +10257,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;
@@ -9873,7 +10275,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) => {
@@ -10061,10 +10469,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 {
@@ -10093,12 +10509,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);
@@ -10126,12 +10590,78 @@ const isUnstableInitializer = (node) => {
 	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left) || isUnstableInitializer(stripped.right);
 	return isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "ArrayExpression") || isNodeOfType(stripped, "ClassExpression") || isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment") || isNodeOfType(stripped, "AssignmentExpression") || isNodeOfType(stripped, "NewExpression");
 };
+const isPotentiallyFreshComparedValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = unwrapExpression$3(node);
+	if (isUnstableInitializer(candidate)) return true;
+	if (isNodeOfType(candidate, "ConditionalExpression")) return isPotentiallyFreshComparedValue(candidate.consequent, scopes, visitedSymbolIds) || isPotentiallyFreshComparedValue(candidate.alternate, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "LogicalExpression")) return isPotentiallyFreshComparedValue(candidate.left, scopes, visitedSymbolIds) || isPotentiallyFreshComparedValue(candidate.right, scopes, visitedSymbolIds);
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	if (symbol.kind === "let" || symbol.kind === "var") return true;
+	if (symbol.kind !== "const" || !symbol.initializer) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isPotentiallyFreshComparedValue(symbol.initializer, scopes, visitedSymbolIds);
+};
+const isExtraDepAllowedForHook = (hookName, node, scopes) => {
+	if (!isExtraReactiveDepAllowed(node, scopes)) return false;
+	if (EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName)) return true;
+	if (hookName !== "useMemo") return false;
+	const rootSymbol = getRootSymbol(node, scopes);
+	return Boolean(rootSymbol && !symbolHasStableValue(rootSymbol, scopes) && !isUnstableInitializer(rootSymbol.initializer));
+};
 const hasDirectIdentifierDeclarator = (symbol) => isNodeOfType(symbol.declarationNode, "VariableDeclarator") && isNodeOfType(symbol.declarationNode.id, "Identifier") || isNodeOfType(symbol.declarationNode, "ClassDeclaration");
 const isFunctionValueSymbol = (symbol) => getFunctionValueNode(symbol) !== null;
-const isStableSetterLikeSymbol = (symbol) => {
-	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 isConvergingFunctionalUpdater = (node, scopes) => {
+	const updater = unwrapExpression$3(node);
+	if (!isNodeOfType(updater, "ArrowFunctionExpression") && !isNodeOfType(updater, "FunctionExpression")) return false;
+	const previousValueParameter = updater.params?.[0];
+	if (!previousValueParameter || !isNodeOfType(previousValueParameter, "Identifier")) return false;
+	let returnedExpression = updater.body;
+	if (isNodeOfType(updater.body, "BlockStatement")) {
+		returnedExpression = null;
+		for (const statement of updater.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument) {
+			returnedExpression = statement.argument;
+			break;
+		}
+	}
+	const conditional = returnedExpression ? unwrapExpression$3(returnedExpression) : null;
+	if (!conditional || !isNodeOfType(conditional, "ConditionalExpression")) return false;
+	const test = unwrapExpression$3(conditional.test);
+	if (!isNodeOfType(test, "BinaryExpression") || ![
+		"===",
+		"!==",
+		"==",
+		"!="
+	].includes(test.operator)) return false;
+	const isPreviousValue = (expression) => {
+		const candidate = unwrapExpression$3(expression);
+		return isNodeOfType(candidate, "Identifier") && candidate.name === previousValueParameter.name;
+	};
+	let comparedValue = null;
+	if (isPreviousValue(test.left)) comparedValue = test.right;
+	else if (isPreviousValue(test.right)) comparedValue = test.left;
+	if (!comparedValue) return false;
+	if (isPotentiallyFreshComparedValue(comparedValue, scopes)) return false;
+	const isSameComparedValue = (expression) => {
+		const candidate = unwrapExpression$3(expression);
+		const compared = unwrapExpression$3(comparedValue);
+		if (isNodeOfType(candidate, "Identifier") && isNodeOfType(compared, "Identifier")) return candidate.name === compared.name;
+		if (isNodeOfType(candidate, "Literal") && isNodeOfType(compared, "Literal")) return candidate.value === compared.value;
+		return false;
+	};
+	return test.operator === "===" || test.operator === "==" ? isPreviousValue(conditional.consequent) && isSameComparedValue(conditional.alternate) : isSameComparedValue(conditional.consequent) && isPreviousValue(conditional.alternate);
+};
+const isGuardedStableSetterCall = (identifier, symbol, scopes) => {
+	const parent = identifier.parent;
+	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier || !isStableSetterLikeSymbol(symbol, scopes)) return false;
+	const writtenValue = parent.arguments?.[0];
+	return Boolean(writtenValue && isConvergingFunctionalUpdater(writtenValue, scopes));
+};
 const findStableSetterReference = (node, scopes) => {
 	let setterName = null;
 	const visit = (current) => {
@@ -10139,7 +10669,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) && !isGuardedStableSetterCall(current, symbol, scopes)) {
 				setterName = symbol.name;
 				return;
 			}
@@ -10255,11 +10785,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);
@@ -10299,7 +10829,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;
@@ -10315,7 +10847,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;
 				}
@@ -10333,9 +10865,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",
@@ -10390,7 +10924,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);
@@ -10447,7 +10981,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)
 				});
@@ -10546,7 +11080,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,
@@ -10584,7 +11118,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;
@@ -10670,7 +11204,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;
@@ -12342,20 +12876,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]/;
@@ -13042,7 +13562,7 @@ const jsCacheStorage = defineRule({
 			CallExpression(node) {
 				if (!isMemberProperty(node.callee, "getItem")) return;
 				const receiver = stripParenExpression(node.callee.object);
-				if (!isNodeOfType(receiver, "Identifier") || !STORAGE_OBJECTS$1.has(receiver.name)) return;
+				if (!isNodeOfType(receiver, "Identifier") || !STORAGE_OBJECTS.has(receiver.name)) return;
 				if (!isNodeOfType(node.arguments?.[0], "Literal")) return;
 				const storageReadCounts = storageReadCountStack[storageReadCountStack.length - 1];
 				const storageKey = String(node.arguments[0].value);
@@ -13309,6 +13829,11 @@ const jsEarlyExit = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/js-flatmap-filter.ts
+const BOUNDED_PIPELINE_SOURCE_METHOD_NAMES = new Set(["slice", "split"]);
+const isBoundedPipelineSource = (node) => {
+	const receiver = stripParenExpression(node);
+	return isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "MemberExpression") && isNodeOfType(receiver.callee.property, "Identifier") && BOUNDED_PIPELINE_SOURCE_METHOD_NAMES.has(receiver.callee.property.name);
+};
 const jsFlatmapFilter = defineRule({
 	id: "js-flatmap-filter",
 	title: ".map().filter(Boolean) loops twice",
@@ -13326,6 +13851,7 @@ const jsFlatmapFilter = defineRule({
 		if (!isNodeOfType(innerCall, "CallExpression") || !isNodeOfType(innerCall.callee, "MemberExpression") || !isNodeOfType(innerCall.callee.property, "Identifier")) return;
 		if (innerCall.callee.property.name !== "map") return;
 		const receiver = stripParenExpression(innerCall.callee.object);
+		if (receiver && isBoundedPipelineSource(receiver)) return;
 		if (receiver && isNodeOfType(receiver, "ArrayExpression")) {
 			const elements = receiver.elements ?? [];
 			if (elements.length > 0 && elements.length <= 8 && elements.every((element) => element == null || !isNodeOfType(element, "SpreadElement"))) return;
@@ -13500,7 +14026,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",
@@ -13519,7 +14045,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;
@@ -13748,7 +14274,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([
 	"!==",
@@ -13760,17 +14286,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;
@@ -13857,18 +14383,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)) {
@@ -13913,7 +14439,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;
@@ -19643,54 +20169,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;
@@ -20674,6 +21152,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);
@@ -20688,6 +21167,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;
@@ -20736,25 +21216,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
@@ -20843,139 +21335,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",
@@ -21092,35 +21451,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;
@@ -21299,25 +21629,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);
@@ -22102,6 +22436,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")) {
@@ -22500,6 +22854,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",
@@ -22546,6 +22940,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);
@@ -22676,7 +23106,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);
@@ -22685,7 +23115,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) => {
@@ -22706,7 +23137,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)) {
@@ -22759,6 +23191,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"));
@@ -22844,38 +23444,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")) {
@@ -22893,6 +23510,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);
@@ -22955,8 +23586,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();
@@ -22976,7 +23607,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);
@@ -23025,7 +23657,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,
@@ -24286,6 +24918,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",
@@ -24488,6 +25253,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?$/;
@@ -24817,7 +25611,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",
@@ -24838,7 +25632,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);
@@ -25782,57 +26576,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;
@@ -25966,6 +26709,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;
@@ -27471,14 +28444,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) {
@@ -27509,7 +28482,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;
@@ -29329,28 +30302,26 @@ const noGiantComponent = defineRule({
 			const lineCount = bodyNode.loc.end.line - bodyNode.loc.start.line + 1;
 			return lineCount > 300 ? lineCount : null;
 		};
-		const reportOversizedComponent = (nameNode, componentName, lineCount) => {
+		const reportOversizedComponent = (nameNode, componentName) => {
 			context.report({
 				node: nameNode,
-				message: `Component "${componentName}" is ${lineCount} lines long, which is hard to read & change. Split it into a few smaller components.`
+				message: `Component "${componentName}" is over 300 lines long, which is hard to read & change. Split it into a few smaller components.`
 			});
 		};
 		return {
 			FunctionDeclaration(node) {
 				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
-				const lineCount = getOversizedComponentLineCount(node);
-				if (lineCount === null) return;
+				if (getOversizedComponentLineCount(node) === null) return;
 				if (!functionContainsReactRenderOutput(node, context.scopes)) return;
-				reportOversizedComponent(node.id, node.id.name, lineCount);
+				reportOversizedComponent(node.id, node.id.name);
 			},
 			VariableDeclarator(node) {
 				if (!isNodeOfType(node.id, "Identifier") || !isUppercaseName(node.id.name)) return;
 				const functionNode = unwrapReactHocFunction(node.init);
 				if (!functionNode) return;
-				const lineCount = getOversizedComponentLineCount(functionNode);
-				if (lineCount === null) return;
+				if (getOversizedComponentLineCount(functionNode) === null) return;
 				if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
-				reportOversizedComponent(node.id, node.id.name, lineCount);
+				reportOversizedComponent(node.id, node.id.name);
 			}
 		};
 	}
@@ -29568,57 +30539,6 @@ const noGrayOnColoredBackground = defineRule({
 	} })
 });
 //#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 = 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.has(parent.callee.property.name) && parent.arguments?.[0] === functionNode;
-};
-//#endregion
 //#region src/plugin/utils/find-enclosing-jsx-opening-element.ts
 const findEnclosingJsxOpeningElement = (node) => {
 	let cursor = node.parent;
@@ -29630,17 +30550,6 @@ const findEnclosingJsxOpeningElement = (node) => {
 	return null;
 };
 //#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/has-client-render-evidence.ts
 const hasClientRenderEvidence = (componentOrHookNode, fileHasUseClientDirective) => {
 	if (fileHasUseClientDirective) return true;
@@ -29749,9 +30658,6 @@ const isGatedByFalsyInitialState = (node, scopes) => {
 	return false;
 };
 //#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/performance/no-hydration-branch-on-browser-global.ts
 const evaluateEquality = (operator, left, right) => {
 	if (operator === "===" || operator === "==") return left === right;
@@ -30052,6 +30958,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 = {
@@ -30218,7 +31249,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({
@@ -31850,6 +32881,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",
@@ -33140,7 +34206,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",
@@ -33175,7 +34241,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;
@@ -33185,10 +34251,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;
@@ -33210,7 +34436,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;
@@ -33240,71 +34466,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
@@ -33858,6 +35092,66 @@ const noPropCallbackInEffect = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-prop-callback-in-render.ts
+const isPreservedThroughConciseArrow = (callExpression, scopes) => {
+	let node = callExpression;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "ChainExpression")) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "SequenceExpression")) {
+			const expressions = parent.expressions ?? [];
+			if (expressions[expressions.length - 1] !== node) return false;
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (!isNodeOfType(parent, "ArrowFunctionExpression") || parent.body !== node) return !isResultDiscardedCall(node);
+		const invocation = parent.parent;
+		if (!isNodeOfType(invocation, "CallExpression") || !executesDuringRender(parent, scopes)) return true;
+		if (invocation.arguments?.[0] === parent || invocation.arguments?.[1] === parent) {
+			const callee = stripParenExpression(invocation.callee);
+			return !(isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "forEach" && invocation.arguments[0] === parent);
+		}
+		node = invocation;
+		parent = node.parent;
+	}
+	return false;
+};
+const noPropCallbackInRender = defineRule({
+	id: "no-prop-callback-in-render",
+	title: "Prop callback invoked during render",
+	severity: "error",
+	recommendation: "Invoke the callback from the event or asynchronous operation that produced the value, or from an effect when synchronizing with an external system. Render must stay pure because React can replay or discard it.",
+	create: (context) => ({ CallExpression(node) {
+		if (!isResultDiscardedCall(node)) return;
+		if (isPreservedThroughConciseArrow(node, context.scopes)) return;
+		if (!findRenderPhaseComponentOrHook(node, context.scopes)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		const callee = stripParenExpression(node.callee);
+		if (isFunctionLike$1(callee)) return;
+		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference))) return;
+		context.report({
+			node,
+			message: "This prop callback runs during render. React can replay or discard render work, so the callback can fire more than once or for UI that never commits."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/architecture/no-prop-types.ts
 const PROP_TYPES_PROPERTY = "propTypes";
 const isPropTypesKey = (key, computed) => {
@@ -34552,6 +35846,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;
@@ -40542,6 +41893,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 = [];
@@ -55397,6 +56865,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",
@@ -55813,6 +57293,18 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noPropCallbackInEffect.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-prop-callback-in-render",
+		id: "no-prop-callback-in-render",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noPropCallbackInRender,
+			framework: "global",
+			category: "Bugs",
+			requires: [...new Set(["react", ...noPropCallbackInRender.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-prop-types",
 		id: "no-prop-types",
@@ -55904,6 +57396,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",
@@ -58496,6 +60000,11 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"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",
@@ -58549,6 +60058,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();
@@ -58635,6 +60147,11 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["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],