oxlint-plugin-react-doctor 0.7.6-dev.1d7b6e2 → 0.7.6-dev.3f22fe3

package/dist/index.js

@@ -6004,6 +6004,170 @@ const getStaticPropertyKeyName = (node, options = {}) => {
 	return null;
 };
 //#endregion
+//#region src/plugin/utils/are-expressions-structurally-equal.ts
+const areExpressionsStructurallyEqual = (a, b) => {
+	if (!a || !b) return a === b;
+	const unwrappedA = stripParenExpression(a);
+	const unwrappedB = stripParenExpression(b);
+	if (unwrappedA !== a || unwrappedB !== b) return areExpressionsStructurallyEqual(unwrappedA, unwrappedB);
+	if (a.type !== b.type) return false;
+	if (isNodeOfType(a, "ThisExpression")) return true;
+	if (isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier")) return a.name === b.name;
+	if (isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal")) return a.value === b.value;
+	if (isNodeOfType(a, "MemberExpression") && isNodeOfType(b, "MemberExpression")) {
+		if (a.computed !== b.computed) return false;
+		return areExpressionsStructurallyEqual(a.object, b.object) && areExpressionsStructurallyEqual(a.property, b.property);
+	}
+	if (isNodeOfType(a, "CallExpression") && isNodeOfType(b, "CallExpression")) {
+		if (!areExpressionsStructurallyEqual(a.callee, b.callee)) return false;
+		const argumentsA = a.arguments ?? [];
+		const argumentsB = b.arguments ?? [];
+		if (argumentsA.length !== argumentsB.length) return false;
+		return argumentsA.every((argument, index) => areExpressionsStructurallyEqual(argument, argumentsB[index]));
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/has-keyboard-activatable-descendant.ts
+const NATIVE_KEYBOARD_ACTIVATABLE_TAGS = new Set([
+	"a",
+	"button",
+	"input",
+	"select",
+	"summary",
+	"textarea"
+]);
+const KEYBOARD_ACTIVATABLE_COMPONENT_NAME_PATTERN = /button|link|nav|anchor/i;
+const EQUIVALENT_ACTION_COMPONENT_NAME_PATTERN = /(?:button|link|anchor)$/i;
+const UPPERCASE_COMPONENT_NAME_PATTERN = /^[A-Z]/;
+const DESCENDANT_ACTION_PROP_NAMES = ["onClick", "onPress"];
+const isStaticallyNullish = (expression) => isNullishExpression(stripParenExpression(expression));
+const isStaticallyNullishHandlerExpression = (expression, scopes) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNullishExpression(strippedExpression)) return true;
+	const symbol = resolveConstIdentifierAlias(strippedExpression, scopes);
+	if (symbol?.kind !== "const" || !symbol.initializer) return false;
+	return isNullishExpression(stripParenExpression(symbol.initializer));
+};
+const resolveSingleHandlerAction = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isStaticallyNullishHandlerExpression(strippedExpression, scopes)) return null;
+	if (isNodeOfType(strippedExpression, "ConditionalExpression")) {
+		const consequent = strippedExpression.consequent;
+		const alternate = strippedExpression.alternate;
+		if (isStaticallyNullishHandlerExpression(consequent, scopes)) return resolveSingleHandlerAction(alternate, scopes, visitedSymbolIds);
+		if (isStaticallyNullishHandlerExpression(alternate, scopes)) return resolveSingleHandlerAction(consequent, scopes, visitedSymbolIds);
+		return null;
+	}
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (symbol?.kind === "const" && symbol.initializer && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && isNodeOfType(symbol.declarationNode.id, "Identifier") && !visitedSymbolIds.has(symbol.id)) {
+			visitedSymbolIds.add(symbol.id);
+			return resolveSingleHandlerAction(symbol.initializer, scopes, visitedSymbolIds);
+		}
+		return strippedExpression;
+	}
+	if (isNodeOfType(strippedExpression, "ArrowFunctionExpression") || isNodeOfType(strippedExpression, "FunctionExpression") || isNodeOfType(strippedExpression, "FunctionDeclaration")) {
+		const body = stripParenExpression(strippedExpression.body);
+		if (!isNodeOfType(body, "BlockStatement")) return body;
+		if (body.body.length !== 1) return null;
+		const statement = body.body[0];
+		if (isNodeOfType(statement, "ExpressionStatement")) return statement.expression;
+		if (isNodeOfType(statement, "ReturnStatement") && statement.argument) return stripParenExpression(statement.argument);
+		return null;
+	}
+	return strippedExpression;
+};
+const getAttributeAction = (attribute, scopes) => {
+	if (!attribute.value || !isNodeOfType(attribute.value, "JSXExpressionContainer")) return null;
+	return resolveSingleHandlerAction(attribute.value.expression, scopes);
+};
+const hasPotentiallyTruthyAttribute = (openingElement, attributeName) => {
+	const attribute = hasJsxPropIgnoreCase(openingElement.attributes, attributeName);
+	if (!attribute) return false;
+	if (!attribute.value) return true;
+	if (isNodeOfType(attribute.value, "Literal")) return attribute.value.value === true || attribute.value.value === "true";
+	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return true;
+	const expression = stripParenExpression(attribute.value.expression);
+	return !isNodeOfType(expression, "Literal") || expression.value !== false;
+};
+const hasPotentiallyNonEmptyAttribute = (openingElement, attributeName) => {
+	const attribute = hasJsxPropIgnoreCase(openingElement.attributes, attributeName);
+	if (!attribute?.value) return false;
+	if (isNodeOfType(attribute.value, "Literal")) return typeof attribute.value.value === "string" && attribute.value.value.trim().length > 0;
+	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return true;
+	const expression = stripParenExpression(attribute.value.expression);
+	if (isNodeOfType(expression, "Literal")) return typeof expression.value === "string" && expression.value.trim().length > 0;
+	return !isStaticallyNullish(expression);
+};
+const childMayProvideAccessibleName = (child) => {
+	if (isNodeOfType(child, "JSXText")) return child.value.trim().length > 0;
+	if (isNodeOfType(child, "JSXElement")) return hasAccessibleNameEvidence(child);
+	if (isNodeOfType(child, "JSXFragment")) return child.children.some((nestedChild) => childMayProvideAccessibleName(nestedChild));
+	if (!isNodeOfType(child, "JSXExpressionContainer")) return false;
+	const expression = stripParenExpression(child.expression);
+	if (isNodeOfType(expression, "Literal")) {
+		if (typeof expression.value === "string") return expression.value.trim().length > 0;
+		return typeof expression.value === "number";
+	}
+	if (isStaticallyNullish(expression)) return false;
+	if (isNodeOfType(expression, "JSXElement")) return hasAccessibleNameEvidence(expression);
+	if (isNodeOfType(expression, "JSXFragment")) return expression.children.some((nestedChild) => childMayProvideAccessibleName(nestedChild));
+	return true;
+};
+const hasAccessibleNameEvidence = (element) => {
+	if (hasPotentiallyNonEmptyAttribute(element.openingElement, "aria-label") || hasPotentiallyNonEmptyAttribute(element.openingElement, "aria-labelledby")) return true;
+	return element.children.some((child) => childMayProvideAccessibleName(child));
+};
+const hasNegativeStaticTabIndex = (openingElement) => {
+	const tabIndexAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "tabIndex");
+	if (!tabIndexAttribute?.value) return false;
+	const tabIndexValue = parseJsxValue(tabIndexAttribute.value);
+	return tabIndexValue !== null && tabIndexValue < 0;
+};
+const isHiddenSubtreeRoot = (openingElement, settings) => isHiddenFromScreenReader(openingElement, settings) || hasPotentiallyTruthyAttribute(openingElement, "hidden");
+const isKeyboardActivatableElement = (element, requiresAccessibleName) => {
+	const openingElement = element.openingElement;
+	const elementName = flattenJsxName$1(openingElement.name);
+	if (!elementName) return false;
+	if (HTML_TAGS.has(elementName)) {
+		if (!NATIVE_KEYBOARD_ACTIVATABLE_TAGS.has(elementName)) return false;
+	} else if (requiresAccessibleName) {
+		if (!UPPERCASE_COMPONENT_NAME_PATTERN.test(elementName) || !EQUIVALENT_ACTION_COMPONENT_NAME_PATTERN.test(elementName)) return false;
+	} else if (!UPPERCASE_COMPONENT_NAME_PATTERN.test(elementName) || !KEYBOARD_ACTIVATABLE_COMPONENT_NAME_PATTERN.test(elementName)) return false;
+	if (!requiresAccessibleName) return true;
+	if (elementName === "a" && !hasJsxPropIgnoreCase(openingElement.attributes, "href")) return false;
+	if (hasPotentiallyTruthyAttribute(openingElement, "disabled") || hasPotentiallyTruthyAttribute(openingElement, "isDisabled") || hasPotentiallyTruthyAttribute(openingElement, "aria-disabled") || hasNegativeStaticTabIndex(openingElement)) return false;
+	return hasAccessibleNameEvidence(element);
+};
+const findKeyboardActivatableDescendant = (node, expectedAction, scopes, settings) => {
+	const walk = (descendant) => findKeyboardActivatableDescendant(descendant, expectedAction, scopes, settings);
+	if (isNodeOfType(node, "JSXElement")) {
+		if (expectedAction && isHiddenSubtreeRoot(node.openingElement, settings)) return false;
+		if (isKeyboardActivatableElement(node, expectedAction !== null)) {
+			if (!expectedAction) return true;
+			for (const actionPropName of DESCENDANT_ACTION_PROP_NAMES) {
+				const attribute = hasJsxPropIgnoreCase(node.openingElement.attributes, actionPropName);
+				const action = attribute ? getAttributeAction(attribute, scopes) : null;
+				if (action && areExpressionsStructurallyEqual(expectedAction, action)) return true;
+			}
+		}
+		return node.children.some((child) => walk(child));
+	}
+	if (isNodeOfType(node, "JSXFragment")) return node.children.some((child) => walk(child));
+	if (!expectedAction) return false;
+	if (isNodeOfType(node, "JSXExpressionContainer")) return walk(node.expression);
+	if (isNodeOfType(node, "LogicalExpression")) return walk(node.left) || walk(node.right);
+	if (isNodeOfType(node, "ConditionalExpression")) return walk(node.consequent) || walk(node.alternate);
+	return false;
+};
+const hasKeyboardActivatableDescendant = (element, interactionAttribute, scopes, settings) => {
+	if (!element || !isNodeOfType(element, "JSXElement")) return false;
+	const expectedAction = interactionAttribute ? getAttributeAction(interactionAttribute, scopes) : null;
+	if (interactionAttribute && !expectedAction) return false;
+	return element.children.some((child) => findKeyboardActivatableDescendant(child, expectedAction, scopes, settings));
+};
+//#endregion
 //#region src/plugin/utils/is-presentation-role.ts
 const isPresentationRole = (openingElement) => {
 	const roleAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "role");
@@ -6012,6 +6176,53 @@ const isPresentationRole = (openingElement) => {
 	return value !== null && PRESENTATION_ROLES$1.has(value);
 };
 //#endregion
+//#region src/plugin/utils/get-property-key-name.ts
+const getPropertyKeyName$2 = (propertyKey) => {
+	if (isNodeOfType(propertyKey, "Identifier") || isNodeOfType(propertyKey, "PrivateIdentifier")) return propertyKey.name;
+};
+//#endregion
+//#region src/plugin/utils/resolve-member-handler-function.ts
+const asHandlerFunction = (value) => {
+	if (isNodeOfType(value, "FunctionExpression") || isNodeOfType(value, "ArrowFunctionExpression")) return value;
+};
+const resolveFromClassBody = (classBody, propertyName) => {
+	for (const classElement of classBody.body) {
+		if (!isNodeOfType(classElement, "MethodDefinition") && !isNodeOfType(classElement, "PropertyDefinition")) continue;
+		if (getPropertyKeyName$2(classElement.key) !== propertyName) continue;
+		const resolvedHandler = asHandlerFunction(classElement.value);
+		if (resolvedHandler) return resolvedHandler;
+	}
+};
+const resolveFromObjectExpression = (objectExpression, propertyName) => {
+	for (const objectProperty of objectExpression.properties) {
+		if (!isNodeOfType(objectProperty, "Property")) continue;
+		if (getPropertyKeyName$2(objectProperty.key) !== propertyName) continue;
+		const resolvedHandler = asHandlerFunction(objectProperty.value);
+		if (resolvedHandler) return resolvedHandler;
+	}
+};
+const resolveMemberHandlerFunction = (handler) => {
+	const propertyName = getPropertyKeyName$2(handler.property);
+	if (propertyName === void 0) return void 0;
+	const objectNode = handler.object;
+	if (isNodeOfType(objectNode, "ThisExpression")) {
+		let ancestor = handler.parent;
+		while (ancestor) {
+			if (isNodeOfType(ancestor, "ClassBody")) return resolveFromClassBody(ancestor, propertyName);
+			if (isNodeOfType(ancestor, "ObjectExpression")) {
+				const resolvedHandler = resolveFromObjectExpression(ancestor, propertyName);
+				if (resolvedHandler) return resolvedHandler;
+			}
+			ancestor = ancestor.parent;
+		}
+		return;
+	}
+	if (isNodeOfType(objectNode, "Identifier")) {
+		const binding = findVariableInitializer(objectNode, objectNode.name);
+		if (isNodeOfType(binding?.initializer, "ObjectExpression")) return resolveFromObjectExpression(binding.initializer, propertyName);
+	}
+};
+//#endregion
 //#region src/plugin/utils/is-pure-event-blocker-handler.ts
 const BLOCKER_METHOD_NAMES = new Set([
 	"stopPropagation",
@@ -6043,9 +6254,10 @@ const isPureEventBlockerBody = (body) => {
 };
 const isPureEventBlockerHandler = (attribute) => {
 	if (!attribute.value || !isNodeOfType(attribute.value, "JSXExpressionContainer")) return false;
-	const expression = attribute.value.expression;
+	const expression = stripParenExpression(attribute.value.expression);
 	if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression")) return isPureEventBlockerBody(expression.body);
-	return false;
+	if (!isNodeOfType(expression, "MemberExpression")) return false;
+	return isPureEventBlockerBody(resolveMemberHandlerFunction(expression)?.body);
 };
 //#endregion
 //#region src/plugin/rules/a11y/click-events-have-key-events.ts
@@ -6197,29 +6409,6 @@ const hasCompositeItemRole = (node) => {
 	const firstRole = roleValue.value.split(/\s+/)[0];
 	return Boolean(firstRole && COMPOSITE_ITEM_ROLES$1.has(firstRole.toLowerCase()));
 };
-const NATIVE_ACTIVATABLE_TAGS = new Set([
-	"a",
-	"button",
-	"input",
-	"select",
-	"textarea",
-	"summary"
-]);
-const INTERACTIVE_COMPONENT_NAME_PATTERN = /button|link|nav|anchor/i;
-const containsKeyboardActivatableDescendant = (element) => {
-	if (!element || !isNodeOfType(element, "JSXElement")) return false;
-	for (const child of element.children) {
-		const childNode = child;
-		if (!isNodeOfType(childNode, "JSXElement")) continue;
-		const name = flattenJsxName$1(childNode.openingElement.name);
-		if (name) {
-			if (NATIVE_ACTIVATABLE_TAGS.has(name)) return true;
-			if (/^[A-Z]/.test(name) && INTERACTIVE_COMPONENT_NAME_PATTERN.test(name)) return true;
-		}
-		if (containsKeyboardActivatableDescendant(childNode)) return true;
-	}
-	return false;
-};
 const isTargetCurrentTargetComparison = (node) => {
 	if (!isNodeOfType(node, "BinaryExpression")) return false;
 	if (node.operator !== "===" && node.operator !== "==" && node.operator !== "!==") return false;
@@ -6276,7 +6465,8 @@ const clickEventsHaveKeyEvents = defineRule({
 			if (hasCompositeItemRole(node)) return;
 			if (isHoverSelectionListItem(tag, node)) return;
 			if (onClick && isBackdropDismissHandler(onClick)) return;
-			if (containsKeyboardActivatableDescendant(node.parent)) return;
+			if (hasKeyboardActivatableDescendant(node.parent, null, context.scopes, context.settings)) return;
+			if (onClick && hasKeyboardActivatableDescendant(node.parent, onClick, context.scopes, context.settings)) return;
 			if (isHiddenFromScreenReader(node, context.settings)) return;
 			if (isPresentationRole(node)) return;
 			if (KEY_HANDLERS.some((handler) => hasJsxPropIgnoreCase(node.attributes, handler) || spreadEventValues.has(handler.toLowerCase()))) return;
@@ -8159,50 +8349,6 @@ const assignedHandlerCallsPreventDefault = (scopeOwner, handlerName) => {
 	});
 	return didFindPreventDefault;
 };
-const asHandlerFunction = (value) => {
-	if (!value) return void 0;
-	if (isNodeOfType(value, "FunctionExpression") || isNodeOfType(value, "ArrowFunctionExpression")) return value;
-};
-const memberKeyName = (keyNode) => {
-	if (isNodeOfType(keyNode, "Identifier") || isNodeOfType(keyNode, "PrivateIdentifier")) return keyNode.name;
-};
-const resolveFromClassBody = (classBody, propertyName) => {
-	for (const element of classBody.body ?? []) {
-		if (!isNodeOfType(element, "MethodDefinition") && !isNodeOfType(element, "PropertyDefinition")) continue;
-		if (memberKeyName(element.key) !== propertyName) continue;
-		const resolved = asHandlerFunction(element.value);
-		if (resolved) return resolved;
-	}
-};
-const resolveFromObjectExpression = (objectExpression, propertyName) => {
-	for (const objectProperty of objectExpression.properties ?? []) {
-		if (!isNodeOfType(objectProperty, "Property")) continue;
-		if (memberKeyName(objectProperty.key) !== propertyName) continue;
-		const resolved = asHandlerFunction(objectProperty.value);
-		if (resolved) return resolved;
-	}
-};
-const resolveMemberHandlerFunction = (handler) => {
-	const propertyName = memberKeyName(handler.property);
-	if (propertyName === void 0) return void 0;
-	const objectNode = handler.object;
-	if (isNodeOfType(objectNode, "ThisExpression")) {
-		let ancestor = handler.parent;
-		while (ancestor) {
-			if (isNodeOfType(ancestor, "ClassBody")) return resolveFromClassBody(ancestor, propertyName);
-			if (isNodeOfType(ancestor, "ObjectExpression")) {
-				const resolved = resolveFromObjectExpression(ancestor, propertyName);
-				if (resolved) return resolved;
-			}
-			ancestor = ancestor.parent ?? null;
-		}
-		return;
-	}
-	if (isNodeOfType(objectNode, "Identifier")) {
-		const initializer = findVariableInitializer(objectNode, objectNode.name)?.initializer;
-		if (initializer && isNodeOfType(initializer, "ObjectExpression")) return resolveFromObjectExpression(initializer, propertyName);
-	}
-};
 const handlerArgumentCallsPreventDefault = (handler) => {
 	if (!handler) return false;
 	if (handlerCallsPreventDefault(handler)) return true;
@@ -8364,7 +8510,7 @@ const handlerMayExposeEvent = (handler, context) => {
 				}
 				const propertyName = getStaticPropertyName(expression);
 				if (isNodeOfType(memberObject, "ObjectExpression") && propertyName) {
-					const property = memberObject.properties.find((candidate) => isNodeOfType(candidate, "Property") && memberKeyName(candidate.key) === propertyName);
+					const property = memberObject.properties.find((candidate) => isNodeOfType(candidate, "Property") && getPropertyKeyName$2(candidate.key) === propertyName);
 					return Boolean(isNodeOfType(property, "Property") && expressionContainsParameterAlias(property.value));
 				}
 				if (isNodeOfType(memberObject, "ArrayExpression") && isNodeOfType(expression.property, "Literal") && typeof expression.property.value === "number") {
@@ -8405,9 +8551,9 @@ const handlerMayExposeEvent = (handler, context) => {
 						continue;
 					}
 					if (!isNodeOfType(patternProperty, "Property")) continue;
-					const propertyName = memberKeyName(patternProperty.key);
+					const propertyName = getPropertyKeyName$2(patternProperty.key);
 					if (!propertyName) continue;
-					const sourceProperty = source.properties.find((property) => isNodeOfType(property, "Property") && memberKeyName(property.key) === propertyName);
+					const sourceProperty = source.properties.find((property) => isNodeOfType(property, "Property") && getPropertyKeyName$2(property.key) === propertyName);
 					if (isNodeOfType(sourceProperty, "Property")) addAliasesFromPattern(patternProperty.value, sourceProperty.value);
 				}
 				return;
@@ -10279,21 +10425,29 @@ const isListenerPathAmbiguous = (node, bodyNode, allowAmbiguousChild) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/resolve-event-listener-capture.ts
-const resolveEventListenerCapture = (optionsNode) => {
+const resolveEventListenerCapture = (optionsNode, { allowComputedString = false, allowIndeterminateEntries = false } = {}) => {
 	if (!optionsNode) return false;
 	const unwrappedOptions = stripParenExpression(optionsNode);
 	if (isNodeOfType(unwrappedOptions, "Literal")) return typeof unwrappedOptions.value === "boolean" ? unwrappedOptions.value : null;
 	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) return null;
 	let capture = false;
-	for (const property of unwrappedOptions.properties) {
+	for (const property of unwrappedOptions.properties ?? []) {
+		if (allowIndeterminateEntries && isNodeOfType(property, "SpreadElement")) {
+			capture = null;
+			continue;
+		}
 		if (!isNodeOfType(property, "Property")) return null;
-		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString });
 		if (propertyName === null) return null;
 		if (!property.computed && propertyName === "__proto__") return null;
 		if (propertyName !== "capture") continue;
 		const propertyValue = stripParenExpression(property.value);
-		if (!isNodeOfType(propertyValue, "Literal") || typeof propertyValue.value !== "boolean") return null;
-		capture = propertyValue.value;
+		if (isNodeOfType(propertyValue, "Literal") && typeof propertyValue.value === "boolean") {
+			capture = propertyValue.value;
+			continue;
+		}
+		if (!allowIndeterminateEntries) return null;
+		capture = null;
 	}
 	return capture;
 };
@@ -10536,7 +10690,7 @@ const readListenerCandidate = (node, methodName, context) => {
 	const targetKey = resolveTargetKey(targetNode, context);
 	const eventName = resolveStaticEventName(node.arguments?.[0], context);
 	const callbackIdentity = resolveCallbackIdentity(node.arguments?.[1], context);
-	const capture = resolveEventListenerCapture(node.arguments?.[2]);
+	const capture = resolveEventListenerCapture(node.arguments?.[2], { allowComputedString: true });
 	if (targetKey === null || eventName === null) return null;
 	return {
 		node,
@@ -10570,7 +10724,7 @@ const readDestructuredRemovalCandidate = (node, context) => {
 		targetKey,
 		eventName,
 		callbackIdentity: resolveCallbackIdentity(node.arguments?.[2], context),
-		capture: resolveEventListenerCapture(node.arguments?.[3])
+		capture: resolveEventListenerCapture(node.arguments?.[3], { allowComputedString: true })
 	};
 };
 const resolveReturnedCleanupBody = (returnedValue, context) => {
@@ -10948,7 +11102,7 @@ const findDeclaratorForBinding = (bindingIdentifier) => {
 };
 //#endregion
 //#region src/plugin/utils/executes-during-render.ts
-const SYNCHRONOUS_ITERATION_METHOD_NAMES$1 = new Set([
+const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
 	"map",
 	"filter",
 	"forEach",
@@ -10984,7 +11138,7 @@ const executesDuringRender = (functionNode, scopes) => {
 	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;
+	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-render-phase-component-or-hook.ts
@@ -11015,6 +11169,26 @@ const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(
 //#region src/plugin/utils/is-event-handler-attribute.ts
 const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
 //#endregion
+//#region src/plugin/utils/react-ref-origin.ts
+const resolveReactRefSymbol = (memberExpression, scopes) => {
+	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
+	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticPropertyName(memberExpression) !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(receiver, scopes);
+	if (!symbol?.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	if (!isNodeOfType(initializer, "CallExpression")) return null;
+	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
+};
+const hasReactRefCurrentOrigin = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (resolveReactRefSymbol(expression, scopes)) return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = resolveConstIdentifierAlias(expression, scopes);
+	if (!symbol?.initializer || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return hasReactRefCurrentOrigin(symbol.initializer, scopes, visitedSymbolIds);
+};
+//#endregion
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
 	if (!node || typeof node !== "object") return;
@@ -11051,6 +11225,7 @@ const isCleanupReturningSubscribeLikeCallExpression = (node) => {
 //#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 REPLAYABLE_ITERATOR_COLLECTION_CACHE = /* @__PURE__ */ new WeakMap();
 const RESOURCE_NOUN_BY_KIND = {
 	subscribe: "subscription",
 	timer: "timer",
@@ -11280,9 +11455,108 @@ const removeSynchronouslyReleasedUsages = (callback, usages, context) => {
 		return !doMatchingNodesCoverEveryPathAfterUsage(usage.node, matchingReleaseCalls, context);
 	});
 };
+const findForOfStatementForIteratorExpression = (expression, context) => {
+	if (!expression) return null;
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(unwrappedExpression);
+	const bindingDeclarator = symbol?.bindingIdentifier.parent;
+	const bindingDeclaration = bindingDeclarator?.parent;
+	const forOfStatement = bindingDeclaration?.parent;
+	const isStableIteratorBinding = isNodeOfType(bindingDeclaration, "VariableDeclaration") && symbol?.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier));
+	return symbol && isNodeOfType(bindingDeclarator, "VariableDeclarator") && bindingDeclarator.id === symbol.bindingIdentifier && isStableIteratorBinding && bindingDeclaration.declarations.length === 1 && isNodeOfType(forOfStatement, "ForOfStatement") && forOfStatement.left === bindingDeclaration && forOfStatement.await !== true ? forOfStatement : null;
+};
+const isAssignmentFormForOfIteratorReference = (expression, context) => {
+	if (!expression) return false;
+	const unwrappedExpression = stripParenExpression(expression);
+	const referencedSymbolIds = /* @__PURE__ */ new Set();
+	walkAst(unwrappedExpression, (expressionChild) => {
+		if (!isNodeOfType(expressionChild, "Identifier")) return;
+		const symbol = context.scopes.symbolFor(expressionChild);
+		if (symbol) referencedSymbolIds.add(symbol.id);
+	});
+	if (referencedSymbolIds.size === 0) return false;
+	const assignsReferencedSymbol = (root, requireAssignmentTarget) => {
+		let didAssignReferencedSymbol = false;
+		walkAst(root, (child) => {
+			if (!isNodeOfType(child, "Identifier")) return;
+			if (requireAssignmentTarget && !isWithinAssignmentTarget(child)) return;
+			const childSymbol = context.scopes.symbolFor(child);
+			if (childSymbol && referencedSymbolIds.has(childSymbol.id)) {
+				didAssignReferencedSymbol = true;
+				return false;
+			}
+		});
+		return didAssignReferencedSymbol;
+	};
+	let currentNode = unwrappedExpression.parent;
+	while (currentNode && !isFunctionLike$2(currentNode)) {
+		if (isNodeOfType(currentNode, "ForOfStatement")) {
+			const loopTarget = stripParenExpression(currentNode.left);
+			if (!isNodeOfType(loopTarget, "VariableDeclaration") && (assignsReferencedSymbol(loopTarget, false) || assignsReferencedSymbol(currentNode.body, true))) return true;
+		}
+		currentNode = currentNode.parent;
+	}
+	return false;
+};
+const isPrivatePlainConstIdentifier = (identifier, context) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const symbol = context.scopes.symbolFor(identifier);
+	if (!symbol || symbol.kind !== "const" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return false;
+	return !isNodeOfType(symbol.declarationNode.parent?.parent, "ExportNamedDeclaration") && !isNodeOfType(symbol.declarationNode.parent?.parent, "ExportDefaultDeclaration");
+};
+const hasOnlyReplayableCollectionReferences = (identifier, context, visitedSymbolIds) => {
+	if (!isNodeOfType(identifier, "Identifier") || !isPrivatePlainConstIdentifier(identifier, context)) return false;
+	const symbol = context.scopes.symbolFor(identifier);
+	if (!symbol) return false;
+	if (visitedSymbolIds.has(symbol.id)) return true;
+	visitedSymbolIds.add(symbol.id);
+	return symbol.references.every((reference) => {
+		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+		const parent = referenceRoot.parent;
+		if (isNodeOfType(parent, "ForOfStatement") && parent.right === referenceRoot) return true;
+		if (isNodeOfType(parent, "VariableDeclarator") && parent.init === referenceRoot) {
+			const declaration = parent.parent;
+			return isNodeOfType(parent.id, "Identifier") && isNodeOfType(declaration, "VariableDeclaration") && declaration.kind === "const" ? hasOnlyReplayableCollectionReferences(parent.id, context, visitedSymbolIds) : false;
+		}
+		return false;
+	});
+};
+const resolveReplayableIteratorCollectionKeyUncached = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!expression) return null;
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "Identifier") || !isPrivatePlainConstIdentifier(unwrappedExpression, context)) return null;
+	const symbol = context.scopes.symbolFor(unwrappedExpression);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return null;
+	visitedSymbolIds.add(symbol.id);
+	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
+	if (isNodeOfType(initializer, "ArrayExpression")) return (initializer.elements ?? []).every((element) => element === null || isNodeOfType(element, "Literal") && (element.value === null || typeof element.value === "boolean" || typeof element.value === "number" || typeof element.value === "string")) && hasOnlyReplayableCollectionReferences(symbol.bindingIdentifier, context, /* @__PURE__ */ new Set()) ? `symbol:${symbol.id}` : null;
+	if (!isNodeOfType(initializer, "Identifier")) return null;
+	return resolveReplayableIteratorCollectionKeyUncached(initializer, context, visitedSymbolIds);
+};
+const resolveReplayableIteratorCollectionKey = (expression, context) => {
+	if (!expression) return null;
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(unwrappedExpression);
+	if (!symbol) return null;
+	let contextCache = REPLAYABLE_ITERATOR_COLLECTION_CACHE.get(context);
+	if (!contextCache) {
+		contextCache = /* @__PURE__ */ new Map();
+		REPLAYABLE_ITERATOR_COLLECTION_CACHE.set(context, contextCache);
+	}
+	if (contextCache.has(symbol.id)) return contextCache.get(symbol.id) ?? null;
+	const collectionKey = resolveReplayableIteratorCollectionKeyUncached(expression, context);
+	contextCache.set(symbol.id, collectionKey);
+	return collectionKey;
+};
 const resolveIteratorCollectionKey = (expression, context) => {
-	if (!expression || !isNodeOfType(expression, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(expression);
+	if (!expression) return null;
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
+	const forOfStatement = findForOfStatementForIteratorExpression(unwrappedExpression, context);
+	if (forOfStatement) return resolveReplayableIteratorCollectionKey(forOfStatement.right, context);
+	const symbol = context.scopes.symbolFor(unwrappedExpression);
 	if (!symbol || symbol.kind !== "parameter") return null;
 	let callbackNode = symbol.bindingIdentifier.parent;
 	while (callbackNode && !isFunctionLike$2(callbackNode)) callbackNode = callbackNode.parent;
@@ -11296,6 +11570,34 @@ const resolveIteratorCollectionKey = (expression, context) => {
 	}
 	return null;
 };
+const isStableLoopReceiver = (expression, context) => {
+	if (!expression) return false;
+	const unwrappedExpression = stripParenExpression(expression);
+	return isNodeOfType(unwrappedExpression, "Identifier") && unwrappedExpression.name === "document" && context.scopes.isGlobalReference(unwrappedExpression);
+};
+const resolveStableLoopHandlerSymbolId = (expression, context) => {
+	if (!expression) return null;
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(unwrappedExpression);
+	if (!symbol || symbol.kind !== "const" && symbol.kind !== "function" && symbol.kind !== "parameter" || !symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier))) return null;
+	return symbol.id;
+};
+const isDirectExhaustiveForOfRelease = (releaseNode, forOfStatement) => {
+	const releaseStatement = findTransparentExpressionRoot(releaseNode).parent;
+	if (!isNodeOfType(releaseStatement, "ExpressionStatement")) return false;
+	if (!(isNodeOfType(forOfStatement.body, "BlockStatement") ? releaseStatement.parent === forOfStatement.body : releaseStatement === forOfStatement.body)) return false;
+	let hasAbruptLoopExit = false;
+	walkAst(forOfStatement.body, (child) => {
+		if (hasAbruptLoopExit) return false;
+		if (child !== forOfStatement.body && isFunctionLike$2(child)) return false;
+		if (isNodeOfType(child, "BreakStatement") || isNodeOfType(child, "ContinueStatement") || isNodeOfType(child, "ReturnStatement") || isNodeOfType(child, "ThrowStatement")) {
+			hasAbruptLoopExit = true;
+			return false;
+		}
+	});
+	return !hasAbruptLoopExit;
+};
 const findCollectionMappingCall = (callbackNode) => {
 	if (!isNodeOfType(callbackNode, "ArrowFunctionExpression") && !isNodeOfType(callbackNode, "FunctionExpression") || callbackNode.async || callbackNode.generator) return null;
 	const callNode = callbackNode.parent;
@@ -11443,23 +11745,26 @@ const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visite
 	if (!isFunctionLike$2(cleanupFunction) || visitedFunctions.has(cleanupFunction)) return false;
 	visitedFunctions.add(cleanupFunction);
 	let didCleanupFunctionMatch = false;
+	const matchingLoopOrHelperAnchors = [];
 	walkAst(cleanupFunction.body, (cleanupChild) => {
 		if (didCleanupFunctionMatch) return false;
 		if (cleanupChild !== cleanupFunction.body && isFunctionLike$2(cleanupChild) && !isSynchronousIteratorCallback(cleanupChild)) return false;
+		const cleanupCall = isNodeOfType(cleanupChild, "ChainExpression") ? cleanupChild.expression : cleanupChild;
 		if (doesReleaseCallMatchUsage(cleanupChild, usage, context)) {
-			didCleanupFunctionMatch = true;
-			return false;
+			const cleanupForOfStatement = findForOfStatementForIteratorExpression(isNodeOfType(cleanupCall, "CallExpression") ? cleanupCall.arguments?.[0] : null, context);
+			if (!cleanupForOfStatement) {
+				didCleanupFunctionMatch = true;
+				return false;
+			}
+			if (!cleanupFunction.async && !cleanupFunction.generator && isDirectExhaustiveForOfRelease(cleanupChild, cleanupForOfStatement)) matchingLoopOrHelperAnchors.push(cleanupForOfStatement);
+			return;
 		}
-		const helperCall = isNodeOfType(cleanupChild, "ChainExpression") ? cleanupChild.expression : cleanupChild;
-		if (!isNodeOfType(helperCall, "CallExpression")) return;
-		const stableHelperFunction = resolveStableValue(helperCall.callee, context);
+		if (!isNodeOfType(cleanupCall, "CallExpression")) return;
+		const stableHelperFunction = resolveStableValue(cleanupCall.callee, context);
 		const helperFunction = isNodeOfType(stableHelperFunction, "Identifier") ? resolveSingleAssignedCleanupFunction(stableHelperFunction, usage, context) : stableHelperFunction;
-		if (helperFunction && isFunctionLike$2(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context, visitedFunctions)) {
-			didCleanupFunctionMatch = true;
-			return false;
-		}
+		if (helperFunction && isFunctionLike$2(helperFunction) && !helperFunction.async && !helperFunction.generator && doesCleanupFunctionReleaseUsage(helperFunction, usage, context, new Set(visitedFunctions))) matchingLoopOrHelperAnchors.push(cleanupCall);
 	});
-	return didCleanupFunctionMatch;
+	return didCleanupFunctionMatch || doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, matchingLoopOrHelperAnchors, context);
 };
 const doesBoundCleanupReleaseUsage = (expression, usage, context) => {
 	const callExpression = stripParenExpression(expression);
@@ -11476,6 +11781,7 @@ const doesBoundCleanupReleaseUsage = (expression, usage, context) => {
 };
 const callbackReturnsCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
+	if (callback.async) return false;
 	const doesReturnedValueReleaseUsage = (returnedValue) => {
 		if (doesBoundCleanupReleaseUsage(returnedValue, usage, context)) return true;
 		const cleanupFunction = resolveStableValue(returnedValue, context);
@@ -11540,6 +11846,7 @@ const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 const hasSplitLifecycleCleanup = (callback, usage, context) => usage.handleKey !== null && hasRerunReleaseBeforeUsage(callback, usage, context) && hasStableUnmountCleanupForUsage(callback, usage, context);
 const effectHasCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
+	if (callback.async) 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 = [];
@@ -11663,10 +11970,29 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	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(callNode.arguments?.[0], context);
+	const usageEventArgument = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[0] : null;
+	const releaseEventArgument = callNode.arguments?.[0];
+	if (isAssignmentFormForOfIteratorReference(usageEventArgument, context) || isAssignmentFormForOfIteratorReference(releaseEventArgument, context)) return false;
 	if (usage.eventKey !== null && releaseEventKey !== null && usage.eventKey !== releaseEventKey) {
-		const usageIteratorCollectionKey = isNodeOfType(usage.node, "CallExpression") ? resolveIteratorCollectionKey(usage.node.arguments?.[0], context) : null;
+		if (!isNodeOfType(usage.node, "CallExpression")) return false;
+		const usageForOfStatement = findForOfStatementForIteratorExpression(usageEventArgument, context);
+		const releaseForOfStatement = findForOfStatementForIteratorExpression(releaseEventArgument, context);
+		if (usageForOfStatement === null !== (releaseForOfStatement === null)) return false;
+		const usageIteratorCollectionKey = resolveIteratorCollectionKey(usage.node.arguments?.[0], context);
 		const releaseIteratorCollectionKey = resolveIteratorCollectionKey(callNode.arguments?.[0], context);
 		if (usageIteratorCollectionKey === null || usageIteratorCollectionKey !== releaseIteratorCollectionKey) return false;
+		if (usageForOfStatement && releaseForOfStatement) {
+			const registrationHandlerSymbolId = resolveStableLoopHandlerSymbolId(usage.node.arguments?.[1], context);
+			const releaseHandlerSymbolId = resolveStableLoopHandlerSymbolId(callNode.arguments?.[1], context);
+			if (usage.registrationVerbName !== "addEventListener" || releaseVerbName !== "removeEventListener") return false;
+			const registrationCallee = stripParenExpression(usage.node.callee);
+			if (!isNodeOfType(registrationCallee, "MemberExpression")) return false;
+			if (!isStableLoopReceiver(registrationCallee.object, context) || !isStableLoopReceiver(callee.object, context) || registrationHandlerSymbolId === null || registrationHandlerSymbolId !== releaseHandlerSymbolId) return false;
+			const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
+			const releaseCapture = resolveEventListenerCapture(callNode.arguments?.[2], { allowIndeterminateEntries: true });
+			if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
+			if (!isDirectExhaustiveForOfRelease(callNode, releaseForOfStatement)) return false;
+		}
 	}
 	if (releaseVerbName === "on") {
 		const handlerArgument = callNode.arguments?.[1];
@@ -11721,6 +12047,213 @@ const fileContainsReleaseForUsage = (usage, context) => {
 	});
 	return didFindRelease;
 };
+const resolveRefOwnedCleanupFunction = (expression, context) => {
+	const resolvedExpression = resolveStableValue(expression, context);
+	if (isFunctionLike$2(resolvedExpression)) return resolvedExpression;
+	if (!isNodeOfType(resolvedExpression, "CallExpression") || !isReactApiCall(resolvedExpression, "useCallback", context.scopes)) return null;
+	return getEffectCallback(resolvedExpression);
+};
+const findRefOwnedHandlerStorage = (retainedFunction, usage, context) => {
+	if (!isFunctionLike$2(retainedFunction) || usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.handlerKey === null || !usage.receiverKey?.startsWith("global:") || !usage.eventKey?.startsWith("literal:")) return null;
+	const usageStart = getRangeStart(usage.node);
+	const functionCfg = context.cfg.cfgFor(retainedFunction);
+	const usageBlock = functionCfg?.blockOf(usage.node);
+	if (usageStart === null || !functionCfg || !usageBlock) return null;
+	const matchingStorage = [];
+	walkAst(retainedFunction.body, (child) => {
+		if (child !== retainedFunction.body && isFunctionLike$2(child)) return false;
+		if (!isNodeOfType(child, "AssignmentExpression") || child.operator !== "=") return;
+		const assignmentStart = getRangeStart(child);
+		const refCurrentExpression = stripParenExpression(child.left);
+		if (assignmentStart === null || assignmentStart >= usageStart || functionCfg.blockOf(child) !== usageBlock || !isNodeOfType(refCurrentExpression, "MemberExpression") || !resolveReactRefSymbol(refCurrentExpression, context.scopes)) return;
+		const refCurrentKey = resolveExpressionKey(refCurrentExpression, context);
+		const refKey = resolveExpressionKey(refCurrentExpression.object, context);
+		const storedSession = stripParenExpression(child.right);
+		if (!refCurrentKey || !refKey || !isNodeOfType(storedSession, "ObjectExpression")) return;
+		const storedSessionProperties = storedSession.properties ?? [];
+		if (storedSessionProperties.some((property) => !isNodeOfType(property, "Property"))) return;
+		for (const property of storedSessionProperties) {
+			if (!isNodeOfType(property, "Property")) continue;
+			const propertyName = getStaticPropertyKeyName(property);
+			if (propertyName && resolveExpressionKey(property.value, context) === usage.handlerKey) {
+				const handlerKey = `${refCurrentKey}.${propertyName}`;
+				matchingStorage.push({
+					handlerKey,
+					refCurrentKey,
+					refKey,
+					assignmentNode: child
+				});
+			}
+		}
+	});
+	return matchingStorage.length === 1 ? matchingStorage[0] : null;
+};
+const doMatchingNodesCoverEveryPathBeforeUsage = (usageNode, matchingNodes, owner, context) => {
+	const functionCfg = context.cfg.cfgFor(owner);
+	const usageBlock = functionCfg?.blockOf(usageNode);
+	const usageStart = getRangeStart(usageNode);
+	if (!functionCfg || !usageBlock || usageStart === null) return false;
+	const matchingBlocks = new Set(matchingNodes.flatMap((matchingNode) => {
+		if (context.cfg.enclosingFunction(matchingNode) !== owner) return [];
+		const matchingStart = getRangeStart(matchingNode);
+		if (matchingStart === null || matchingStart >= usageStart) return [];
+		const matchingBlock = functionCfg.blockOf(matchingNode);
+		return matchingBlock ? [matchingBlock] : [];
+	}));
+	if (matchingBlocks.size === 0) return false;
+	if (matchingBlocks.has(usageBlock)) return true;
+	const visitedBlocks = new Set([functionCfg.entry]);
+	const pendingBlocks = [functionCfg.entry];
+	while (pendingBlocks.length > 0) {
+		const currentBlock = pendingBlocks.pop();
+		if (!currentBlock) break;
+		if (matchingBlocks.has(currentBlock)) continue;
+		if (currentBlock === usageBlock) return false;
+		for (const edge of currentBlock.successors) {
+			if (visitedBlocks.has(edge.to)) continue;
+			visitedBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return true;
+};
+const retainedFunctionReleasesPreviousRefOwnedUsage = (retainedFunction, cleanupFunction, storageNode, context) => {
+	if (!isFunctionLike$2(retainedFunction)) return false;
+	const retainedFunctionBody = retainedFunction.body;
+	const cleanupCalls = [];
+	walkAst(retainedFunctionBody, (child) => {
+		if (child !== retainedFunctionBody && isFunctionLike$2(child)) return false;
+		if (isNodeOfType(child, "CallExpression") && resolveRefOwnedCleanupFunction(child.callee, context) === cleanupFunction) cleanupCalls.push(child);
+	});
+	return doMatchingNodesCoverEveryPathBeforeUsage(storageNode, cleanupCalls, retainedFunction, context);
+};
+const isDirectRefOwnedRelease = (releaseNode, cleanupFunction, usage, storedHandlerKey, refCurrentKey, context) => {
+	if (!isFunctionLike$2(cleanupFunction)) return false;
+	const releaseCall = isNodeOfType(releaseNode, "ChainExpression") ? releaseNode.expression : releaseNode;
+	if (!isNodeOfType(releaseCall, "CallExpression") || !isNodeOfType(releaseCall.callee, "MemberExpression") || releaseCall.callee.computed || !isNodeOfType(releaseCall.callee.property, "Identifier") || releaseCall.callee.property.name !== "removeEventListener" || !isNodeOfType(usage.node, "CallExpression") || usage.node.arguments?.[2] !== void 0 || releaseCall.arguments?.[2] !== void 0) return false;
+	const releaseStatement = findTransparentExpressionRoot(releaseNode).parent;
+	const releaseBlock = releaseStatement?.parent;
+	const releaseGuard = releaseBlock?.parent;
+	const isDirectCleanupStatement = releaseBlock === cleanupFunction.body;
+	const isRefPresenceGuardedStatement = Boolean(isNodeOfType(releaseBlock, "BlockStatement") && isNodeOfType(releaseGuard, "IfStatement") && releaseGuard.consequent === releaseBlock && releaseGuard.alternate === null && resolveExpressionKey(releaseGuard.test, context) === refCurrentKey);
+	if (!isNodeOfType(releaseStatement, "ExpressionStatement") || !isNodeOfType(cleanupFunction.body, "BlockStatement") || !isDirectCleanupStatement && !isRefPresenceGuardedStatement) return false;
+	return usage.receiverKey !== null && usage.receiverKey === resolveExpressionKey(releaseCall.callee.object, context) && usage.eventKey !== null && usage.eventKey === resolveExpressionKey(releaseCall.arguments?.[0], context) && resolveExpressionKey(releaseCall.arguments?.[1], context) === storedHandlerKey;
+};
+const isRefPresenceGuardedEarlyReturn = (returnStatement, refCurrentKey, context) => {
+	const returnBranch = returnStatement.parent;
+	const guardStatement = isNodeOfType(returnBranch, "BlockStatement") ? returnBranch.parent : returnBranch;
+	const guardedConsequent = isNodeOfType(returnBranch, "BlockStatement") ? returnBranch : returnStatement;
+	if (!isNodeOfType(guardStatement, "IfStatement") || guardStatement.consequent !== guardedConsequent || guardStatement.alternate !== null) return false;
+	const guardTest = stripParenExpression(guardStatement.test);
+	return isNodeOfType(guardTest, "UnaryExpression") && guardTest.operator === "!" && resolveExpressionKey(guardTest.argument, context) === refCurrentKey;
+};
+const hasUnprovenReturnBeforeRefOwnedRelease = (cleanupFunction, releaseNode, refCurrentKey, context) => {
+	if (!isFunctionLike$2(cleanupFunction)) return true;
+	const releaseStart = getRangeStart(releaseNode);
+	if (releaseStart === null) return true;
+	let hasUnprovenEarlyReturn = false;
+	walkAst(cleanupFunction.body, (child) => {
+		if (hasUnprovenEarlyReturn) return false;
+		if (child !== cleanupFunction.body && isFunctionLike$2(child)) return false;
+		if (!isNodeOfType(child, "ReturnStatement")) return;
+		const returnStart = getRangeStart(child);
+		if ((returnStart === null || returnStart < releaseStart) && !isRefPresenceGuardedEarlyReturn(child, refCurrentKey, context)) {
+			hasUnprovenEarlyReturn = true;
+			return false;
+		}
+	});
+	return hasUnprovenEarlyReturn;
+};
+const cleanupFunctionReleasesRefOwnedUsage = (cleanupFunction, componentFunction, retainedFunction, usage, context) => {
+	if (!isFunctionLike$2(cleanupFunction) || !isFunctionLike$2(componentFunction) || cleanupFunction.async || cleanupFunction.generator) return false;
+	const storage = findRefOwnedHandlerStorage(retainedFunction, usage, context);
+	if (!storage) return false;
+	if (!retainedFunctionReleasesPreviousRefOwnedUsage(retainedFunction, cleanupFunction, storage.assignmentNode, context)) return false;
+	let releaseNode = null;
+	walkAst(cleanupFunction.body, (child) => {
+		if (releaseNode) return false;
+		if (child !== cleanupFunction.body && isFunctionLike$2(child)) return false;
+		if (isDirectRefOwnedRelease(child, cleanupFunction, usage, storage.handlerKey, storage.refCurrentKey, context)) {
+			releaseNode = child;
+			return false;
+		}
+	});
+	if (!releaseNode) return false;
+	if (hasUnprovenReturnBeforeRefOwnedRelease(cleanupFunction, releaseNode, storage.refCurrentKey, context)) return false;
+	let hasUnsafeRefWrite = false;
+	walkAst(componentFunction.body, (child) => {
+		if (hasUnsafeRefWrite) return false;
+		if (isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
+			const deleteTarget = stripParenExpression(child.argument);
+			if (resolveExpressionKey(deleteTarget, context) === storage.handlerKey || isNodeOfType(deleteTarget, "MemberExpression") && resolveExpressionKey(deleteTarget.object, context) === storage.refCurrentKey) {
+				hasUnsafeRefWrite = true;
+				return false;
+			}
+			return;
+		}
+		if (isNodeOfType(child, "CallExpression")) {
+			if ((child.arguments ?? []).some((argumentNode) => {
+				const argumentKey = resolveExpressionKey(argumentNode, context);
+				return argumentKey !== null && (argumentKey === storage.refKey || argumentKey === storage.refCurrentKey);
+			})) {
+				hasUnsafeRefWrite = true;
+				return false;
+			}
+			return;
+		}
+		if (!isNodeOfType(child, "AssignmentExpression")) return;
+		const assignmentTarget = stripParenExpression(child.left);
+		if (isNodeOfType(assignmentTarget, "MemberExpression") && assignmentTarget.computed && resolveExpressionKey(assignmentTarget.object, context) === storage.refCurrentKey) {
+			hasUnsafeRefWrite = true;
+			return false;
+		}
+		const assignedKey = resolveExpressionKey(child.left, context);
+		if (assignedKey === storage.handlerKey) {
+			hasUnsafeRefWrite = true;
+			return false;
+		}
+		if (assignedKey !== storage.refCurrentKey) return;
+		const assignedValue = stripParenExpression(child.right);
+		if (isNodeOfType(assignedValue, "Literal") && assignedValue.value === null && findEnclosingFunction(child) === cleanupFunction) return;
+		const assignedSessionProperties = (isNodeOfType(assignedValue, "ObjectExpression") ? assignedValue : null)?.properties ?? [];
+		const storesMatchingHandler = assignedSessionProperties.every((property) => isNodeOfType(property, "Property")) && assignedSessionProperties.some((property) => isNodeOfType(property, "Property") && `${storage.refCurrentKey}.${getStaticPropertyKeyName(property) ?? ""}` === storage.handlerKey && resolveExpressionKey(property.value, context) === usage.handlerKey);
+		if (findEnclosingFunction(child) !== retainedFunction || !storesMatchingHandler) {
+			hasUnsafeRefWrite = true;
+			return false;
+		}
+	});
+	return !hasUnsafeRefWrite;
+};
+const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retainedFunction, usage, context) => {
+	const matchesReturnedCleanup = (returnedValue) => {
+		const cleanupFunction = resolveRefOwnedCleanupFunction(returnedValue, context);
+		return Boolean(cleanupFunction && cleanupFunctionReleasesRefOwnedUsage(cleanupFunction, componentFunction, retainedFunction, usage, context));
+	};
+	if (!isFunctionLike$2(effectCallback)) return false;
+	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return matchesReturnedCleanup(stripParenExpression(effectCallback.body));
+	const matchingReturns = [];
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (isNodeOfType(child, "ReturnStatement") && child.argument && matchesReturnedCleanup(stripParenExpression(child.argument))) matchingReturns.push(child);
+	});
+	return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+};
+const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) => {
+	const componentFunction = findEnclosingFunction(retainedFunction);
+	if (!componentFunction || !isFunctionLike$2(componentFunction)) return false;
+	let didFindCleanupEffect = false;
+	walkAst(componentFunction.body, (child) => {
+		if (didFindCleanupEffect) return false;
+		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
+		const effectStatement = findTransparentExpressionRoot(child).parent;
+		if (!isNodeOfType(effectStatement, "ExpressionStatement") || effectStatement.parent !== componentFunction.body) return;
+		const effectCallback = getEffectCallback(child);
+		if (effectCallback && effectReturnsRefOwnedCleanup(effectCallback, componentFunction, retainedFunction, usage, context)) {
+			didFindCleanupEffect = true;
+			return false;
+		}
+	});
+	return didFindCleanupEffect;
+};
 const isUseSyncExternalStoreSubscribeFunction = (functionNode, context) => {
 	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
 	if (!bindingIdentifier) return false;
@@ -11761,7 +12294,7 @@ const findRetainedFunctionLeak = (retainedFunction, context) => {
 	let leak = null;
 	const allowConciseReturnEscape = !isInlineRetainedHandlerFunction(retainedFunction, context);
 	const isExternalStoreSubscribeFunction = isUseSyncExternalStoreSubscribeFunction(retainedFunction, context);
-	const hasReleaseForUsage = (usage) => isExternalStoreSubscribeFunction ? effectHasCleanupForUsage(retainedFunction, usage, context) : fileContainsReleaseForUsage(usage, context);
+	const hasReleaseForUsage = (usage) => isExternalStoreSubscribeFunction ? effectHasCleanupForUsage(retainedFunction, usage, context) : fileContainsReleaseForUsage(usage, context) || hasGuaranteedRefOwnedUnmountCleanup(retainedFunction, usage, context);
 	walkAst(body, (child) => {
 		if (leak !== null) return false;
 		if (isFunctionLike$2(child)) return false;
@@ -12970,7 +13503,7 @@ const stringifyMemberChain = (node) => {
 	}
 	return null;
 };
-const collectCaptureDepKeys = (callback, scopes) => {
+const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys) => {
 	const keys = /* @__PURE__ */ new Set();
 	const stableCapturedNames = /* @__PURE__ */ new Set();
 	const moduleScopeCapturedNames = /* @__PURE__ */ new Set();
@@ -13000,6 +13533,10 @@ const collectCaptureDepKeys = (callback, scopes) => {
 			continue;
 		}
 		if (depKey === symbol.name) {
+			if (declaredExactBindingKeys?.has(depKey)) {
+				keys.add(depKey);
+				continue;
+			}
 			const identitySourceKeys = resolveReactiveIdentitySourceKeys(symbol, scopes);
 			if (identitySourceKeys) {
 				if (identitySourceKeys.size === 0) stableCapturedNames.add(depKey);
@@ -13108,13 +13645,13 @@ const isRegExpLiteral = (node) => {
 	if (!isNodeOfType(node, "Literal")) return false;
 	return Boolean(node.regex);
 };
-const isUnstableInitializer = (node) => {
+const isUnstableInitializer = (node, isNestedInitializer = false) => {
 	if (!node) return false;
 	const stripped = unwrapExpression$3(node);
 	if (isRegExpLiteral(stripped)) return true;
-	if (isNodeOfType(stripped, "ConditionalExpression")) return isUnstableInitializer(stripped.consequent) || isUnstableInitializer(stripped.alternate);
-	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left) || isUnstableInitializer(stripped.right);
-	return isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "ArrayExpression") || isNodeOfType(stripped, "ClassExpression") || isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment") || isNodeOfType(stripped, "AssignmentExpression") || isNodeOfType(stripped, "NewExpression");
+	if (isNodeOfType(stripped, "ConditionalExpression")) return isUnstableInitializer(stripped.consequent, true) || isUnstableInitializer(stripped.alternate, true);
+	if (isNodeOfType(stripped, "LogicalExpression")) return isUnstableInitializer(stripped.left, true) || isUnstableInitializer(stripped.right, true);
+	return isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "ArrayExpression") || isNestedInitializer && (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "FunctionExpression")) || isNodeOfType(stripped, "ClassExpression") || isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "JSXElement") || isNodeOfType(stripped, "JSXFragment") || isNodeOfType(stripped, "AssignmentExpression") || isNodeOfType(stripped, "NewExpression");
 };
 const isPotentiallyFreshComparedValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = unwrapExpression$3(node);
@@ -13567,8 +14104,6 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				});
 				return;
 			}
-			const { keys: captureKeys, stableCapturedNames, moduleScopeCapturedNames, outerFunctionCapturedNames } = collectCaptureDepKeys(callbackToAnalyze ?? callbackArgument, context.scopes);
-			for (const forcedCaptureKey of forcedCaptureKeys) captureKeys.add(forcedCaptureKey);
 			const hasLiteralDepElement = depsArgument.elements.some((element) => {
 				if (!element) return false;
 				return isLiteralOrEmptyTemplate(unwrapExpression$3(element));
@@ -13582,6 +14117,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				message: buildLiteralDepMessage(hookName)
 			});
 			const declaredKeys = /* @__PURE__ */ new Set();
+			const declaredExactBindingKeys = /* @__PURE__ */ new Set();
 			const declaredKeyToReportNode = /* @__PURE__ */ new Map();
 			const seenDeclaredKeys = /* @__PURE__ */ new Set();
 			let didReportRefCurrentDep = false;
@@ -13647,8 +14183,11 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				}
 				seenDeclaredKeys.add(key);
 				declaredKeys.add(key);
+				if (isNodeOfType(stripped, "Identifier")) declaredExactBindingKeys.add(key);
 				declaredKeyToReportNode.set(key, elementNode);
 			}
+			const { keys: captureKeys, stableCapturedNames, moduleScopeCapturedNames, outerFunctionCapturedNames } = collectCaptureDepKeys(callbackToAnalyze ?? callbackArgument, context.scopes, declaredExactBindingKeys);
+			for (const forcedCaptureKey of forcedCaptureKeys) captureKeys.add(forcedCaptureKey);
 			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument, context.scopes);
 			const missingCaptureKeys = [];
 			for (const captureKey of captureKeys) {
@@ -15646,7 +16185,7 @@ const jotaiTqUseRawQueryAtom = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/js-async-reduce-without-awaited-acc.ts
-const isAsyncFunctionLike$1 = (node) => {
+const isAsyncFunctionLike = (node) => {
 	if (!node) return false;
 	if (!isNodeOfType(node, "ArrowFunctionExpression") && !isNodeOfType(node, "FunctionExpression")) return false;
 	return node.async === true;
@@ -15713,7 +16252,7 @@ const jsAsyncReduceWithoutAwaitedAcc = defineRule({
 		const args = node.arguments ?? [];
 		if (args.length === 0) return;
 		const reducerCandidate = stripParenExpression(args[0]);
-		if (!isAsyncFunctionLike$1(reducerCandidate)) return;
+		if (!isAsyncFunctionLike(reducerCandidate)) return;
 		const reducer = reducerCandidate;
 		if (!containsDirectAwait(reducer.body)) return;
 		const firstParameter = classifyFirstParameter(reducer);
@@ -16997,30 +17536,6 @@ const jsIndexMaps = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/are-expressions-structurally-equal.ts
-const areExpressionsStructurallyEqual = (a, b) => {
-	if (!a || !b) return a === b;
-	const unwrappedA = stripParenExpression(a);
-	const unwrappedB = stripParenExpression(b);
-	if (unwrappedA !== a || unwrappedB !== b) return areExpressionsStructurallyEqual(unwrappedA, unwrappedB);
-	if (a.type !== b.type) return false;
-	if (isNodeOfType(a, "ThisExpression")) return true;
-	if (isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier")) return a.name === b.name;
-	if (isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal")) return a.value === b.value;
-	if (isNodeOfType(a, "MemberExpression") && isNodeOfType(b, "MemberExpression")) {
-		if (a.computed !== b.computed) return false;
-		return areExpressionsStructurallyEqual(a.object, b.object) && areExpressionsStructurallyEqual(a.property, b.property);
-	}
-	if (isNodeOfType(a, "CallExpression") && isNodeOfType(b, "CallExpression")) {
-		if (!areExpressionsStructurallyEqual(a.callee, b.callee)) return false;
-		const argumentsA = a.arguments ?? [];
-		const argumentsB = b.arguments ?? [];
-		if (argumentsA.length !== argumentsB.length) return false;
-		return argumentsA.every((argument, index) => areExpressionsStructurallyEqual(argument, argumentsB[index]));
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/utils/flatten-logical-and-chain.ts
 const flattenLogicalAndChain = (node) => {
 	if (isNodeOfType(node, "LogicalExpression") && node.operator === "&&") return [...flattenLogicalAndChain(node.left), ...flattenLogicalAndChain(node.right)];
@@ -28299,271 +28814,21 @@ const noCallComponentAsFunction = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-setter-identifier.ts
-const isSetterIdentifier = (name) => SETTER_PATTERN.test(name);
-//#endregion
-//#region src/plugin/utils/is-setter-call.ts
-const isSetterCall = (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && isSetterIdentifier(node.callee.name);
-//#endregion
-//#region src/plugin/utils/is-hook-binding-in-scope.ts
-const isHookBindingInScope = (node, query) => {
-	const { bindingName, hookName, destructureIndex } = query;
-	let cursor = node;
-	while (cursor) {
-		if (isNodeOfType(cursor, "BlockStatement") || isNodeOfType(cursor, "Program")) for (const statement of cursor.body ?? []) {
-			if (!isNodeOfType(statement, "VariableDeclaration")) continue;
-			for (const declarator of statement.declarations ?? []) {
-				if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-				if (!isHookCall$2(declarator.init, hookName)) continue;
-				if (destructureIndex !== void 0) {
-					if (!isNodeOfType(declarator.id, "ArrayPattern")) continue;
-					const elements = declarator.id.elements ?? [];
-					if (elements.length <= destructureIndex) continue;
-					const element = elements[destructureIndex];
-					if (isNodeOfType(element, "Identifier") && element.name === bindingName) return true;
-				} else if (isNodeOfType(declarator.id, "Identifier") && declarator.id.name === bindingName) return true;
-			}
-		}
-		cursor = cursor.parent ?? null;
-	}
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/is-use-state-setter-in-scope.ts
-const isUseStateSetterInScope = (node, setterName) => isHookBindingInScope(node, {
-	bindingName: setterName,
-	hookName: "useState",
-	destructureIndex: 1
+//#region src/plugin/utils/define-retired-rule.ts
+const defineRetiredRule = (rule) => defineRule({
+	...rule,
+	defaultEnabled: false,
+	lifecycle: "retired",
+	create: () => ({})
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-cascading-set-state.ts
-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([
-	"forEach",
-	"map",
-	"filter",
-	"reduce",
-	"reduceRight",
-	"flatMap",
-	"some",
-	"every",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"sort"
-]);
-const runsOnEffectDispatch = (functionNode) => {
-	const parent = functionNode.parent;
-	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
-	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);
-};
-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);
-const analyzeStatementSequence = (statements, context) => {
-	let fallThroughCount = 0;
-	let maxTerminatedCount = 0;
-	for (const statement of statements) {
-		if (isNodeOfType(statement, "IfStatement")) {
-			fallThroughCount += countMaxPathSetStateCalls(statement.test, context);
-			const thenSummary = analyzeBranchStatements(statement.consequent, context);
-			const elseSummary = statement.alternate ? analyzeBranchStatements(statement.alternate, context) : {
-				fallThroughCount: 0,
-				maxTerminatedCount: 0,
-				doAllPathsTerminate: false
-			};
-			maxTerminatedCount = Math.max(maxTerminatedCount, fallThroughCount + thenSummary.maxTerminatedCount, fallThroughCount + elseSummary.maxTerminatedCount);
-			if (thenSummary.doAllPathsTerminate && elseSummary.doAllPathsTerminate) return {
-				fallThroughCount: 0,
-				maxTerminatedCount,
-				doAllPathsTerminate: true
-			};
-			const fallThroughBranchCounts = [...thenSummary.doAllPathsTerminate ? [] : [thenSummary.fallThroughCount], ...elseSummary.doAllPathsTerminate ? [] : [elseSummary.fallThroughCount]];
-			fallThroughCount += Math.max(...fallThroughBranchCounts);
-			continue;
-		}
-		if (isTerminatingStatement(statement)) {
-			const terminatedPathCount = fallThroughCount + countMaxPathSetStateCalls(statement, context);
-			return {
-				fallThroughCount: 0,
-				maxTerminatedCount: Math.max(maxTerminatedCount, terminatedPathCount),
-				doAllPathsTerminate: true
-			};
-		}
-		fallThroughCount += countMaxPathSetStateCalls(statement, context);
-	}
-	return {
-		fallThroughCount,
-		maxTerminatedCount,
-		doAllPathsTerminate: false
-	};
-};
-const countStatementSequenceSetStateCalls = (statements, context) => {
-	const summary = analyzeStatementSequence(statements, context);
-	return Math.max(summary.fallThroughCount, summary.maxTerminatedCount);
-};
-const collectLocalHelperFunctions = (root) => {
-	const helpersByName = /* @__PURE__ */ new Map();
-	const visit = (node) => {
-		if (isNodeOfType(node, "FunctionDeclaration") && node.id) helpersByName.set(node.id.name, node);
-		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.init && isFunctionLike$2(node.init)) helpersByName.set(node.id.name, node.init);
-		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.init && isNodeOfType(node.init, "CallExpression") && isNodeOfType(node.init.callee, "Identifier") && node.init.callee.name === "useCallback" && node.init.arguments?.[0] && isFunctionLike$2(node.init.arguments[0])) helpersByName.set(node.id.name, node.init.arguments[0]);
-		const record = node;
-		for (const key of Object.keys(record)) {
-			if (key === "parent") continue;
-			const child = record[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (item && typeof item === "object" && "type" in item) visit(item);
-			} else if (child && typeof child === "object" && "type" in child) visit(child);
-		}
-	};
-	visit(root);
-	return helpersByName;
-};
-const isWholesaleDelegationCall = (callNode, effectCallback) => {
-	const parent = callNode.parent;
-	if (!parent) return false;
-	if (parent === effectCallback) return true;
-	if (!isNodeOfType(parent, "ExpressionStatement")) return false;
-	return parent.parent === effectCallback.body;
-};
-const countFunctionBodySetStateCalls = (functionNode, context) => {
-	if (isAsyncFunctionLike(functionNode)) return 0;
-	const body = functionNode.body;
-	if (!body) return 0;
-	return countMaxPathSetStateCalls(body, context);
-};
-const countMaxPathSetStateCalls = (node, context) => {
-	if (!node || typeof node !== "object") return 0;
-	if (isFunctionLike$2(node)) return 0;
-	if (isNodeOfType(node, "BlockStatement") || isNodeOfType(node, "Program")) return countStatementSequenceSetStateCalls(node.body ?? [], context);
-	if (isNodeOfType(node, "IfStatement") || isNodeOfType(node, "ConditionalExpression")) {
-		const consequent = node.consequent;
-		const alternate = node.alternate;
-		const testCount = countMaxPathSetStateCalls(node.test, context);
-		const thenCount = countMaxPathSetStateCalls(consequent, context);
-		const elseCount = alternate ? countMaxPathSetStateCalls(alternate, context) : 0;
-		return testCount + Math.max(thenCount, elseCount);
-	}
-	if (isNodeOfType(node, "SwitchStatement")) {
-		let maxRunSetters = 0;
-		let currentRunSetters = 0;
-		for (const switchCase of node.cases ?? []) {
-			const consequent = switchCase.consequent ?? [];
-			let caseSetters = 0;
-			let runEnds = false;
-			for (const statement of consequent) {
-				caseSetters += countMaxPathSetStateCalls(statement, context);
-				if (isTerminatingStatement(statement)) runEnds = true;
-			}
-			currentRunSetters += caseSetters;
-			if (runEnds) {
-				if (currentRunSetters > maxRunSetters) maxRunSetters = currentRunSetters;
-				currentRunSetters = 0;
-			}
-		}
-		if (currentRunSetters > maxRunSetters) maxRunSetters = currentRunSetters;
-		return maxRunSetters;
-	}
-	if (isNodeOfType(node, "TryStatement")) {
-		const tryCount = countMaxPathSetStateCalls(node.block, context);
-		const catchCount = node.handler ? countMaxPathSetStateCalls(node.handler.body, context) : 0;
-		const finallyCount = node.finalizer ? countMaxPathSetStateCalls(node.finalizer, context) : 0;
-		return Math.max(tryCount, catchCount) + finallyCount;
-	}
-	if (isNodeOfType(node, "CallExpression") && isSetterCall(node) && isNodeOfType(node.callee, "Identifier") && isUseStateSetterInScope(node, node.callee.name)) {
-		let nestedSettersInArgs = 0;
-		for (const argument of node.arguments ?? []) nestedSettersInArgs += isFunctionLike$2(argument) ? countFunctionBodySetStateCalls(argument, context) : countMaxPathSetStateCalls(argument, context);
-		return 1 + nestedSettersInArgs;
-	}
-	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier")) {
-		const helperFunction = context.helpersByName.get(node.callee.name);
-		if (helperFunction && !context.activeHelpers.has(helperFunction) && isWholesaleDelegationCall(node, context.effectCallback)) {
-			context.activeHelpers.add(helperFunction);
-			let helperCount = countFunctionBodySetStateCalls(helperFunction, context);
-			context.activeHelpers.delete(helperFunction);
-			for (const argument of node.arguments ?? []) helperCount += countMaxPathSetStateCalls(argument, context);
-			return helperCount;
-		}
-	}
-	const countChild = (child) => {
-		if (isFunctionLike$2(child)) return runsOnEffectDispatch(child) ? countFunctionBodySetStateCalls(child, context) : 0;
-		return countMaxPathSetStateCalls(child, context);
-	};
-	let total = 0;
-	const nodeRecord = node;
-	for (const key of Object.keys(nodeRecord)) {
-		if (key === "parent") continue;
-		const child = nodeRecord[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (item && typeof item === "object" && "type" in item) total += countChild(item);
-		} else if (child && typeof child === "object" && "type" in child) total += countChild(child);
-	}
-	return total;
-};
-const isInitOnlyEffect = (node) => {
-	const depsArg = node.arguments?.[1];
-	if (!depsArg) return false;
-	if (!isNodeOfType(depsArg, "ArrayExpression")) return false;
-	return (depsArg.elements ?? []).length === 0;
-};
-const DEV_ENV_FLAG_NAMES = new Set([
-	"DEV",
-	"PROD",
-	"MODE",
-	"NODE_ENV"
-]);
-const mentionsDevEnvFlag = (node) => {
-	if (!node || typeof node !== "object") return false;
-	if (isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && DEV_ENV_FLAG_NAMES.has(node.property.name) && isNodeOfType(node.object, "MemberExpression") && isNodeOfType(node.object.property, "Identifier") && node.object.property.name === "env") return true;
-	const record = node;
-	for (const key of Object.keys(record)) {
-		if (key === "parent") continue;
-		const child = record[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (item && typeof item === "object" && "type" in item && mentionsDevEnvFlag(item)) return true;
-		} else if (child && typeof child === "object" && "type" in child && mentionsDevEnvFlag(child)) return true;
-	}
-	return false;
-};
-const isDevOnlyGuardedEffect = (callback) => {
-	const body = callback.body;
-	if (!body || !isNodeOfType(body, "BlockStatement")) return false;
-	const firstStatement = (body.body ?? [])[0];
-	if (!firstStatement) return false;
-	if (!isNodeOfType(firstStatement, "IfStatement") || firstStatement.alternate) return false;
-	const consequent = firstStatement.consequent;
-	if (!(isTerminatingStatement(consequent) || isNodeOfType(consequent, "BlockStatement") && (consequent.body ?? []).some((inner) => isTerminatingStatement(inner)))) return false;
-	return mentionsDevEnvFlag(firstStatement.test);
-};
-const noCascadingSetState = defineRule({
+const noCascadingSetState = defineRetiredRule({
 	id: "no-cascading-set-state",
 	title: "Multiple setState calls in one effect",
 	severity: "warn",
 	tags: ["test-noise"],
-	recommendation: "Combine related updates in `useReducer` so one effect does not redraw the screen once per `setState` call.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
-		if (isInitOnlyEffect(node)) return;
-		const callback = getEffectCallback(node, context.scopes);
-		if (!callback) return;
-		if (isDevOnlyGuardedEffect(callback)) return;
-		const setStateCallCount = countFunctionBodySetStateCalls(callback, {
-			helpersByName: collectLocalHelperFunctions(findProgramRoot(node) ?? callback),
-			activeHelpers: /* @__PURE__ */ new Set(),
-			effectCallback: callback
-		});
-		if (setStateCallCount >= 3) context.report({
-			node,
-			message: `${setStateCallCount} setState calls in one useEffect redraw your screen each time they run together.`
-		});
-	} })
+	recommendation: "Retired: React batches synchronous state updates from one effect into the same follow-up commit, so setter count does not prove repeated redraws."
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-chain-state-updates.ts
@@ -30437,6 +30702,9 @@ const noDirectMutationState = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/utils/is-setter-identifier.ts
+const isSetterIdentifier = (name) => SETTER_PATTERN.test(name);
+//#endregion
 //#region src/plugin/rules/state-and-effects/utils/collect-use-state-bindings.ts
 const collectUseStateBindings = (componentBody) => {
 	const bindings = [];
@@ -31323,7 +31591,7 @@ const noEffectChain = defineRule({
 			const effectInfos = [];
 			for (const effectCall of findTopLevelEffectCalls(componentBody)) {
 				const callback = getEffectCallback(effectCall, context.scopes);
-				if (!callback) continue;
+				if (!callback || !isFunctionLike$2(callback) || callback.async) continue;
 				const analysisFunctions = collectSynchronouslyInvokedFunctions(callback, context.scopes);
 				const writtenStateNames = collectWrittenStateNamesInEffect(analysisFunctions, setterToStateName);
 				effectInfos.push({
@@ -32707,6 +32975,9 @@ const noEventTriggerState = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-setter-call.ts
+const isSetterCall = (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && isSetterIdentifier(node.callee.name);
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-fetch-in-effect.ts
 const IMPORT_INITIALIZER_TYPES = new Set([
 	"ImportSpecifier",
@@ -33954,26 +34225,6 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/react-ref-origin.ts
-const resolveReactRefSymbol = (memberExpression, scopes) => {
-	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
-	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticPropertyName(memberExpression) !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
-	const symbol = resolveConstIdentifierAlias(receiver, scopes);
-	if (!symbol?.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
-};
-const hasReactRefCurrentOrigin = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(node);
-	if (resolveReactRefSymbol(expression, scopes)) return true;
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = resolveConstIdentifierAlias(expression, scopes);
-	if (!symbol?.initializer || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	return hasReactRefCurrentOrigin(symbol.initializer, scopes, visitedSymbolIds);
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-impure-state-updater.ts
 const TIMER_FUNCTION_NAMES = new Set([
 	"cancelAnimationFrame",
@@ -40937,10 +41188,10 @@ const noStaticElementInteractions = defineRule({
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return { JSXOpeningElement(node) {
 			if (isTestlikeFile) return;
-			let hasNonBlockerHandler = false;
 			let hasAnyHandler = false;
 			let isKeyboardTarget = null;
 			let seenHandlerNames = null;
+			let nonBlockerHandlerNamesLower = null;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
 				const attributeName = getJsxAttributeName(attribute.name);
@@ -40955,13 +41206,12 @@ const noStaticElementInteractions = defineRule({
 					if (!isKeyboardTarget) continue;
 				}
 				hasAnyHandler = true;
-				if (!isPureEventBlockerHandler(attribute)) {
-					hasNonBlockerHandler = true;
-					break;
-				}
+				if (!isPureEventBlockerHandler(attribute)) (nonBlockerHandlerNamesLower ??= /* @__PURE__ */ new Set()).add(handlerNameLower);
 			}
 			if (!hasAnyHandler) return;
-			if (!hasNonBlockerHandler) return;
+			if (!nonBlockerHandlerNamesLower) return;
+			const onClick = nonBlockerHandlerNamesLower.size === 1 && nonBlockerHandlerNamesLower.has("onclick") ? hasJsxPropIgnoreCase(node.attributes, "onClick") : null;
+			if (onClick && hasKeyboardActivatableDescendant(node.parent, onClick, context.scopes, context.settings)) return;
 			const elementType = getElementType(node, context.settings);
 			if (!HTML_TAGS.has(elementType)) return;
 			if (elementType === "svg") return;
@@ -45418,19 +45668,63 @@ const preferTagOverRole = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/prefer-use-effect-event.ts
-const collectFunctionTypedLocalBindings = (componentBody) => {
-	const functionTypedLocals = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(componentBody, "BlockStatement")) return functionTypedLocals;
+const STABLE_REACT_HOOK_VALUE_NAMES = new Set([
+	"useActionState",
+	"useEffectEvent",
+	"useReducer",
+	"useRef",
+	"useState",
+	"useTransition"
+]);
+const isStableReactHookDependency = (dependency, context) => {
+	const unwrappedDependency = stripParenExpression(dependency);
+	if (!isNodeOfType(unwrappedDependency, "Identifier")) return false;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let dependencySymbol = context.scopes.symbolFor(unwrappedDependency);
+	while (dependencySymbol) {
+		if (visitedSymbolIds.has(dependencySymbol.id)) return false;
+		visitedSymbolIds.add(dependencySymbol.id);
+		if (symbolHasStableHookOrigin(dependencySymbol, context.scopes)) {
+			let declarator = dependencySymbol.declarationNode;
+			while (declarator && !isNodeOfType(declarator, "VariableDeclarator")) declarator = declarator.parent;
+			if (!declarator?.init) return false;
+			return isReactApiCall(stripParenExpression(declarator.init), STABLE_REACT_HOOK_VALUE_NAMES, context.scopes, {
+				allowGlobalReactNamespace: true,
+				resolveNamedAliases: true
+			});
+		}
+		if (dependencySymbol.kind !== "const" || dependencySymbol.references.some((reference) => reference.flag !== "read") || !isNodeOfType(dependencySymbol.declarationNode, "VariableDeclarator") || dependencySymbol.declarationNode.id !== dependencySymbol.bindingIdentifier || !dependencySymbol.initializer) return false;
+		const aliasInitializer = stripParenExpression(dependencySymbol.initializer);
+		if (!isNodeOfType(aliasInitializer, "Identifier")) return false;
+		dependencySymbol = context.scopes.symbolFor(aliasInitializer);
+	}
+	return false;
+};
+const isPotentiallyChangingReactUseCallback = (initializer, context) => {
+	const unwrappedInitializer = stripParenExpression(initializer);
+	if (!isNodeOfType(unwrappedInitializer, "CallExpression")) return false;
+	if (!isReactApiCall(unwrappedInitializer, "useCallback", context.scopes, {
+		allowGlobalReactNamespace: true,
+		resolveNamedAliases: true
+	})) return false;
+	const dependencyList = unwrappedInitializer.arguments?.[1];
+	if (!dependencyList) return true;
+	const unwrappedDependencyList = stripParenExpression(dependencyList);
+	if (!isNodeOfType(unwrappedDependencyList, "ArrayExpression")) return true;
+	return (unwrappedDependencyList.elements ?? []).some((dependency) => dependency === null || !isStableReactHookDependency(dependency, context));
+};
+const collectPotentiallyChangingCallbackBindings = (componentBody, context) => {
+	const potentiallyChangingCallbacks = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(componentBody, "BlockStatement")) return potentiallyChangingCallbacks;
 	for (const statement of componentBody.body ?? []) {
 		if (!isNodeOfType(statement, "VariableDeclaration")) continue;
 		for (const declarator of statement.declarations ?? []) {
 			if (!isNodeOfType(declarator.id, "Identifier")) continue;
-			if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-			if (!isHookCall$2(declarator.init, "useCallback")) continue;
-			functionTypedLocals.add(declarator.id.name);
+			if (!declarator.init || !isPotentiallyChangingReactUseCallback(declarator.init, context)) continue;
+			potentiallyChangingCallbacks.add(declarator.id.name);
 		}
 	}
-	return functionTypedLocals;
+	return potentiallyChangingCallbacks;
 };
 const findEnclosingFunctionInsideEffect = (identifierNode, effectCallback) => {
 	let cursor = identifierNode.parent ?? null;
@@ -45504,7 +45798,7 @@ const preferUseEffectEvent = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const functionTypedLocalBindings = collectFunctionTypedLocalBindings(componentBody);
+			const potentiallyChangingCallbackBindings = collectPotentiallyChangingCallbackBindings(componentBody, context);
 			for (const statement of componentBody.body ?? []) {
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 				const effectCall = statement.expression;
@@ -45522,7 +45816,7 @@ const preferUseEffectEvent = defineRule({
 					if (!isNodeOfType(depElement, "Identifier")) continue;
 					const depName = depElement.name;
 					const isFunctionTypedPropDep = propStackTracker.isPropName(depName) && REACT_HANDLER_PROP_PATTERN.test(depName);
-					const isFunctionTypedLocalDep = functionTypedLocalBindings.has(depName);
+					const isFunctionTypedLocalDep = potentiallyChangingCallbackBindings.has(depName);
 					if (!isFunctionTypedPropDep && !isFunctionTypedLocalDep) continue;
 					const classification = classifyCallableReadsInsideEffect(depName, callback);
 					if (!classification.hasAnyRead) continue;
@@ -47068,6 +47362,37 @@ const containsLocaleEnvironmentRead = (expression) => {
 	return readsLocaleEnvironment;
 };
 //#endregion
+//#region src/plugin/utils/is-hook-binding-in-scope.ts
+const isHookBindingInScope = (node, query) => {
+	const { bindingName, hookName, destructureIndex } = query;
+	let cursor = node;
+	while (cursor) {
+		if (isNodeOfType(cursor, "BlockStatement") || isNodeOfType(cursor, "Program")) for (const statement of cursor.body ?? []) {
+			if (!isNodeOfType(statement, "VariableDeclaration")) continue;
+			for (const declarator of statement.declarations ?? []) {
+				if (!isNodeOfType(declarator.init, "CallExpression")) continue;
+				if (!isHookCall$2(declarator.init, hookName)) continue;
+				if (destructureIndex !== void 0) {
+					if (!isNodeOfType(declarator.id, "ArrayPattern")) continue;
+					const elements = declarator.id.elements ?? [];
+					if (elements.length <= destructureIndex) continue;
+					const element = elements[destructureIndex];
+					if (isNodeOfType(element, "Identifier") && element.name === bindingName) return true;
+				} else if (isNodeOfType(declarator.id, "Identifier") && declarator.id.name === bindingName) return true;
+			}
+		}
+		cursor = cursor.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/is-use-state-setter-in-scope.ts
+const isUseStateSetterInScope = (node, setterName) => isHookBindingInScope(node, {
+	bindingName: setterName,
+	hookName: "useState",
+	destructureIndex: 1
+});
+//#endregion
 //#region src/plugin/rules/performance/rendering-hydration-no-flicker.ts
 const USE_EFFECT_ONLY = new Set(["useEffect"]);
 const argumentsReadRefCurrent = (callArguments) => callArguments.some((argument) => {
@@ -48757,14 +49082,6 @@ const rerenderTransitionsScroll = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/define-retired-rule.ts
-const defineRetiredRule = (rule) => defineRule({
-	...rule,
-	defaultEnabled: false,
-	lifecycle: "retired",
-	create: () => ({})
-});
-//#endregion
 //#region src/plugin/rules/react-native/rn-animate-layout-property.ts
 const rnAnimateLayoutProperty = defineRetiredRule({
 	id: "rn-animate-layout-property",
@@ -57932,8 +58249,7 @@ const webhookSignatureRisk = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/zod/utils/zod-ast.ts
-const ZOD_MODULE = "zod";
-const ZOD_MODULE_SOURCES = [ZOD_MODULE];
+const ZOD_MODULE_SOURCES = ["zod", "zod/v4"];
 const importInfoCache = /* @__PURE__ */ new WeakMap();
 const getImportInfoForIdentifier = (identifier) => {
 	if (importInfoCache.has(identifier)) return importInfoCache.get(identifier) ?? null;
@@ -57946,7 +58262,8 @@ const computeImportInfoForIdentifier = (identifier) => {
 	if (!specifier) return null;
 	const declaration = specifier.parent;
 	if (!declaration || !isNodeOfType(declaration, "ImportDeclaration")) return null;
-	if (declaration.source?.value !== ZOD_MODULE) return null;
+	const source = declaration.source?.value;
+	if (typeof source !== "string" || !ZOD_MODULE_SOURCES.includes(source)) return null;
 	if (isNodeOfType(specifier, "ImportNamespaceSpecifier")) return {
 		imported: null,
 		isDefault: false,