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

package/dist/index.js

@@ -8406,54 +8406,6 @@ const effectListenerCleanupMismatch = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/collect-effect-invoked-functions.ts
-const PROMISE_CHAIN_METHOD_NAMES$1 = new Set([
-	"then",
-	"catch",
-	"finally"
-]);
-const collectEffectInvokedFunctions = (effectCallback) => {
-	const invokedFunctions = new Set([effectCallback]);
-	const localFunctionBindings = /* @__PURE__ */ new Map();
-	const calledBindingNames = /* @__PURE__ */ new Set();
-	const pendingFunctions = [effectCallback];
-	const enqueue = (candidate) => {
-		const strippedCandidate = candidate ? stripParenExpression(candidate) : candidate;
-		if (!isFunctionLike$1(strippedCandidate) || invokedFunctions.has(strippedCandidate)) return;
-		invokedFunctions.add(strippedCandidate);
-		pendingFunctions.push(strippedCandidate);
-	};
-	const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
-	while (pendingFunctions.length > 0) {
-		const currentFunction = pendingFunctions.pop();
-		if (!currentFunction) break;
-		walkAst(currentFunction, (child) => {
-			if (child !== currentFunction && isFunctionLike$1(child)) {
-				if (isNodeOfType(child, "FunctionDeclaration") && isNodeOfType(child.id, "Identifier")) localFunctionBindings.set(child.id.name, child);
-				return false;
-			}
-			if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
-				const initializer = child.init ? stripParenExpression(child.init) : null;
-				if (isFunctionLike$1(initializer)) localFunctionBindings.set(child.id.name, initializer);
-				return;
-			}
-			if (!isNodeOfType(child, "CallExpression")) return;
-			const callee = stripParenExpression(child.callee);
-			if (isFunctionLike$1(callee)) {
-				enqueue(callee);
-				return;
-			}
-			if (isNodeOfType(callee, "Identifier")) {
-				calledBindingNames.add(callee.name);
-				return;
-			}
-			if (isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
-		});
-		for (const calledName of calledBindingNames) enqueue(localFunctionBindings.get(calledName));
-	}
-	return invokedFunctions;
-};
-//#endregion
 //#region src/plugin/utils/is-react-hook-name.ts
 const isReactHookName = (name) => {
 	if (!name.startsWith("use")) return false;
@@ -8509,90 +8461,46 @@ const enclosingComponentOrHookName = (node) => {
 	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
 };
 //#endregion
-//#region src/plugin/utils/find-declarator-for-binding.ts
-const findDeclaratorForBinding = (bindingIdentifier) => {
-	let ancestor = bindingIdentifier.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "VariableDeclarator")) return ancestor;
-		if (isNodeOfType(ancestor, "FunctionDeclaration") || isNodeOfType(ancestor, "FunctionExpression") || isNodeOfType(ancestor, "ArrowFunctionExpression") || isNodeOfType(ancestor, "Program")) return null;
-		ancestor = ancestor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/executes-during-render.ts
-const SYNCHRONOUS_ITERATION_METHOD_NAMES$1 = new Set([
-	"map",
-	"filter",
-	"forEach",
-	"flatMap",
-	"reduce",
-	"reduceRight",
-	"some",
-	"every",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"sort",
-	"toSorted"
-]);
-const REACT_RENDER_PHASE_HOOK_NAMES = new Set(["useMemo", "useState"]);
-const isGlobalArrayFromMember = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "MemberExpression") || unwrappedNode.computed || !isNodeOfType(unwrappedNode.object, "Identifier") || unwrappedNode.object.name !== "Array" || !scopes.isGlobalReference(unwrappedNode.object) || !isNodeOfType(unwrappedNode.property, "Identifier")) return false;
-	return unwrappedNode.property.name === "from";
-};
-const isConstAliasOfGlobalArrayFrom = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "Identifier")) return false;
-	const binding = findVariableInitializer(unwrappedNode, unwrappedNode.name);
-	if (!binding?.initializer) return false;
-	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
-	return Boolean(declarator && scopes.symbolFor(unwrappedNode)?.declarationNode === declarator && declarator.init && declarator.parent && isNodeOfType(declarator.parent, "VariableDeclaration") && declarator.parent.kind === "const" && isGlobalArrayFromMember(declarator.init, scopes));
-};
-const executesDuringRender = (functionNode, scopes) => {
-	const parent = functionNode.parent;
-	if (!isNodeOfType(parent, "CallExpression")) return false;
-	if (parent.callee === functionNode) return true;
-	if ((scopes ? isReactApiCall(parent, REACT_RENDER_PHASE_HOOK_NAMES, scopes, { allowGlobalReactNamespace: true }) : isHookCall$2(parent, REACT_RENDER_PHASE_HOOK_NAMES)) && parent.arguments?.[0] === functionNode) return true;
-	if (scopes && parent.arguments?.[1] === functionNode && (isGlobalArrayFromMember(parent.callee, scopes) || isConstAliasOfGlobalArrayFrom(parent.callee, scopes))) return true;
-	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES$1.has(parent.callee.property.name) && parent.arguments?.[0] === functionNode;
-};
-//#endregion
-//#region src/plugin/utils/find-render-phase-component-or-hook.ts
-const findRenderPhaseComponentOrHook = (node, scopes) => {
-	let functionNode = findEnclosingFunction(node);
-	while (functionNode) {
-		if (componentOrHookDisplayNameForFunction(functionNode)) return functionNode;
-		if (!executesDuringRender(functionNode, scopes)) return null;
-		functionNode = findEnclosingFunction(functionNode);
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/get-function-binding-name.ts
-const getFunctionBindingIdentifier = (functionNode) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
-	const parent = functionNode.parent;
-	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
-	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === functionNode && isNodeOfType(parent.left, "Identifier")) return parent.left;
-	if (isNodeOfType(parent, "CallExpression")) {
-		const callParent = parent.parent;
-		if (isNodeOfType(callParent, "VariableDeclarator") && isNodeOfType(callParent.id, "Identifier")) return callParent.id;
-	}
-	return null;
-};
-const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(functionNode)?.name ?? null;
-//#endregion
 //#region src/plugin/utils/get-range-start.ts
 const getRangeStart = (node) => {
 	const rangeStart = node.range?.[0];
 	return typeof rangeStart === "number" ? rangeStart : null;
 };
 //#endregion
-//#region src/plugin/utils/is-event-handler-attribute.ts
-const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
+//#region src/plugin/utils/is-result-discarded-call.ts
+const isResultDiscardedCall = (callExpression) => {
+	let node = callExpression;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "ExpressionStatement")) return true;
+		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void") return true;
+		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
+		if (isNodeOfType(parent, "ChainExpression")) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "SequenceExpression")) {
+			const expressions = parent.expressions ?? [];
+			if (expressions[expressions.length - 1] !== node) return true;
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
 //#endregion
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
@@ -8627,79 +8535,136 @@ const isCleanupReturningSubscribeLikeCallExpression = (node) => {
 	return true;
 };
 //#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",
-	socket: "connection"
+//#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 isSocketConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP.has(node.callee.name);
-const isSubscribeOrObserveCall = (node) => {
-	if (isSubscribeLikeCallExpression(node)) return true;
-	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME;
+const 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 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;
+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(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}`;
+	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 null;
+	return false;
 };
-const findAssignedResourceKey = (resourceNode, context) => {
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (isNodeOfType(parentNode, "ChainExpression")) {
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
+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 (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;
+	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 RESOURCE_NOUN_BY_KIND = {
+	subscribe: "subscription",
+	timer: "timer",
+	socket: "connection"
 };
-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 isSocketConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP.has(node.callee.name);
+const isSubscribeOrObserveCall = (node) => {
+	if (isSubscribeLikeCallExpression(node)) return true;
+	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME;
 };
-const findSubscribeLikeUsages = (callback, context) => {
+const findSubscribeLikeUsages = (callback) => {
 	const usages = [];
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	let cleanupArgument = null;
@@ -8708,22 +8673,13 @@ const findSubscribeLikeUsages = (callback, context) => {
 		const lastCallbackStatement = callbackStatements[callbackStatements.length - 1];
 		if (isNodeOfType(lastCallbackStatement, "ReturnStatement") && lastCallbackStatement.argument) cleanupArgument = lastCallbackStatement.argument;
 	}
-	const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
 	walkAst(callback, (child) => {
-		if (child !== callback && isFunctionLike$1(child)) {
-			if (child === cleanupArgument) return false;
-			if (!effectInvokedFunctions.has(child) && !isSynchronousIteratorCallback(child)) return false;
-		}
+		if (child === cleanupArgument && !isSubscribeLikeCallExpression(child)) return false;
 		if (isSocketConstruction(child)) {
 			usages.push({
 				kind: "socket",
 				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: null,
-				eventKey: null,
-				handlerKey: null
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
 			});
 			return;
 		}
@@ -8732,348 +8688,118 @@ const findSubscribeLikeUsages = (callback, context) => {
 			usages.push({
 				kind: "timer",
 				node: child,
-				resourceName: child.callee.name,
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: child.callee.name,
-				eventKey: null,
-				handlerKey: null
+				resourceName: child.callee.name
 			});
 			return;
 		}
-		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) {
-			const registrationDetails = getCallRegistrationDetails(child, context);
-			usages.push({
-				kind: "subscribe",
-				node: child,
-				resourceName: child.callee.property.name,
-				handleKey: findAssignedResourceKey(child, context),
-				...registrationDetails
-			});
+		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) usages.push({
+			kind: "subscribe",
+			node: child,
+			resourceName: child.callee.property.name
+		});
+	});
+	return usages;
+};
+const collectCleanupBindings = (effectCallback) => {
+	const bindings = {
+		cleanupFunctionNames: /* @__PURE__ */ new Set(),
+		subscriptionNames: /* @__PURE__ */ new Set(),
+		effectScopeVariableNames: /* @__PURE__ */ new Set()
+	};
+	if (!isNodeOfType(effectCallback, "ArrowFunctionExpression") && !isNodeOfType(effectCallback, "FunctionExpression")) return bindings;
+	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return bindings;
+	walkAst(effectCallback.body, (child) => {
+		if (!isSubscribeOrObserveCall(child)) return;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!isNodeOfType(child.callee, "MemberExpression")) return;
+		if (!isNodeOfType(child.callee.object, "Identifier")) return;
+		bindings.subscriptionNames.add(child.callee.object.name);
+	});
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (!isNodeOfType(child, "VariableDeclaration")) return;
+		for (const declarator of child.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			const bindingName = declarator.id.name;
+			bindings.effectScopeVariableNames.add(bindingName);
+			const init = declarator.init;
+			if (!init) continue;
+			if (isSocketConstruction(init)) {
+				bindings.subscriptionNames.add(bindingName);
+				continue;
+			}
+			if (!isNodeOfType(init, "CallExpression")) continue;
+			if (isSubscribeLikeCallExpression(init)) {
+				bindings.subscriptionNames.add(bindingName);
+				if (isCleanupReturningSubscribeLikeCallExpression(init)) bindings.cleanupFunctionNames.add(bindingName);
+			}
 		}
 	});
-	return usages.filter((usage) => isNodeReachableWithinFunction(usage.node, context));
-};
-const isNodeReachableWithinFunction = (node, context) => {
-	const owner = context.cfg.enclosingFunction(node);
-	if (!owner) return true;
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return true;
-	const targetBlock = functionCfg.blockOf(node);
-	if (!targetBlock) return true;
-	const visitedBlocks = new Set([functionCfg.entry]);
-	const pendingBlocks = [functionCfg.entry];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		if (currentBlock === targetBlock) return true;
-		for (const edge of currentBlock.successors) {
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return false;
-};
-const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, context) => {
-	let pathAnchor = usageNode;
-	let pathOwner = findEnclosingFunction(pathAnchor);
-	while (pathOwner && isSynchronousIteratorCallback(pathOwner)) {
-		if (matchingNodes.length > 0 && matchingNodes.every((matchingNode) => context.cfg.enclosingFunction(matchingNode) === pathOwner)) break;
-		const iteratorCall = pathOwner.parent;
-		if (!isNodeOfType(iteratorCall, "CallExpression")) break;
-		pathAnchor = iteratorCall;
-		pathOwner = findEnclosingFunction(pathAnchor);
-	}
-	const owner = context.cfg.enclosingFunction(pathAnchor);
-	if (!owner) return false;
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return false;
-	const usageBlock = functionCfg.blockOf(pathAnchor);
-	if (!usageBlock) return false;
-	const usageStart = getRangeStart(usageNode);
-	const matchingBlocks = new Set(matchingNodes.flatMap((matchingNode) => {
-		if (context.cfg.enclosingFunction(matchingNode) !== owner) return [];
-		const matchingBlock = functionCfg.blockOf(matchingNode);
-		if (!matchingBlock) return [];
-		const matchingStart = getRangeStart(matchingNode);
-		if (matchingBlock === usageBlock && usageStart !== null && matchingStart !== null && matchingStart < usageStart) return [];
-		return [matchingBlock];
-	}));
-	if (matchingBlocks.has(usageBlock)) return true;
-	const visitedBlocks = new Set([usageBlock]);
-	const pendingBlocks = [usageBlock];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		for (const edge of currentBlock.successors) {
-			if (matchingBlocks.has(edge.to)) continue;
-			if (edge.to === functionCfg.exit) return false;
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return matchingBlocks.size > 0;
-};
-const removeSynchronouslyReleasedUsages = (callback, usages, context) => {
+	walkAst(effectCallback.body, (child) => {
+		if (child !== effectCallback.body && (isNodeOfType(child, "ArrowFunctionExpression") || isNodeOfType(child, "FunctionExpression"))) return false;
+		if (isNodeOfType(child, "FunctionDeclaration") && child.id && isCleanupFunctionLike(child, bindings.cleanupFunctionNames, bindings.subscriptionNames)) {
+			bindings.cleanupFunctionNames.add(child.id.name);
+			return false;
+		}
+	});
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (!isNodeOfType(child, "VariableDeclaration")) return;
+		for (const declarator of child.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier") || !declarator.init) continue;
+			if (isCleanupFunctionLike(declarator.init, bindings.cleanupFunctionNames, bindings.subscriptionNames)) bindings.cleanupFunctionNames.add(declarator.id.name);
+		}
+	});
+	walkAst(effectCallback.body, (child) => {
+		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.left, "Identifier") && bindings.effectScopeVariableNames.has(child.left.name) && isCleanupFunctionLike(child.right, bindings.cleanupFunctionNames, bindings.subscriptionNames)) bindings.cleanupFunctionNames.add(child.left.name);
+	});
+	return bindings;
+};
+const removeSynchronouslyReleasedUsages = (callback, usages) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
-	const releaseCalls = [];
+	const releaseStarts = [];
 	walkInsideStatementBlocks(callback.body, (child) => {
-		if (!isNodeOfType(isNodeOfType(child, "ChainExpression") ? child.expression : child, "CallExpression")) return;
-		releaseCalls.push(child);
+		if (!isReleaseLikeCall(child, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return;
+		const releaseStart = getRangeStart(child);
+		if (releaseStart !== null) releaseStarts.push(releaseStart);
 	});
-	if (releaseCalls.length === 0) return usages;
+	if (releaseStarts.length === 0) return usages;
 	return usages.filter((usage) => {
 		const usageStart = getRangeStart(usage.node);
 		if (usageStart === null) return true;
-		const matchingReleaseCalls = releaseCalls.filter((releaseCall) => {
-			const releaseStart = getRangeStart(releaseCall);
-			return releaseStart !== null && releaseStart > usageStart && doesReleaseCallMatchUsage(releaseCall, usage, context);
-		});
-		return !doMatchingNodesCoverEveryPathAfterUsage(usage.node, matchingReleaseCalls, context);
-	});
-};
-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] : [];
+		return !releaseStarts.some((releaseStart) => releaseStart > usageStart);
 	});
-	if (invocationCalls.length !== 1) return null;
-	const invocationCall = invocationCalls[0];
-	return findEnclosingFunction(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
 };
-const resolveCleanupPathAnchor = (usageNode, effectCallback, context) => {
-	const usageFunction = findEnclosingFunction(usageNode);
-	if (!usageFunction || usageFunction === effectCallback) return usageNode;
-	return findSingleDirectInvocation(usageFunction, effectCallback, context) ?? usageNode;
-};
-const resolveSingleAssignedCleanupFunction = (expression, usage, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	const initializer = symbol?.initializer ? stripParenExpression(symbol.initializer) : null;
-	if (!symbol || symbol.kind !== "let" && symbol.kind !== "var" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || !isNodeOfType(initializer, "Literal") || initializer.value !== null || symbol.scope.symbols.filter((candidate) => candidate.name === symbol.name).length !== 1) return null;
-	const assignmentReferences = symbol.references.filter((reference) => isWithinAssignmentTarget(reference.identifier));
-	if (assignmentReferences.length !== 1) return null;
-	const assignmentReference = assignmentReferences[0];
-	const assignmentTarget = findTransparentExpressionRoot(assignmentReference.identifier);
-	const assignmentNode = assignmentTarget.parent;
-	if (!isNodeOfType(assignmentNode, "AssignmentExpression") || assignmentNode.operator !== "=" || assignmentNode.left !== assignmentTarget || findEnclosingFunction(assignmentNode) !== findEnclosingFunction(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [assignmentNode], context)) return null;
-	const assignedValue = stripParenExpression(assignmentNode.right);
-	return isFunctionLike$1(assignedValue) ? assignedValue : null;
-};
-const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visitedFunctions = /* @__PURE__ */ new Set()) => {
-	if (!isFunctionLike$1(cleanupFunction) || visitedFunctions.has(cleanupFunction)) return false;
-	visitedFunctions.add(cleanupFunction);
-	let didCleanupFunctionMatch = false;
-	walkAst(cleanupFunction.body, (cleanupChild) => {
-		if (didCleanupFunctionMatch) return false;
-		if (cleanupChild !== cleanupFunction.body && isFunctionLike$1(cleanupChild) && !isSynchronousIteratorCallback(cleanupChild)) return false;
-		if (doesReleaseCallMatchUsage(cleanupChild, usage, context)) {
-			didCleanupFunctionMatch = true;
-			return false;
-		}
-		const helperCall = isNodeOfType(cleanupChild, "ChainExpression") ? cleanupChild.expression : cleanupChild;
-		if (!isNodeOfType(helperCall, "CallExpression")) return;
-		const stableHelperFunction = resolveStableValue(helperCall.callee, context);
-		const helperFunction = isNodeOfType(stableHelperFunction, "Identifier") ? resolveSingleAssignedCleanupFunction(stableHelperFunction, usage, context) : stableHelperFunction;
-		if (helperFunction && isFunctionLike$1(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context, visitedFunctions)) {
-			didCleanupFunctionMatch = true;
-			return false;
-		}
+const cleanupReturnRunsAfterUsage = (returnStatement, usages) => {
+	if (returnStatement.argument && isCleanupReturningSubscribeLikeCallExpression(returnStatement.argument)) return true;
+	const returnStart = getRangeStart(returnStatement);
+	if (returnStart === null) return true;
+	return usages.some((usage) => {
+		const usageStart = getRangeStart(usage.node);
+		return usageStart === null || usageStart < returnStart;
 	});
-	return didCleanupFunctionMatch;
 };
-const effectHasCleanupForUsage = (callback, usage, context) => {
+const effectHasCleanupReturn = (callback, usages) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	if (usage.kind === "subscribe" && findEnclosingFunction(usage.node) === callback && doesResourceResultEscape(usage.node, true) && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
-	if (!isNodeOfType(callback.body, "BlockStatement")) return callback.body === usage.node && isCleanupReturningSubscribeLikeCallExpression(callback.body);
-	const matchingCleanupReturns = [];
+	if (!isNodeOfType(callback.body, "BlockStatement")) return isCleanupReturningSubscribeLikeCallExpression(callback.body);
+	const cleanupBindings = collectCleanupBindings(callback);
+	let didFindCleanupReturn = false;
 	walkInsideStatementBlocks(callback.body, (child) => {
+		if (didFindCleanupReturn) return;
 		if (!isNodeOfType(child, "ReturnStatement")) return;
-		const returnStart = getRangeStart(child);
-		const usageStart = getRangeStart(usage.node);
-		if (returnStart !== null && usageStart !== null && returnStart < usageStart) return;
-		const returnedValue = child.argument ? stripParenExpression(child.argument) : null;
-		if (!returnedValue) return;
-		if (usage.kind === "subscribe" && (returnedValue === usage.node || getRangeStart(returnedValue) !== null && getRangeStart(returnedValue) === getRangeStart(usage.node)) && isCleanupReturningSubscribeLikeCallExpression(returnedValue)) {
-			matchingCleanupReturns.push(child);
-			return;
-		}
-		if (usage.kind === "subscribe" && isNodeOfType(returnedValue, "Identifier") && usage.handleKey !== null && resolveExpressionKey$1(returnedValue, context) === usage.handleKey && isCleanupReturningSubscribeLikeCallExpression(usage.node)) {
-			matchingCleanupReturns.push(child);
-			return;
-		}
-		if (isNodeOfType(returnedValue, "Identifier")) {
-			if (returnedValue.name === "undefined" && context.scopes.isGlobalReference(returnedValue)) return;
-			const returnedKey = resolveExpressionKey$1(returnedValue, context);
-			if (usage.handleKey !== null && returnedKey === usage.handleKey) return;
-			if (!context.scopes.symbolFor(returnedValue)?.initializer) return;
-		}
-		const cleanupFunction = resolveStableValue(returnedValue, context);
-		if (!cleanupFunction || !isFunctionLike$1(cleanupFunction)) return;
-		if (doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context)) matchingCleanupReturns.push(child);
+		if (!cleanupReturnRunsAfterUsage(child, usages)) return;
+		if (isCleanupReturn(child.argument, cleanupBindings.cleanupFunctionNames, cleanupBindings.subscriptionNames, { allowOpaqueReturn: true })) didFindCleanupReturn = true;
 	});
-	return doMatchingNodesCoverEveryPathAfterUsage(resolveCleanupPathAnchor(usage.node, callback, context), matchingCleanupReturns, context);
-};
-const findFirstUsageWithoutCleanup = (callback, usages, context) => {
-	for (const usage of usages) if (!effectHasCleanupForUsage(callback, usage, context)) return usage;
-	return null;
-};
-const isLocalAbortControllerExpression = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "NewExpression") && isNodeOfType(unwrappedExpression.callee, "Identifier") && unwrappedExpression.callee.name === "AbortController") return true;
-	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return isLocalAbortControllerExpression(unwrappedExpression.object, context, visitedSymbolIds);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return false;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	if (symbol.initializer) return isLocalAbortControllerExpression(symbol.initializer, context, visitedSymbolIds);
-	const bindingProperty = symbol.bindingIdentifier.parent;
-	const bindingPattern = bindingProperty?.parent;
-	const variableDeclarator = bindingPattern?.parent;
-	return Boolean(isNodeOfType(bindingProperty, "Property") && isNodeOfType(bindingPattern, "ObjectPattern") && isNodeOfType(variableDeclarator, "VariableDeclarator") && variableDeclarator.init && isLocalAbortControllerExpression(variableDeclarator.init, context, visitedSymbolIds));
+	return didFindCleanupReturn;
 };
-const isSelfReleasingListenerOptionProperty = (property, context) => {
+const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
+const isSelfReleasingListenerOptionProperty = (property) => {
 	if (!isNodeOfType(property, "Property")) return false;
 	const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : isNodeOfType(property.key, "Literal") ? property.key.value : null;
-	if (keyName === "signal") return !isLocalAbortControllerExpression(property.value, context);
+	if (keyName === "signal") return true;
 	if (keyName !== "once") return false;
 	return isNodeOfType(property.value, "Literal") && property.value.value === true;
 };
-const hasSelfReleasingListenerOptions = (node, context) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some((property) => isSelfReleasingListenerOptionProperty(property, context)));
+const hasSelfReleasingListenerOptions = (node) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some(isSelfReleasingListenerOptionProperty));
 const PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB = new Map([
 	["addEventListener", new Set(["removeEventListener", "abort"])],
 	["addListener", new Set([
@@ -9099,185 +8825,85 @@ const UNIVERSAL_RELEASE_VERB_NAMES = new Set([
 	"teardown"
 ]);
 const SOCKET_RELEASE_VERB_NAMES = new Set(["close"]);
+const INTERVAL_RELEASE_VERB_NAMES = new Set(["clearInterval"]);
 const getReleaseVerbName = (node) => {
+	if (!isReleaseLikeCall(node, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return null;
 	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
 	if (!isNodeOfType(callNode, "CallExpression")) return null;
 	const callee = isNodeOfType(callNode.callee, "ChainExpression") ? callNode.callee.expression : callNode.callee;
-	if (isNodeOfType(callee, "Identifier")) return TIMER_CLEANUP_CALLEE_NAMES.has(callee.name) || GLOBAL_RELEASE_METHOD_NAMES.has(callee.name) || UNIVERSAL_RELEASE_VERB_NAMES.has(callee.name) ? callee.name : null;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-		const methodName = callee.property.name;
-		return GLOBAL_RELEASE_METHOD_NAMES.has(methodName) || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(methodName) || methodName === "on" ? methodName : null;
-	}
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
 	return null;
 };
-const doesReleaseCallMatchUsage = (node, usage, context) => {
-	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	const callee = isNodeOfType(callNode.callee, "ChainExpression") ? callNode.callee.expression : callNode.callee;
-	if (usage.kind === "timer") {
-		const expectedCleanupName = usage.registrationVerbName === "setInterval" ? "clearInterval" : "clearTimeout";
-		if (!isNodeOfType(callee, "Identifier") || !TIMER_CLEANUP_CALLEE_NAMES.has(callee.name) || callee.name !== expectedCleanupName) return false;
-		if (usage.handleKey !== null && resolveExpressionKey$1(callNode.arguments?.[0], context) === usage.handleKey) return true;
-		const collectionKey = findContainingCollectionKey(usage.node, context);
-		return collectionKey !== null && collectionKey === resolveIteratorCollectionKey(callNode.arguments?.[0], context);
-	}
-	if (isNodeOfType(callee, "Identifier") && usage.kind === "subscribe" && usage.handleKey !== null && resolveExpressionKey$1(callee, context) === usage.handleKey && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
-	const releaseVerbName = getReleaseVerbName(callNode);
-	if (!releaseVerbName) return false;
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
-	const releaseReceiverKey = resolveExpressionKey$1(callee.object, context);
-	if (usage.kind === "socket") return usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (SOCKET_RELEASE_VERB_NAMES.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName));
-	if (usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub" || releaseVerbName === "close" || releaseVerbName === "unwatch" || releaseVerbName === "unlisten" || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(releaseVerbName))) return true;
-	if (releaseVerbName === "abort" && releaseReceiverKey === getListenerAbortControllerKey(usage, context)) return true;
-	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) return false;
-	const pairedVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
-	if (!pairedVerbNames || !matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return false;
-	const releaseEventKey = resolveExpressionKey$1(callNode.arguments?.[0], context);
-	if (usage.eventKey !== null && releaseEventKey !== null && usage.eventKey !== releaseEventKey) {
-		const usageIteratorCollectionKey = isNodeOfType(usage.node, "CallExpression") ? resolveIteratorCollectionKey(usage.node.arguments?.[0], context) : null;
-		const releaseIteratorCollectionKey = resolveIteratorCollectionKey(callNode.arguments?.[0], context);
-		if (usageIteratorCollectionKey === null || usageIteratorCollectionKey !== releaseIteratorCollectionKey) return false;
-	}
-	if (releaseVerbName === "on") {
-		const handlerArgument = callNode.arguments?.[1];
-		return isNodeOfType(handlerArgument, "Literal") && handlerArgument.value === null;
-	}
-	if (releaseVerbName === "removeEventListener" || releaseVerbName === "removeListener" || releaseVerbName === "off") {
-		const releaseHandler = callNode.arguments?.[1];
-		if (!releaseHandler) return releaseVerbName === "off";
-		return usage.handlerKey !== null && resolveExpressionKey$1(releaseHandler, context) === usage.handlerKey;
-	}
-	if (releaseVerbName === "unobserve" && usage.eventKey !== null) return releaseEventKey === usage.eventKey;
-	return true;
-};
 const matchesPairedReleaseVerb = (releaseVerbName, pairedVerbNames) => pairedVerbNames.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName);
-const isReturnedEffectCleanupFunction = (functionNode) => {
-	let currentNode = functionNode;
-	let parentNode = currentNode.parent;
-	while (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	if (!isNodeOfType(parentNode, "ReturnStatement") || parentNode.argument !== currentNode) return false;
-	const effectCallback = findEnclosingFunction(parentNode);
-	const effectCall = effectCallback?.parent;
-	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isHookCall$2(effectCall, CLEANUP_EFFECT_HOOK_NAMES));
-};
-const isPotentiallyReachableFunction = (functionNode, context) => {
-	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode)) return true;
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
-	if (!bindingIdentifier) return false;
-	const symbol = context.scopes.symbolFor(bindingIdentifier);
-	if (!symbol) return false;
-	return symbol.references.some((reference) => findEnclosingFunction(reference.identifier) !== functionNode);
-};
-const isReleaseReachableForUsage = (releaseNode, usage, context) => {
-	if (!isNodeReachableWithinFunction(releaseNode, context)) return false;
-	const releaseFunction = findEnclosingFunction(releaseNode);
-	if (!releaseFunction) return true;
-	if (releaseFunction === findEnclosingFunction(usage.node)) return true;
-	return isPotentiallyReachableFunction(releaseFunction, context);
-};
-const fileContainsReleaseForUsage = (usage, context) => {
-	let programNode = usage.node;
-	while (programNode.parent) programNode = programNode.parent;
-	let didFindRelease = false;
-	walkAst(programNode, (child) => {
-		if (didFindRelease) return false;
-		if (doesReleaseCallMatchUsage(child, usage, context) && isReleaseReachableForUsage(child, usage, context)) {
-			didFindRelease = true;
+const bodyContainsPairedReleaseCall = (body, pairedVerbNames) => {
+	let didFindPairedRelease = false;
+	walkAst(body, (child) => {
+		if (didFindPairedRelease) return false;
+		if (child !== body && isFunctionLike$1(child)) return false;
+		const releaseVerbName = getReleaseVerbName(child);
+		if (releaseVerbName !== null && matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) {
+			didFindPairedRelease = true;
 			return false;
 		}
 	});
-	return didFindRelease;
+	return didFindPairedRelease;
 };
-const isUseSyncExternalStoreSubscribeFunction = (functionNode, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
-	if (!bindingIdentifier) return false;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	const isSubscribeBinding = (candidateBinding) => {
-		const symbol = context.scopes.symbolFor(candidateBinding);
-		if (!symbol || visitedSymbolIds.has(symbol.id) || symbol.references.length === 0) return false;
-		visitedSymbolIds.add(symbol.id);
-		return symbol.references.every((reference) => {
-			const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-			const referenceParent = referenceRoot.parent;
-			if (isNodeOfType(referenceParent, "CallExpression") && referenceParent.arguments?.[0] === referenceRoot) return isReactApiCall(referenceParent, "useSyncExternalStore", context.scopes);
-			const aliasDeclaration = referenceParent?.parent;
-			return Boolean(isNodeOfType(referenceParent, "VariableDeclarator") && referenceParent.init === referenceRoot && isNodeOfType(referenceParent.id, "Identifier") && isNodeOfType(aliasDeclaration, "VariableDeclaration") && aliasDeclaration.kind === "const" && isSubscribeBinding(referenceParent.id));
-		});
-	};
-	return isSubscribeBinding(bindingIdentifier);
+const fileReleaseVerbNamesCache = /* @__PURE__ */ new WeakMap();
+const collectFileReleaseVerbNames = (anyNode) => {
+	let programNode = anyNode;
+	while (programNode.parent) programNode = programNode.parent;
+	const cached = fileReleaseVerbNamesCache.get(programNode);
+	if (cached) return cached;
+	const releaseVerbNames = /* @__PURE__ */ new Set();
+	walkAst(programNode, (child) => {
+		const releaseVerbName = getReleaseVerbName(child);
+		if (releaseVerbName !== null) releaseVerbNames.add(releaseVerbName);
+	});
+	fileReleaseVerbNamesCache.set(programNode, releaseVerbNames);
+	return releaseVerbNames;
 };
-const doesResourceResultEscape = (resourceNode, allowConciseReturnEscape) => {
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode) return true;
-		if (isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode && allowConciseReturnEscape) return true;
-		if (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
-			currentNode = parentNode;
-			parentNode = currentNode.parent;
-			continue;
-		}
-		return false;
-	}
+const fileContainsPairedReleaseCall = (registrationCall, registrationVerbName) => {
+	const fileReleaseVerbNames = collectFileReleaseVerbNames(registrationCall);
+	const pairedVerbNames = PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(registrationVerbName);
+	if (!pairedVerbNames) return fileReleaseVerbNames.size > 0;
+	for (const releaseVerbName of fileReleaseVerbNames) if (matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return true;
 	return false;
 };
-const findRetainedFunctionLeak = (retainedFunction, context) => {
+const findRetainedFunctionLeak = (retainedFunction) => {
 	if (!isFunctionLike$1(retainedFunction)) return null;
 	const body = retainedFunction.body;
 	if (!body) return null;
+	const conciseReturnValue = isNodeOfType(body, "BlockStatement") ? null : body;
 	let leak = null;
-	const allowConciseReturnEscape = !isInlineRetainedHandlerFunction(retainedFunction, context);
-	const isExternalStoreSubscribeFunction = isUseSyncExternalStoreSubscribeFunction(retainedFunction, context);
-	const hasReleaseForUsage = (usage) => isExternalStoreSubscribeFunction ? effectHasCleanupForUsage(retainedFunction, usage, context) : fileContainsReleaseForUsage(usage, context);
 	walkAst(body, (child) => {
 		if (leak !== null) return false;
 		if (isFunctionLike$1(child)) return false;
-		if (isSocketConstruction(child) && !doesResourceResultEscape(child, false)) {
-			const socketUsage = {
+		if (child === conciseReturnValue && isNodeOfType(child, "CallExpression")) return;
+		if (isSocketConstruction(child) && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, SOCKET_RELEASE_VERB_NAMES)) {
+			leak = {
 				kind: "socket",
 				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: null,
-				eventKey: null,
-				handlerKey: null
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
 			};
-			if (!hasReleaseForUsage(socketUsage)) {
-				leak = socketUsage;
-				return false;
-			}
+			return false;
 		}
 		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
-			const timerUsage = {
+		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, INTERVAL_RELEASE_VERB_NAMES)) {
+			leak = {
 				kind: "timer",
 				node: child,
-				resourceName: "setInterval",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: "setInterval",
-				eventKey: null,
-				handlerKey: null
+				resourceName: "setInterval"
 			};
-			if (!hasReleaseForUsage(timerUsage)) {
-				leak = timerUsage;
-				return false;
-			}
+			return false;
 		}
-		if (isSubscribeOrObserveCall(child) && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
-			const registrationDetails = getCallRegistrationDetails(child, context);
-			const subscriptionUsage = {
+		if (isSubscribeOrObserveCall(child) && isResultDiscardedCall(child)) {
+			const registrationVerbName = isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") ? child.callee.property.name : "subscribe";
+			if (!hasSelfReleasingListenerOptions(child) && !fileContainsPairedReleaseCall(child, registrationVerbName)) leak = {
 				kind: "subscribe",
 				node: child,
-				resourceName: registrationDetails.registrationVerbName ?? "subscribe",
-				handleKey: findAssignedResourceKey(child, context),
-				...registrationDetails
+				resourceName: registrationVerbName
 			};
-			if (!hasSelfReleasingListenerOptions(child, context) && !hasReleaseForUsage(subscriptionUsage)) leak = subscriptionUsage;
 			return false;
 		}
 	});
@@ -9289,26 +8915,6 @@ const isRetainedComponentScopeFunction = (functionNode) => {
 	if (!isNodeOfType(functionNode.parent, "VariableDeclarator")) return false;
 	return enclosingComponentOrHookName(functionNode) !== null;
 };
-const isDirectJsxEventHandlerValue = (expression) => {
-	const expressionRoot = findTransparentExpressionRoot(expression);
-	const expressionContainer = expressionRoot.parent;
-	return isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === expressionRoot && isEventHandlerAttribute(expressionContainer.parent);
-};
-const isInlineRetainedHandlerFunction = (functionNode, context) => {
-	if (!isFunctionLike$1(functionNode)) return false;
-	const functionRoot = findTransparentExpressionRoot(functionNode);
-	const callbackCall = functionRoot.parent;
-	if (isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments?.[0] === functionRoot && isHookCall$2(callbackCall, "useCallback") && isDirectJsxEventHandlerValue(callbackCall)) return true;
-	const parentNode = functionNode.parent;
-	if (isDirectJsxEventHandlerValue(functionNode)) return true;
-	if (!isNodeOfType(parentNode, "Property") || parentNode.value !== functionNode || parentNode.computed) return false;
-	const propertyName = getStaticPropertyKeyName(parentNode);
-	if (!propertyName || !/^on[A-Z]/.test(propertyName)) return false;
-	const objectExpression = parentNode.parent;
-	if (!isNodeOfType(objectExpression, "ObjectExpression")) return false;
-	const objectParent = objectExpression.parent;
-	return (isNodeOfType(objectParent, "CallExpression") && objectParent.arguments.some((argument) => argument === objectExpression) || isNodeOfType(objectParent, "JSXExpressionContainer")) && findRenderPhaseComponentOrHook(parentNode, context.scopes) !== null;
-};
 const effectNeedsCleanup = defineRule({
 	id: "effect-needs-cleanup",
 	title: "Effect subscription or timer never cleaned up",
@@ -9317,8 +8923,7 @@ const effectNeedsCleanup = defineRule({
 	recommendation: "Return a cleanup function that stops the subscription or timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` or `clearTimeout(id)` for timers, `return () => observer.disconnect()` for observers, `return () => socket.close()` for connections, or `return unsubscribe` if the subscribe call already gave you one.",
 	create: (context) => {
 		const reportRetainedLeak = (retainedFunction) => {
-			if (!isPotentiallyReachableFunction(retainedFunction, context)) return;
-			const leak = findRetainedFunctionLeak(retainedFunction, context);
+			const leak = findRetainedFunctionLeak(retainedFunction);
 			if (!leak) return;
 			const resourceNoun = RESOURCE_NOUN_BY_KIND[leak.kind];
 			context.report({
@@ -9330,31 +8935,30 @@ const effectNeedsCleanup = defineRule({
 			CallExpression(node) {
 				if (isHookCall$2(node, "useCallback")) {
 					const retainedCallback = getEffectCallback(node);
-					if (retainedCallback && !isInlineRetainedHandlerFunction(retainedCallback, context)) reportRetainedLeak(retainedCallback);
+					if (retainedCallback) reportRetainedLeak(retainedCallback);
 					return;
 				}
-				if (!isHookCall$2(node, CLEANUP_EFFECT_HOOK_NAMES)) return;
+				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 				const callback = getEffectCallback(node);
 				if (!callback) return;
-				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback, context), context);
+				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback));
 				if (usages.length === 0) return;
-				const firstUsage = findFirstUsageWithoutCleanup(callback, usages, context);
-				if (!firstUsage) return;
+				if (effectHasCleanupReturn(callback, usages)) return;
+				const firstUsage = usages[0];
 				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
-				const hookName = getCalleeName$2(node) ?? "effect";
 				context.report({
 					node,
-					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without returning cleanup. Return a cleanup function so it does not leak after unmount.`
+					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in useEffect without returning cleanup. Return a cleanup function so it does not leak after unmount.`
 				});
 			},
 			FunctionDeclaration(node) {
 				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
 			},
 			ArrowFunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
 			},
 			FunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
 			}
 		};
 	}
@@ -12738,6 +12342,20 @@ const collectHandlerReferencedNames = (root) => {
 	return names;
 };
 //#endregion
+//#region src/plugin/utils/get-function-binding-name.ts
+const getFunctionBindingIdentifier = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
+	const parent = functionNode.parent;
+	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === functionNode && isNodeOfType(parent.left, "Identifier")) return parent.left;
+	if (isNodeOfType(parent, "CallExpression")) {
+		const callParent = parent.parent;
+		if (isNodeOfType(callParent, "VariableDeclarator") && isNodeOfType(callParent.id, "Identifier")) return callParent.id;
+	}
+	return null;
+};
+const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(functionNode)?.name ?? null;
+//#endregion
 //#region src/plugin/rules/jotai/jotai-select-atom-in-render-body.ts
 const JOTAI_SELECT_ATOM_SOURCES = ["jotai/utils", "jotai"];
 const COMPONENT_NAME_PATTERN = /^[A-Z]/;
@@ -13882,7 +13500,7 @@ const jsHoistIntl = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/create-loop-aware-visitors.ts
-const ITERATOR_CALLBACK_METHOD_NAMES$1 = new Set([
+const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
 	"map",
 	"flatMap",
 	"forEach",
@@ -13901,7 +13519,7 @@ const isIteratorCallback = (node) => {
 	const parent = node.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
 	if (!parent.arguments.includes(node)) return false;
-	return isNodeOfType(parent.callee, "MemberExpression") && isNodeOfType(parent.callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES$1.has(parent.callee.property.name);
+	return isNodeOfType(parent.callee, "MemberExpression") && isNodeOfType(parent.callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES.has(parent.callee.property.name);
 };
 const createLoopAwareVisitors = (innerVisitors, options = {}) => {
 	let loopDepth = 0;
@@ -14130,7 +13748,7 @@ const findIndexedArrayObject = (callbackBody, indexParameterName) => {
 	});
 	return indexedArrayObject;
 };
-const unwrapChainExpression$3 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const unwrapChainExpression$2 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
 const LENGTH_EQUALITY_OPERATORS = new Set(["===", "=="]);
 const LENGTH_MISMATCH_OPERATORS = new Set([
 	"!==",
@@ -14142,17 +13760,17 @@ const LENGTH_MISMATCH_OPERATORS = new Set([
 ]);
 const LENGTH_ANY_COMPARISON_OPERATORS = new Set([...LENGTH_EQUALITY_OPERATORS, ...LENGTH_MISMATCH_OPERATORS]);
 const isLengthComparison = (candidate, receiverArray, indexedArray, operators) => {
-	const binaryGuard = unwrapChainExpression$3(candidate);
+	const binaryGuard = unwrapChainExpression$2(candidate);
 	if (!isNodeOfType(binaryGuard, "BinaryExpression")) return false;
 	if (!operators.has(binaryGuard.operator)) return false;
-	const leftSide = unwrapChainExpression$3(binaryGuard.left);
-	const rightSide = unwrapChainExpression$3(binaryGuard.right);
+	const leftSide = unwrapChainExpression$2(binaryGuard.left);
+	const rightSide = unwrapChainExpression$2(binaryGuard.right);
 	if (!isMemberProperty(leftSide, "length")) return false;
 	if (!isMemberProperty(rightSide, "length")) return false;
-	const leftLengthObject = unwrapChainExpression$3(leftSide.object);
-	const rightLengthObject = unwrapChainExpression$3(rightSide.object);
-	const normalizedReceiver = unwrapChainExpression$3(receiverArray);
-	const normalizedIndexed = unwrapChainExpression$3(indexedArray);
+	const leftLengthObject = unwrapChainExpression$2(leftSide.object);
+	const rightLengthObject = unwrapChainExpression$2(rightSide.object);
+	const normalizedReceiver = unwrapChainExpression$2(receiverArray);
+	const normalizedIndexed = unwrapChainExpression$2(indexedArray);
 	const matchesReceiverThenIndexed = areExpressionsStructurallyEqual(leftLengthObject, normalizedReceiver) && areExpressionsStructurallyEqual(rightLengthObject, normalizedIndexed);
 	const matchesIndexedThenReceiver = areExpressionsStructurallyEqual(leftLengthObject, normalizedIndexed) && areExpressionsStructurallyEqual(rightLengthObject, normalizedReceiver);
 	return matchesReceiverThenIndexed || matchesIndexedThenReceiver;
@@ -14239,18 +13857,18 @@ const LENGTH_PRESERVING_METHOD_NAMES = new Set([
 	"toReversed"
 ]);
 const peelLengthPreservingDerivation = (expression) => {
-	let current = unwrapChainExpression$3(expression);
+	let current = unwrapChainExpression$2(expression);
 	for (;;) {
 		if (isNodeOfType(current, "ArrayExpression") && current.elements?.length === 1 && isNodeOfType(current.elements[0], "SpreadElement")) {
-			current = unwrapChainExpression$3(current.elements[0].argument);
+			current = unwrapChainExpression$2(current.elements[0].argument);
 			continue;
 		}
 		if (isNodeOfType(current, "CallExpression")) {
-			const callee = unwrapChainExpression$3(current.callee);
+			const callee = unwrapChainExpression$2(current.callee);
 			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-				const calleeObject = unwrapChainExpression$3(callee.object);
+				const calleeObject = unwrapChainExpression$2(callee.object);
 				if (isNodeOfType(calleeObject, "Identifier") && calleeObject.name === "Array" && callee.property.name === "from" && current.arguments?.length === 1) {
-					current = unwrapChainExpression$3(current.arguments[0]);
+					current = unwrapChainExpression$2(current.arguments[0]);
 					continue;
 				}
 				if (LENGTH_PRESERVING_METHOD_NAMES.has(callee.property.name)) {
@@ -14295,7 +13913,7 @@ const resolveComparedArraySource = (expression, scopeNode) => {
 		const initializer = findConstInitializer(current.name, scopeNode);
 		if (!initializer) return current;
 		const peeledInitializer = peelLengthPreservingDerivation(initializer);
-		if (peeledInitializer === unwrapChainExpression$3(initializer)) return current;
+		if (peeledInitializer === unwrapChainExpression$2(initializer)) return current;
 		current = peeledInitializer;
 	}
 	return current;
@@ -19989,41 +19607,89 @@ const nextjsMissingMetadata = defineRule({
 			node: programNode,
 			message: "This page has no metadata, so search engines and social previews get no title or description."
 		});
-	} })
-});
-//#endregion
-//#region src/plugin/rules/nextjs/nextjs-no-a-element.ts
-const getJsxAttributeLiteralValue = (attributeValue) => {
-	if (!attributeValue) return void 0;
-	if (isNodeOfType(attributeValue, "Literal")) return attributeValue.value;
-	if (isNodeOfType(attributeValue, "JSXExpressionContainer") && isNodeOfType(attributeValue.expression, "Literal")) return attributeValue.expression.value;
+	} })
+});
+//#endregion
+//#region src/plugin/rules/nextjs/nextjs-no-a-element.ts
+const getJsxAttributeLiteralValue = (attributeValue) => {
+	if (!attributeValue) return void 0;
+	if (isNodeOfType(attributeValue, "Literal")) return attributeValue.value;
+	if (isNodeOfType(attributeValue, "JSXExpressionContainer") && isNodeOfType(attributeValue.expression, "Literal")) return attributeValue.expression.value;
+};
+const nextjsNoAElement = defineRule({
+	id: "nextjs-no-a-element",
+	title: "Plain anchor reloads internal Next.js links",
+	tags: ["test-noise"],
+	requires: ["nextjs"],
+	severity: "warn",
+	recommendation: "`import Link from 'next/link'` for client-side navigation, prefetching, and preserved scroll position",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
+		const attributes = node.attributes ?? [];
+		const downloadAttribute = findJsxAttribute(attributes, "download");
+		if (downloadAttribute) {
+			if (!downloadAttribute.value) return;
+			const downloadValue = getJsxAttributeLiteralValue(downloadAttribute.value);
+			if (downloadValue !== false && downloadValue !== null) return;
+		}
+		if (getJsxAttributeLiteralValue(findJsxAttribute(attributes, "target")?.value) === "_blank") return;
+		const hrefAttribute = findJsxAttribute(attributes, "href");
+		if (!hrefAttribute?.value) return;
+		const hrefValue = getJsxAttributeLiteralValue(hrefAttribute.value);
+		if (typeof hrefValue === "string" && hrefValue.startsWith("/") && !hrefValue.startsWith("//")) context.report({
+			node,
+			message: "Plain <a> reloads the whole page for internal links, so Next.js loses client-side navigation and prefetching."
+		});
+	} })
+});
+//#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;
 };
-const nextjsNoAElement = defineRule({
-	id: "nextjs-no-a-element",
-	title: "Plain anchor reloads internal Next.js links",
-	tags: ["test-noise"],
-	requires: ["nextjs"],
-	severity: "warn",
-	recommendation: "`import Link from 'next/link'` for client-side navigation, prefetching, and preserved scroll position",
-	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
-		const attributes = node.attributes ?? [];
-		const downloadAttribute = findJsxAttribute(attributes, "download");
-		if (downloadAttribute) {
-			if (!downloadAttribute.value) return;
-			const downloadValue = getJsxAttributeLiteralValue(downloadAttribute.value);
-			if (downloadValue !== false && downloadValue !== null) return;
-		}
-		if (getJsxAttributeLiteralValue(findJsxAttribute(attributes, "target")?.value) === "_blank") return;
-		const hrefAttribute = findJsxAttribute(attributes, "href");
-		if (!hrefAttribute?.value) return;
-		const hrefValue = getJsxAttributeLiteralValue(hrefAttribute.value);
-		if (typeof hrefValue === "string" && hrefValue.startsWith("/") && !hrefValue.startsWith("//")) context.report({
-			node,
-			message: "Plain <a> reloads the whole page for internal links, so Next.js loses client-side navigation and prefetching."
-		});
-	} })
-});
 //#endregion
 //#region src/plugin/utils/contains-fetch-call.ts
 const isFetchCall$1 = (node) => {
@@ -25151,7 +24817,7 @@ const isAsyncFunctionLike = (node) => {
 	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) return Boolean(node.async);
 	return false;
 };
-const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
+const SYNCHRONOUS_ITERATION_METHOD_NAMES$1 = new Set([
 	"forEach",
 	"map",
 	"filter",
@@ -25172,7 +24838,7 @@ const runsOnEffectDispatch = (functionNode) => {
 	if (parent.callee === functionNode) return true;
 	if (!(parent.arguments ?? []).some((argument) => argument === functionNode)) return false;
 	const callee = parent.callee;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.has(callee.property.name);
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES$1.has(callee.property.name);
 };
 const isTerminatingStatement = (statement) => isNodeOfType(statement, "BreakStatement") || isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "ContinueStatement");
 const analyzeBranchStatements = (branch, context) => analyzeStatementSequence(isNodeOfType(branch, "BlockStatement") ? branch.body ?? [] : [branch], context);
@@ -27805,14 +27471,14 @@ const hasDocumentClassListMutation = (node) => {
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-effect-event-handler.ts
 const hasEventLikeNode = (node) => findTriggeredSideEffectCalleeName(node) !== null || hasDocumentClassListMutation(node);
-const unwrapChainExpression$2 = (node) => {
+const unwrapChainExpression$1 = (node) => {
 	if (!node) return null;
 	if (isNodeOfType(node, "ChainExpression")) return node.expression;
 	return node;
 };
 const collectGuardExpressions = (node, into) => {
 	if (!node) return;
-	const unwrappedNode = unwrapChainExpression$2(node);
+	const unwrappedNode = unwrapChainExpression$1(node);
 	if (!unwrappedNode) return;
 	const rootIdentifierName = getRootIdentifierName(unwrappedNode);
 	if (rootIdentifierName) {
@@ -27843,7 +27509,7 @@ const isReturnOnlyStatement = (node) => {
 };
 const hasEventLikeRemainingStatements = (statements) => statements.some((statement) => !isNodeOfType(statement, "ReturnStatement") && hasEventLikeNode(statement));
 const doesGuardMatchDependency = (guardExpression, dependencyExpression) => {
-	const unwrappedDependencyExpression = unwrapChainExpression$2(dependencyExpression);
+	const unwrappedDependencyExpression = unwrapChainExpression$1(dependencyExpression);
 	if (!unwrappedDependencyExpression) return false;
 	if (areExpressionsStructurallyEqual(guardExpression.expression, unwrappedDependencyExpression)) return true;
 	return isNodeOfType(unwrappedDependencyExpression, "Identifier") && unwrappedDependencyExpression.name === guardExpression.rootIdentifierName;
@@ -29902,6 +29568,57 @@ 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;
@@ -29913,6 +29630,17 @@ 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;
@@ -30021,6 +29749,9 @@ 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;
@@ -32119,41 +31850,6 @@ const noMutableInDeps = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-result-discarded-call.ts
-const isResultDiscardedCall = (callExpression) => {
-	let node = callExpression;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "ExpressionStatement")) return true;
-		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void") return true;
-		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
-		if (isNodeOfType(parent, "ChainExpression")) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "SequenceExpression")) {
-			const expressions = parent.expressions ?? [];
-			if (expressions[expressions.length - 1] !== node) return true;
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		return false;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/lodash-mutator-call.ts
 const LODASH_MUTATOR_NAMES = new Set([
 	"set",
@@ -33444,7 +33140,7 @@ const isUseRefIdentifier = (identifier) => {
 };
 const COMMAND_PROP_NAME_PATTERN = /^(fetch|load|refetch|dispatch|register|render)([A-Z_]|$)/;
 const SETTER_NAMED_PROP_PATTERN = /^set[A-Z]/;
-const unwrapChainExpression$1 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const unwrapChainExpression = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
 const FUNCTION_WRAPPER_HOOK_NAMES$1 = new Set([
 	"useCallback",
 	"useMemo",
@@ -33479,7 +33175,7 @@ const isDirectParentCallbackRef = (analysis, ref) => {
 	return Boolean(ref.resolved?.defs.some((def) => {
 		const node = def.node;
 		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-		const initializer = unwrapChainExpression$1(node.init);
+		const initializer = unwrapChainExpression(node.init);
 		const wrappedFunction = getWrapperHookWrappedFunction(initializer);
 		if (wrappedFunction) {
 			if (wrappedFunction.async) return false;
@@ -33492,7 +33188,7 @@ const isDirectParentCallbackRef = (analysis, ref) => {
 const isWrapperHookCallbackRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-	return getWrapperHookWrappedFunction(unwrapChainExpression$1(node.init)) !== null;
+	return getWrapperHookWrappedFunction(unwrapChainExpression(node.init)) !== null;
 }));
 const isHandlerBagArgument = (analysis, argument) => {
 	if (!isNodeOfType(argument, "ObjectExpression")) return false;
@@ -33514,7 +33210,7 @@ const HOOK_NAME_PATTERN$1 = /^use[A-Z0-9]/;
 const isParentWiredHookResultRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-	const init = unwrapChainExpression$1(node.init);
+	const init = unwrapChainExpression(node.init);
 	if (!isNodeOfType(init, "CallExpression")) return false;
 	const callee = init.callee;
 	if (!isNodeOfType(callee, "Identifier") || !HOOK_NAME_PATTERN$1.test(callee.name)) return false;
@@ -33558,7 +33254,7 @@ const noPassDataToParent = defineRule({
 			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
 			if (isRefCall(analysis, ref)) continue;
 			if (!isSynchronous(ref.identifier, effectFn)) continue;
-			const calleeNode = unwrapChainExpression$1(callExpr.callee);
+			const calleeNode = unwrapChainExpression(callExpr.callee);
 			const identifier = ref.identifier;
 			if (calleeNode === identifier) {
 				if (!isDirectParentCallbackRef(analysis, ref)) continue;
@@ -40846,123 +40542,6 @@ const preferUseEffectEvent = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/is-cleanup-return.ts
-const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
-	"each",
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"flatMap",
-	"forEach",
-	"map",
-	"reduce",
-	"reduceRight",
-	"some",
-	"sort",
-	"toSorted"
-]);
-const STATIC_ITERATOR_CALLBACK_METHOD_NAMES = new Set([
-	"from",
-	"fromAsync",
-	"groupBy"
-]);
-const unwrapChainExpression = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
-const isNullLiteral = (node) => isNodeOfType(node, "Literal") && node.value === null;
-const isListenerRemovalViaNullHandler = (callNode) => {
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	const callee = unwrapChainExpression(callNode.callee);
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "on" && isNullLiteral(callNode.arguments?.[1]);
-};
-const REFERENCE_BASED_REMOVAL_METHOD_NAMES = new Set([
-	"off",
-	"removeEventListener",
-	"removeListener"
-]);
-const isNoOpInlineHandlerRemoval = (callNode, methodName) => {
-	if (!REFERENCE_BASED_REMOVAL_METHOD_NAMES.has(methodName)) return false;
-	const handlerArgument = callNode.arguments?.[1];
-	return isNodeOfType(handlerArgument, "ArrowFunctionExpression") || isNodeOfType(handlerArgument, "FunctionExpression");
-};
-const isReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	const callNode = unwrapChainExpression(node);
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	if (isListenerRemovalViaNullHandler(callNode)) return true;
-	const callee = unwrapChainExpression(callNode.callee);
-	if (isNodeOfType(callee, "Identifier")) {
-		if (TIMER_CLEANUP_CALLEE_NAMES.has(callee.name)) return true;
-		if (CLEANUP_LIKE_RELEASE_CALLEE_NAMES.has(callee.name)) return true;
-		if (knownCleanupFunctionNames.has(callee.name)) return true;
-		return false;
-	}
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-		if (isNoOpInlineHandlerRemoval(callNode, callee.property.name)) return false;
-		if (BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier") && knownBoundSubscriptionNames.has(callee.object.name)) return true;
-		return GLOBAL_RELEASE_METHOD_NAMES.has(callee.property.name);
-	}
-	return false;
-};
-const isStaticIteratorCallbackCallee = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && (callee.object.name === "Array" || callee.object.name === "Map" || callee.object.name === "Object") && STATIC_ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
-const isIteratorCallbackArgument = (node) => {
-	const parentNode = node.parent;
-	if (!isNodeOfType(parentNode, "CallExpression")) return false;
-	if (!parentNode.arguments?.some((argument) => argument === node)) return false;
-	const callee = unwrapChainExpression(parentNode.callee);
-	if (parentNode.arguments[1] === node && isStaticIteratorCallbackCallee(callee)) return true;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
-};
-const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	let didFindRelease = false;
-	walkAst(node, (child) => {
-		if (didFindRelease) return false;
-		if (child !== node && isFunctionLike$1(child) && !isIteratorCallbackArgument(child)) return false;
-		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
-			didFindRelease = true;
-			return false;
-		}
-	});
-	return didFindRelease;
-};
-const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	if (!isFunctionLike$1(node)) return false;
-	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
-};
-const isProvablyNoOpCleanupFunction = (node) => {
-	if (!isFunctionLike$1(node)) return false;
-	let sawNoOpRemoval = false;
-	let sawOtherCall = false;
-	walkAst(node.body, (child) => {
-		if (sawOtherCall) return false;
-		if (isFunctionLike$1(child)) return false;
-		const callNode = unwrapChainExpression(child);
-		if (!isNodeOfType(callNode, "CallExpression")) return;
-		const callee = unwrapChainExpression(callNode.callee);
-		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && isNoOpInlineHandlerRemoval(callNode, callee.property.name)) {
-			sawNoOpRemoval = true;
-			return;
-		}
-		sawOtherCall = true;
-	});
-	return sawNoOpRemoval && !sawOtherCall;
-};
-const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames, options = {}) => {
-	if (!returnedValue) return false;
-	const unwrappedValue = unwrapChainExpression(returnedValue);
-	if (isNodeOfType(unwrappedValue, "Literal") && unwrappedValue.value === null) return false;
-	if (isNodeOfType(unwrappedValue, "Identifier")) {
-		if (unwrappedValue.name === "undefined") return false;
-		if (knownCleanupFunctionNames.has(unwrappedValue.name)) return true;
-		return options.allowOpaqueReturn === true && !knownBoundSubscriptionNames.has(unwrappedValue.name);
-	}
-	if (isCleanupReturningSubscribeLikeCallExpression(unwrappedValue)) return true;
-	if (isProvablyNoOpCleanupFunction(unwrappedValue)) return false;
-	if (options.allowOpaqueReturn === true && !isSubscribeLikeCallExpression(unwrappedValue)) return true;
-	if (isCleanupFunctionLike(unwrappedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames)) return true;
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/prefer-use-sync-external-store.ts
 const findUseEffectsInComponent = (componentBody) => {
 	const effectCalls = [];