oxlint-plugin-react-doctor 0.7.6-dev.b36e439 → 0.7.6-dev.c1916d5

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;
@@ -6890,6 +7080,27 @@ const createMethodMutationAnalysis = (context) => {
 	};
 };
 //#endregion
+//#region src/plugin/utils/collect-function-return-statements.ts
+const collectFunctionReturnStatements = (functionNode) => {
+	if (!isFunctionLike$2(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return [];
+	const returnStatements = [];
+	walkAst(functionNode.body, (node) => {
+		if (node !== functionNode.body && (isFunctionLike$2(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (isNodeOfType(node, "ReturnStatement")) returnStatements.push(node);
+	});
+	return returnStatements;
+};
+//#endregion
+//#region src/plugin/utils/find-enclosing-function.ts
+const findEnclosingFunction = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isFunctionLike$2(cursor)) return cursor;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+//#endregion
 //#region src/plugin/utils/statement-always-exits.ts
 const statementAlwaysExits = (statement) => {
 	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement")) return true;
@@ -6899,17 +7110,109 @@ const statementAlwaysExits = (statement) => {
 };
 //#endregion
 //#region src/plugin/utils/function-returns-matching-expression.ts
+const REASSIGNABLE_BINDING_KINDS = new Set(["let", "var"]);
+const CONDITIONAL_EXPRESSION_TYPES = new Set(["ConditionalExpression", "LogicalExpression"]);
 const collectReturnedExpressions = (functionNode) => {
-	if (!isFunctionLike$2(functionNode)) return [];
-	const body = functionNode.body;
-	if (!body) return [];
-	if (!isNodeOfType(body, "BlockStatement")) return [body];
-	const returnedExpressions = [];
-	walkAst(body, (node) => {
-		if (node !== body && (isFunctionLike$2(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
-		if (isNodeOfType(node, "ReturnStatement") && node.argument) returnedExpressions.push(node.argument);
-	});
-	return returnedExpressions;
+	if (!isFunctionLike$2(functionNode) || !functionNode.body) return [];
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return [functionNode.body];
+	return collectFunctionReturnStatements(functionNode).flatMap((returnStatement) => returnStatement.argument ? [returnStatement.argument] : []);
+};
+const getAssignedExpressionForWrite = (writeIdentifier) => {
+	let assignmentTarget = writeIdentifier;
+	let parent = assignmentTarget.parent;
+	while (parent && stripParenExpression(parent) === writeIdentifier) {
+		assignmentTarget = parent;
+		parent = assignmentTarget.parent;
+	}
+	return parent && isNodeOfType(parent, "AssignmentExpression") && parent.operator === "=" && parent.left === assignmentTarget ? parent.right : null;
+};
+const isConditionalWithinBlock = (node, block, functionControlFlow) => {
+	let current = node.parent ?? null;
+	while (current && functionControlFlow.blockOf(current) === block) {
+		if (CONDITIONAL_EXPRESSION_TYPES.has(current.type)) return true;
+		current = current.parent ?? null;
+	}
+	return false;
+};
+const haveSameDefinitions = (left, right) => left.size === right.size && [...left].every((definition) => right.has(definition));
+const applyDefinitions = (incomingDefinitions, definitions) => {
+	let currentDefinitions = new Set(incomingDefinitions);
+	for (const definition of definitions) {
+		if (!definition.isConditionalWithinBlock) currentDefinitions = /* @__PURE__ */ new Set();
+		currentDefinitions.add(definition);
+	}
+	return currentDefinitions;
+};
+const collectPossibleAssignedExpressions = (symbol, referenceNode, controlFlow) => {
+	if (!REASSIGNABLE_BINDING_KINDS.has(symbol.kind)) return symbol.initializer ? [symbol.initializer] : [];
+	if (!controlFlow) return [];
+	const referenceFunction = findEnclosingFunction(referenceNode);
+	if (findEnclosingFunction(symbol.bindingIdentifier) !== referenceFunction) return [];
+	if (!referenceFunction) return [];
+	const functionControlFlow = controlFlow.cfgFor(referenceFunction);
+	if (!functionControlFlow) return [];
+	const referenceBlock = functionControlFlow.blockOf(referenceNode);
+	if (!referenceBlock) return [];
+	const referencePosition = getRangeStart(referenceNode);
+	const bindingPosition = getRangeStart(symbol.bindingIdentifier);
+	if (referencePosition === null || bindingPosition === null) return [];
+	const definitionsByBlock = /* @__PURE__ */ new Map();
+	const addDefinition = (expression, definitionNode, position) => {
+		const block = functionControlFlow.blockOf(definitionNode);
+		if (!block) return;
+		const definitions = definitionsByBlock.get(block) ?? [];
+		definitions.push({
+			expression,
+			position,
+			isConditionalWithinBlock: isConditionalWithinBlock(definitionNode, block, functionControlFlow)
+		});
+		definitionsByBlock.set(block, definitions);
+	};
+	if (symbol.initializer) addDefinition(symbol.initializer, symbol.bindingIdentifier, bindingPosition);
+	for (const reference of symbol.references) {
+		const writePosition = getRangeStart(reference.identifier);
+		if (reference.flag === "read" || findEnclosingFunction(reference.identifier) !== referenceFunction || writePosition === null || writePosition >= referencePosition) continue;
+		const assignedExpression = getAssignedExpressionForWrite(reference.identifier);
+		if (!assignedExpression) continue;
+		addDefinition(assignedExpression, reference.identifier, writePosition);
+	}
+	for (const definitions of definitionsByBlock.values()) definitions.sort((left, right) => left.position - right.position);
+	const incomingDefinitionsByBlock = /* @__PURE__ */ new Map();
+	const outgoingDefinitionsByBlock = /* @__PURE__ */ new Map();
+	const reachableBlocks = new Set([functionControlFlow.entry]);
+	const pendingBlocks = [functionControlFlow.entry];
+	while (pendingBlocks.length > 0) {
+		const block = pendingBlocks.pop();
+		if (!block) break;
+		for (const edge of block.successors) {
+			if (reachableBlocks.has(edge.to)) continue;
+			reachableBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	if (!reachableBlocks.has(referenceBlock)) return [];
+	let didDefinitionsChange = true;
+	while (didDefinitionsChange) {
+		didDefinitionsChange = false;
+		for (const block of functionControlFlow.blocks) {
+			if (!reachableBlocks.has(block)) continue;
+			const incomingDefinitions = /* @__PURE__ */ new Set();
+			for (const predecessor of block.predecessors) {
+				if (!reachableBlocks.has(predecessor.from)) continue;
+				for (const definition of outgoingDefinitionsByBlock.get(predecessor.from) ?? []) incomingDefinitions.add(definition);
+			}
+			const outgoingDefinitions = applyDefinitions(incomingDefinitions, definitionsByBlock.get(block) ?? []);
+			const previousIncomingDefinitions = incomingDefinitionsByBlock.get(block) ?? /* @__PURE__ */ new Set();
+			const previousOutgoingDefinitions = outgoingDefinitionsByBlock.get(block) ?? /* @__PURE__ */ new Set();
+			if (!haveSameDefinitions(incomingDefinitions, previousIncomingDefinitions) || !haveSameDefinitions(outgoingDefinitions, previousOutgoingDefinitions)) {
+				incomingDefinitionsByBlock.set(block, incomingDefinitions);
+				outgoingDefinitionsByBlock.set(block, outgoingDefinitions);
+				didDefinitionsChange = true;
+			}
+		}
+	}
+	const definitionsBeforeReference = (definitionsByBlock.get(referenceBlock) ?? []).filter((definition) => definition.position < referencePosition);
+	return [...applyDefinitions(incomingDefinitionsByBlock.get(referenceBlock) ?? /* @__PURE__ */ new Set(), definitionsBeforeReference)].map((definition) => definition.expression);
 };
 const functionHasBareReturn = (functionNode) => {
 	if (!isFunctionLike$2(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return false;
@@ -6921,7 +7224,7 @@ const functionHasBareReturn = (functionNode) => {
 	});
 	return didFindBareReturn;
 };
-const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpression, matchMode = "some") => {
+const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpression, controlFlow, matchMode = "some") => {
 	const visitedExpressions = /* @__PURE__ */ new Set();
 	const visitedFunctions = /* @__PURE__ */ new Set();
 	const functionMatches = (candidateFunction) => {
@@ -6938,10 +7241,11 @@ const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpressi
 		if (matchesExpression(unwrappedExpression)) return true;
 		if (isNodeOfType(unwrappedExpression, "Identifier")) {
 			const symbol = scopes.symbolFor(unwrappedExpression);
-			if (!symbol || symbol.kind !== "const" || !symbol.initializer) return false;
-			const initializer = stripParenExpression(symbol.initializer);
-			if (isFunctionLike$2(initializer)) return false;
-			return expressionMatches(initializer);
+			if (!symbol || symbol.kind !== "const" && !REASSIGNABLE_BINDING_KINDS.has(symbol.kind)) return false;
+			return collectPossibleAssignedExpressions(symbol, unwrappedExpression, controlFlow).some((assignedExpression) => {
+				const assignedValue = stripParenExpression(assignedExpression);
+				return !isFunctionLike$2(assignedValue) && expressionMatches(assignedValue);
+			});
 		}
 		if (isNodeOfType(unwrappedExpression, "CallExpression")) {
 			if (unwrappedExpression.arguments.length !== 0) return false;
@@ -7342,7 +7646,7 @@ const isProvenBrowserApiReceiver = (receiver, receiverKind, scopes, visitedSymbo
 		const callee = stripParenExpression(expression.callee);
 		if (isDomEventTarget && isNodeOfType(callee, "MemberExpression") && DOM_EVENT_TARGET_FACTORY_METHOD_NAMES.has(getStaticPropertyName(callee) ?? "") && isProvenBrowserApiReceiver(callee.object, receiverKind, scopes, visitedSymbolIds)) return true;
 		const calledFunction = getSameFileCalledFunction(expression, scopes, visitedSymbolIds);
-		return Boolean(calledFunction && functionReturnsMatchingExpression(calledFunction, scopes, (returnedExpression) => isProvenBrowserApiReceiver(returnedExpression, receiverKind, scopes, new Set(visitedSymbolIds)), "every"));
+		return Boolean(calledFunction && functionReturnsMatchingExpression(calledFunction, scopes, (returnedExpression) => isProvenBrowserApiReceiver(returnedExpression, receiverKind, scopes, new Set(visitedSymbolIds)), void 0, "every"));
 	}
 	if (!isNodeOfType(expression, "MemberExpression")) return false;
 	const classMember = getClassMemberDefinition(expression);
@@ -8045,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;
@@ -8250,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") {
@@ -8291,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;
@@ -10165,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;
 };
@@ -10422,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,
@@ -10456,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) => {
@@ -10816,16 +11084,6 @@ const componentOrHookDisplayNameForFunction = (functionNode) => {
 	return displayNameFromFunctionBinding(functionNode);
 };
 //#endregion
-//#region src/plugin/utils/find-enclosing-function.ts
-const findEnclosingFunction = (node) => {
-	let cursor = node.parent;
-	while (cursor) {
-		if (isFunctionLike$2(cursor)) return cursor;
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/enclosing-component-or-hook-name.ts
 const enclosingComponentOrHookName = (node) => {
 	const functionNode = findEnclosingFunction(node);
@@ -10844,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",
@@ -10880,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
@@ -10911,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;
@@ -10947,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",
@@ -11176,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;
@@ -11192,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;
@@ -11339,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);
@@ -11372,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);
@@ -11436,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 = [];
@@ -11559,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];
@@ -11617,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;
@@ -11657,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;
@@ -12866,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();
@@ -12896,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);
@@ -13004,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);
@@ -13463,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));
@@ -13478,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;
@@ -13543,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) {
@@ -15542,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;
@@ -15609,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);
@@ -16893,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)];
@@ -17173,12 +17792,23 @@ const jsLengthCheckFirst = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/js-min-max-loop.ts
+const builtinMutationByProgram = /* @__PURE__ */ new WeakMap();
+const RUNTIMELESS_SYMBOL_KINDS = new Set(["ts-interface", "ts-type-alias"]);
+const PROTOTYPE_METHOD_NAMES = new Set(["getPrototypeOf"]);
+const OBJECT_ASSIGN_METHOD_NAMES = new Set(["assign"]);
+const OBJECT_DEFINE_PROPERTIES_METHOD_NAMES = new Set(["defineProperties"]);
+const KEYED_MUTATION_METHOD_NAMES = new Set([
+	"defineProperty",
+	"deleteProperty",
+	"set"
+]);
 const numericComparatorDirection = (comparator) => {
-	if (!isInlineFunctionExpression(comparator)) return null;
+	if (!isInlineFunctionExpression(comparator) || comparator.async || comparator.generator) return null;
 	const parameters = comparator.params ?? [];
 	if (parameters.length !== 2) return null;
 	const [firstParameter, secondParameter] = parameters;
 	if (!isNodeOfType(firstParameter, "Identifier") || !isNodeOfType(secondParameter, "Identifier")) return null;
+	if (firstParameter.name === secondParameter.name) return null;
 	let comparisonExpression = null;
 	const comparatorBody = stripParenExpression(comparator.body);
 	if (isNodeOfType(comparatorBody, "BinaryExpression")) comparisonExpression = comparatorBody;
@@ -17196,6 +17826,150 @@ const numericComparatorDirection = (comparator) => {
 	if (leftName === secondParameter.name && rightName === firstParameter.name) return "descending";
 	return null;
 };
+const getStaticFiniteNumericValue = (expression) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Literal")) return typeof strippedExpression.value === "number" && Number.isFinite(strippedExpression.value) ? strippedExpression.value : null;
+	if (!isNodeOfType(strippedExpression, "UnaryExpression") || strippedExpression.operator !== "+" && strippedExpression.operator !== "-") return null;
+	const argumentValue = getStaticFiniteNumericValue(strippedExpression.argument);
+	if (argumentValue === null) return null;
+	return strippedExpression.operator === "-" ? -argumentValue : argumentValue;
+};
+const isSafeFreshNumericArray = (arrayExpression) => {
+	if (arrayExpression.elements.length === 0 || arrayExpression.elements.length > 1024) return false;
+	let didFindPositiveZero = false;
+	let didFindNegativeZero = false;
+	for (const element of arrayExpression.elements) {
+		if (!element || isNodeOfType(element, "SpreadElement")) return false;
+		const numericValue = getStaticFiniteNumericValue(element);
+		if (numericValue === null) return false;
+		if (Object.is(numericValue, 0)) didFindPositiveZero = true;
+		if (Object.is(numericValue, -0)) didFindNegativeZero = true;
+	}
+	return !(didFindPositiveZero && didFindNegativeZero);
+};
+const isGlobalObjectReference = (expression, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
+	if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
+	const symbol = scopes.symbolFor(strippedExpression);
+	if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
+	visitedSymbols.add(symbol.id);
+	return isGlobalObjectReference(symbol.initializer, scopes, visitedSymbols);
+};
+const resolvesToGlobalNamespace = (expression, namespaceName, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
+		visitedSymbols.add(symbol.id);
+		return resolvesToGlobalNamespace(symbol.initializer, namespaceName, scopes, visitedSymbols);
+	}
+	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isGlobalObjectReference(strippedExpression.object, scopes);
+};
+const resolvesToGlobalMethod = (expression, namespaceName, methodNames, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
+		visitedSymbols.add(symbol.id);
+		return resolvesToGlobalMethod(symbol.initializer, namespaceName, methodNames, scopes, visitedSymbols);
+	}
+	return isNodeOfType(strippedExpression, "MemberExpression") && methodNames.has(getStaticPropertyName(strippedExpression) ?? "") && resolvesToGlobalNamespace(strippedExpression.object, namespaceName, scopes);
+};
+const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
+		visitedSymbols.add(symbol.id);
+		return resolvesToNativeArrayPrototype(symbol.initializer, scopes, visitedSymbols);
+	}
+	if (isNodeOfType(strippedExpression, "MemberExpression")) {
+		const propertyName = getStaticPropertyName(strippedExpression);
+		if (propertyName === "prototype") return resolvesToGlobalNamespace(strippedExpression.object, "Array", scopes);
+		return propertyName === "__proto__" && isNodeOfType(stripParenExpression(strippedExpression.object), "ArrayExpression");
+	}
+	if (!isNodeOfType(strippedExpression, "CallExpression")) return false;
+	if (!resolvesToGlobalMethod(strippedExpression.callee, "Object", PROTOTYPE_METHOD_NAMES, scopes) && !resolvesToGlobalMethod(strippedExpression.callee, "Reflect", PROTOTYPE_METHOD_NAMES, scopes)) return false;
+	const argument = strippedExpression.arguments[0];
+	return Boolean(argument && isNodeOfType(stripParenExpression(argument), "ArrayExpression"));
+};
+const isGlobalNamespaceReplacementTarget = (target, namespaceName, scopes) => {
+	const strippedTarget = stripParenExpression(target);
+	if (isNodeOfType(strippedTarget, "Identifier")) return strippedTarget.name === namespaceName && scopes.isGlobalReference(strippedTarget);
+	return isNodeOfType(strippedTarget, "MemberExpression") && getStaticPropertyName(strippedTarget) === namespaceName && isGlobalObjectReference(strippedTarget.object, scopes);
+};
+const isUnsafeBuiltinMemberTarget = (target, targetFunction, scopes) => {
+	const strippedTarget = stripParenExpression(target);
+	if (!isNodeOfType(strippedTarget, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(strippedTarget);
+	if (resolvesToNativeArrayPrototype(strippedTarget.object, scopes)) return propertyName === null || propertyName === "sort";
+	if (resolvesToGlobalNamespace(strippedTarget.object, "Math", scopes)) return propertyName === null || propertyName === targetFunction;
+	return isGlobalObjectReference(strippedTarget.object, scopes) && (propertyName === null || propertyName === "Math");
+};
+const isUnsafeBuiltinMutationApiCall = (callExpression, targetFunction, scopes) => {
+	const target = callExpression.arguments[0];
+	if (!target) return false;
+	let propertyName = null;
+	if (resolvesToNativeArrayPrototype(target, scopes)) propertyName = "sort";
+	else if (resolvesToGlobalNamespace(target, "Math", scopes)) propertyName = targetFunction;
+	else if (isGlobalObjectReference(target, scopes)) propertyName = "Math";
+	if (!propertyName) return false;
+	const canObjectExpressionSetProperty = (properties) => {
+		if (!isNodeOfType(properties, "ObjectExpression")) return true;
+		return properties.properties.some((property) => {
+			if (isNodeOfType(property, "SpreadElement")) return true;
+			const keyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+			return keyName === propertyName || keyName === null;
+		});
+	};
+	if (resolvesToGlobalMethod(callExpression.callee, "Object", OBJECT_ASSIGN_METHOD_NAMES, scopes)) return callExpression.arguments.slice(1).some((properties) => canObjectExpressionSetProperty(properties));
+	if (resolvesToGlobalMethod(callExpression.callee, "Object", OBJECT_DEFINE_PROPERTIES_METHOD_NAMES, scopes)) {
+		const properties = callExpression.arguments[1];
+		return !properties || canObjectExpressionSetProperty(properties);
+	}
+	if (!resolvesToGlobalMethod(callExpression.callee, "Object", KEYED_MUTATION_METHOD_NAMES, scopes) && !resolvesToGlobalMethod(callExpression.callee, "Reflect", KEYED_MUTATION_METHOD_NAMES, scopes)) return false;
+	const propertyArgument = callExpression.arguments[1];
+	if (!propertyArgument) return true;
+	return isNodeOfType(propertyArgument, "Literal") ? propertyArgument.value === propertyName : true;
+};
+const hasUnsafeBuiltinMutation = (node, targetFunction, scopes) => {
+	const programRoot = findProgramRoot(node);
+	if (!programRoot) return true;
+	let mutationByTargetFunction = builtinMutationByProgram.get(programRoot);
+	if (!mutationByTargetFunction) {
+		mutationByTargetFunction = /* @__PURE__ */ new Map();
+		builtinMutationByProgram.set(programRoot, mutationByTargetFunction);
+	}
+	const cachedResult = mutationByTargetFunction.get(targetFunction);
+	if (cachedResult !== void 0) return cachedResult;
+	let didFindUnsafeMutation = false;
+	walkAst(programRoot, (candidate) => {
+		if (didFindUnsafeMutation) return false;
+		if (isNodeOfType(candidate, "CallExpression")) {
+			didFindUnsafeMutation = isUnsafeBuiltinMutationApiCall(candidate, targetFunction, scopes);
+			return;
+		}
+		let mutationTarget = null;
+		if (isNodeOfType(candidate, "AssignmentExpression")) mutationTarget = candidate.left;
+		if (isNodeOfType(candidate, "UpdateExpression")) mutationTarget = candidate.argument;
+		if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "delete") mutationTarget = candidate.argument;
+		if (!mutationTarget) return;
+		didFindUnsafeMutation = isUnsafeBuiltinMemberTarget(mutationTarget, targetFunction, scopes) || isGlobalNamespaceReplacementTarget(mutationTarget, "Math", scopes);
+	});
+	mutationByTargetFunction.set(targetFunction, didFindUnsafeMutation);
+	return didFindUnsafeMutation;
+};
+const hasUnsafeMathBinding = (node, scopes) => {
+	let scope = scopes.scopeFor(node);
+	while (scope) {
+		const symbol = scope.symbolsByName.get("Math");
+		if (symbol && !RUNTIMELESS_SYMBOL_KINDS.has(symbol.kind)) return !(symbol.kind === "const" && symbol.initializer && resolvesToGlobalNamespace(symbol.initializer, "Math", scopes));
+		scope = scope.parent;
+	}
+	return false;
+};
 const jsMinMaxLoop = defineRule({
 	id: "js-min-max-loop",
 	title: "sort() to find min or max",
@@ -17206,18 +17980,18 @@ const jsMinMaxLoop = defineRule({
 		if (!node.computed) return;
 		const object = node.object;
 		if (!isNodeOfType(object, "CallExpression") || !isMemberProperty(object.callee, "sort")) return;
+		const sortReceiver = stripParenExpression(object.callee.object);
+		if (!isNodeOfType(sortReceiver, "ArrayExpression") || !isSafeFreshNumericArray(sortReceiver)) return;
 		const comparator = object.arguments?.[0];
 		const direction = numericComparatorDirection(comparator);
 		if (!direction) return;
-		const isFirstElement = isNodeOfType(node.property, "Literal") && node.property.value === 0;
-		const isLastElement = isNodeOfType(node.property, "BinaryExpression") && node.property.operator === "-" && isNodeOfType(node.property.right, "Literal") && node.property.right.value === 1;
-		if (isFirstElement || isLastElement) {
-			const targetFunction = (direction === "ascending" ? isFirstElement : isLastElement) ? "min" : "max";
-			context.report({
-				node,
-				message: `This is slow because array.sort()[${isFirstElement ? "0" : "length-1"}] sorts the whole list just to grab the smallest or largest, so use Math.${targetFunction}(...array) instead`
-			});
-		}
+		if (!(isNodeOfType(node.property, "Literal") && node.property.value === 0)) return;
+		const targetFunction = direction === "ascending" ? "min" : "max";
+		if (hasUnsafeMathBinding(node, context.scopes) || hasUnsafeBuiltinMutation(node, targetFunction, context.scopes)) return;
+		context.report({
+			node,
+			message: `This is slow because array.sort()[0] sorts the whole list just to grab the smallest or largest, so use Math.${targetFunction}(...array) instead`
+		});
 	} })
 });
 //#endregion
@@ -27691,6 +28465,152 @@ const noBarrelImport = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/has-static-property-write-before.ts
+const equivalentSymbolsByAnalysis = /* @__PURE__ */ new WeakMap();
+const CONDITIONAL_EXECUTION_NODE_TYPES = new Set([
+	"CatchClause",
+	"ConditionalExpression",
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"IfStatement",
+	"LogicalExpression",
+	"SwitchCase",
+	"SwitchStatement",
+	"TryStatement",
+	"WhileStatement"
+]);
+const getResolvedStaticPropertyName = (memberExpression, scopes) => {
+	if (!isNodeOfType(memberExpression, "MemberExpression")) return null;
+	const directPropertyName = getStaticPropertyName(memberExpression);
+	if (directPropertyName || !memberExpression.computed) return directPropertyName;
+	const property = stripParenExpression(memberExpression.property);
+	if (!isNodeOfType(property, "Identifier")) return null;
+	const propertySymbol = resolveConstIdentifierAlias(property, scopes);
+	const initializer = propertySymbol?.initializer ? stripParenExpression(propertySymbol.initializer) : null;
+	return initializer && isNodeOfType(initializer, "Literal") && typeof initializer.value === "string" ? initializer.value : null;
+};
+const collectScopeSymbols = (scope, symbols) => {
+	symbols.push(...scope.symbols);
+	for (const childScope of scope.children) collectScopeSymbols(childScope, symbols);
+};
+const getEquivalentSymbols = (identifier, scopes) => {
+	const rootSymbol = resolveConstIdentifierAlias(identifier, scopes);
+	if (!rootSymbol) return [];
+	let symbolsByRootId = equivalentSymbolsByAnalysis.get(scopes);
+	if (!symbolsByRootId) {
+		symbolsByRootId = /* @__PURE__ */ new Map();
+		equivalentSymbolsByAnalysis.set(scopes, symbolsByRootId);
+	}
+	const cachedSymbols = symbolsByRootId.get(rootSymbol.id);
+	if (cachedSymbols) return cachedSymbols;
+	const allSymbols = [];
+	collectScopeSymbols(scopes.rootScope, allSymbols);
+	const equivalentSymbols = allSymbols.filter((symbol) => resolveConstIdentifierAlias(symbol.bindingIdentifier, scopes)?.id === rootSymbol.id);
+	symbolsByRootId.set(rootSymbol.id, equivalentSymbols);
+	return equivalentSymbols;
+};
+const findExecutionBoundary = (node) => {
+	let current = node;
+	while (current) {
+		if (isFunctionLike$2(current) || isNodeOfType(current, "Program")) return current;
+		current = current.parent ?? null;
+	}
+	return null;
+};
+const isOnUnconditionalPath = (node, boundary) => {
+	let current = node.parent ?? null;
+	while (current && current !== boundary) {
+		if (CONDITIONAL_EXECUTION_NODE_TYPES.has(current.type)) return false;
+		current = current.parent ?? null;
+	}
+	return current === boundary;
+};
+const findFunctionBindingIdentifier = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration")) return functionNode.id ?? null;
+	const parent = functionNode.parent;
+	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.init === functionNode && isNodeOfType(parent.id, "Identifier")) return parent.id;
+	return null;
+};
+const findDirectCall = (identifier) => {
+	let callee = identifier;
+	let parent = callee.parent;
+	while (parent && stripParenExpression(parent) === identifier) {
+		callee = parent;
+		parent = callee.parent;
+	}
+	return parent && isNodeOfType(parent, "CallExpression") && parent.callee === callee ? parent : null;
+};
+const isFunctionSynchronouslyInvokedBefore = (functionNode, referenceNode, scopes, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
+	if (visitedFunctionNodes.has(functionNode) || !isFunctionLike$2(functionNode) || functionNode.generator) return false;
+	visitedFunctionNodes.add(functionNode);
+	const referenceBoundary = findExecutionBoundary(referenceNode);
+	if (!referenceBoundary) return false;
+	const invocationCalls = [];
+	const bindingIdentifier = findFunctionBindingIdentifier(functionNode);
+	if (bindingIdentifier) for (const symbol of getEquivalentSymbols(bindingIdentifier, scopes)) for (const reference of symbol.references) {
+		const call = findDirectCall(reference.identifier);
+		if (call) invocationCalls.push(call);
+	}
+	else {
+		const call = findDirectCall(functionNode);
+		if (call) invocationCalls.push(call);
+	}
+	return invocationCalls.some((call) => {
+		if (call.range[0] >= referenceNode.range[0]) return false;
+		const callBoundary = findExecutionBoundary(call);
+		if (!callBoundary) return false;
+		if (callBoundary === referenceBoundary) return true;
+		if (!isFunctionLike$2(callBoundary)) return false;
+		return isFunctionSynchronouslyInvokedBefore(callBoundary, referenceNode, scopes, new Set(visitedFunctionNodes));
+	});
+};
+const isMemberWriteTarget = (memberExpression) => {
+	const parent = memberExpression.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "AssignmentExpression")) return parent.left === memberExpression;
+	if (isNodeOfType(parent, "UpdateExpression")) return parent.argument === memberExpression;
+	return isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === memberExpression;
+};
+const symbolHasStaticPropertyWriteBefore = (symbol, propertyName, referenceNode, scopes) => symbol.references.some((reference) => {
+	let parent = reference.identifier.parent;
+	while (parent && stripParenExpression(parent) === reference.identifier) parent = parent.parent;
+	if (!parent || !isNodeOfType(parent, "MemberExpression") || stripParenExpression(parent.object) !== reference.identifier || getResolvedStaticPropertyName(parent, scopes) !== propertyName || !isMemberWriteTarget(parent)) return false;
+	const writeBoundary = findExecutionBoundary(parent);
+	const referenceBoundary = findExecutionBoundary(referenceNode);
+	if (!writeBoundary || !referenceBoundary || !isOnUnconditionalPath(parent, writeBoundary)) return false;
+	if (writeBoundary === referenceBoundary) return parent.range[0] < referenceNode.range[0];
+	return isFunctionLike$2(writeBoundary) && isFunctionSynchronouslyInvokedBefore(writeBoundary, referenceNode, scopes);
+});
+const hasStaticPropertyWriteBefore = (identifier, propertyName, referenceNode, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	return getEquivalentSymbols(identifier, scopes).some((symbol) => symbolHasStaticPropertyWriteBefore(symbol, propertyName, referenceNode, scopes));
+};
+//#endregion
+//#region src/plugin/utils/has-symbol-write-before.ts
+const hasSymbolWriteBefore = (symbol, referenceNode, scopes) => symbol.references.some((reference) => {
+	if (reference.flag === "read") return false;
+	const writeFunction = findEnclosingFunction(reference.identifier);
+	if (writeFunction === findEnclosingFunction(referenceNode)) return reference.identifier.range[0] < referenceNode.range[0];
+	if (!writeFunction) return true;
+	return isFunctionSynchronouslyInvokedBefore(writeFunction, referenceNode, scopes);
+});
+//#endregion
+//#region src/plugin/utils/has-stable-call-target.ts
+const hasStableCallTarget = (callExpression, scopes) => {
+	if (!isNodeOfType(callExpression, "CallExpression")) return false;
+	const callee = stripParenExpression(callExpression.callee);
+	if (isNodeOfType(callee, "Identifier")) {
+		const symbol = scopes.symbolFor(callee);
+		return Boolean(symbol && !hasSymbolWriteBefore(symbol, callee, scopes));
+	}
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(callee);
+	const receiver = stripParenExpression(callee.object);
+	return Boolean(propertyName && isNodeOfType(receiver, "Identifier") && !hasStaticPropertyWriteBefore(receiver, propertyName, callee, scopes));
+};
+//#endregion
 //#region src/plugin/utils/function-contains-react-render-output.ts
 const NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES = new Set([
 	"FunctionDeclaration",
@@ -27703,19 +28623,68 @@ const REACT_CREATE_ELEMENT_OPTIONS = {
 	allowGlobalReactNamespace: false,
 	allowUnboundBareCalls: false
 };
-const isCallArgumentFunctionExpression = (node) => {
+const LODASH_SORT_BY_MODULE_SOURCES = new Set([
+	"lodash/sortBy",
+	"lodash/sortBy.js",
+	"lodash-es/sortBy",
+	"lodash-es/sortBy.js"
+]);
+const isArrayTypeAnnotation = (node) => {
+	if (isNodeOfType(node, "TSArrayType") || isNodeOfType(node, "TSTupleType")) return true;
+	if (!isNodeOfType(node, "TSTypeReference")) return false;
+	return isNodeOfType(node.typeName, "Identifier") && (node.typeName.name === "Array" || node.typeName.name === "ReadonlyArray");
+};
+const hasArrayTypeAnnotation = (identifier) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const typeAnnotation = identifier.typeAnnotation;
+	return Boolean(typeAnnotation && isNodeOfType(typeAnnotation, "TSTypeAnnotation") && isArrayTypeAnnotation(typeAnnotation.typeAnnotation));
+};
+const isProvenArrayProducerCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const symbol = scopes.symbolFor(callee);
+	if (!symbol || hasSymbolWriteBefore(symbol, callee, scopes)) return false;
+	if (!isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") && !isNodeOfType(symbol.declarationNode, "ImportSpecifier")) return false;
+	const importBinding = getImportBindingForName(callee, callee.name);
+	if (!importBinding || importBinding.isNamespace) return false;
+	if (LODASH_SORT_BY_MODULE_SOURCES.has(importBinding.source) && importBinding.exportedName === "default") return true;
+	return (importBinding.source === "lodash" || importBinding.source === "lodash-es") && importBinding.exportedName === "sortBy";
+};
+const isProvenArrayExpression = (expression, scopes, referenceNode, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "ArrayExpression")) return true;
+	if (isProvenArrayProducerCall(candidate, scopes)) return true;
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, referenceNode, scopes)) return false;
+	if (hasArrayTypeAnnotation(symbol.bindingIdentifier)) return true;
+	if (!symbol.initializer) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isProvenArrayExpression(symbol.initializer, scopes, referenceNode, visitedSymbolIds);
+};
+const isProvenArrayMapCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || getStaticPropertyName(callee) !== "map") return false;
+	const receiver = stripParenExpression(callee.object);
+	if (!isProvenArrayExpression(receiver, scopes, node)) return false;
+	return !(isNodeOfType(receiver, "Identifier") && hasStaticPropertyWriteBefore(receiver, "map", node, scopes));
+};
+const isRenderPreservingCallArgumentFunction = (node, scopes) => {
 	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return false;
 	const parent = node.parent;
 	if (!isNodeOfType(parent, "CallExpression")) return false;
-	return parent.arguments.some((argumentNode) => argumentNode === node);
+	if (isReactApiCall(parent, "useMemo", scopes, { resolveNamedAliases: true }) && hasStableCallTarget(parent, scopes)) return parent.arguments[0] === node;
+	return parent.arguments.some((argumentNode) => argumentNode === node) && isProvenArrayMapCall(parent, scopes);
 };
-const isNestedRenderEvidenceBoundary = (node) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isCallArgumentFunctionExpression(node);
+const isNestedRenderEvidenceBoundary = (node, scopes) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isRenderPreservingCallArgumentFunction(node, scopes);
 const isRenderOutputExpression = (node, scopes) => node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS);
 const containsRenderOutput$1 = (rootNode, scopes) => {
 	let hasRenderOutput = false;
 	walkAst(rootNode, (node) => {
 		if (hasRenderOutput) return false;
-		if (node !== rootNode && isNestedRenderEvidenceBoundary(node)) return false;
+		if (node !== rootNode && isNestedRenderEvidenceBoundary(node, scopes)) return false;
 		if (isRenderOutputExpression(node, scopes)) {
 			hasRenderOutput = true;
 			return false;
@@ -27724,12 +28693,13 @@ const containsRenderOutput$1 = (rootNode, scopes) => {
 	return hasRenderOutput;
 };
 const renderOutputCache = /* @__PURE__ */ new WeakMap();
-const functionContainsReactRenderOutput = (functionNode, scopes) => {
+const functionContainsReactRenderOutput = (functionNode, scopes, controlFlow) => {
 	const cachedEntry = renderOutputCache.get(functionNode);
-	if (cachedEntry && cachedEntry.scopes === scopes) return cachedEntry.hasRenderOutput;
-	const hasRenderOutput = containsRenderOutput$1(functionNode, scopes) || functionReturnsMatchingExpression(functionNode, scopes, (expression) => isRenderOutputExpression(expression, scopes));
+	if (cachedEntry && cachedEntry.scopes === scopes && cachedEntry.controlFlow === controlFlow) return cachedEntry.hasRenderOutput;
+	const hasRenderOutput = functionReturnsMatchingExpression(functionNode, scopes, (expression) => containsRenderOutput$1(expression, scopes), controlFlow);
 	renderOutputCache.set(functionNode, {
 		scopes,
+		controlFlow,
 		hasRenderOutput
 	});
 	return hasRenderOutput;
@@ -27745,8 +28715,8 @@ const isComponentDeclaration = (node) => isNodeOfType(node, "FunctionDeclaration
 const message = (name) => `\`${name}\` is a component, so calling it as a plain function (\`${name}(...)\`) runs it outside React: its hooks break, it gets no fiber/state, and memoization is lost. Render it as \`<${name} />\` instead.`;
 const symbolIsLocalComponent = (symbol, context) => {
 	const declaration = symbol.declarationNode;
-	if (isComponentDeclaration(declaration)) return functionContainsReactRenderOutput(declaration, context.scopes);
-	if (isComponentAssignment(declaration) && symbol.initializer) return functionContainsReactRenderOutput(symbol.initializer, context.scopes);
+	if (isComponentDeclaration(declaration)) return functionContainsReactRenderOutput(declaration, context.scopes, context.cfg);
+	if (isComponentAssignment(declaration) && symbol.initializer) return functionContainsReactRenderOutput(symbol.initializer, context.scopes, context.cfg);
 	return false;
 };
 const isModuleScopeDeclaration = (declaration) => {
@@ -27844,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
@@ -28364,7 +29084,7 @@ const noCreateRefInFunctionComponent = defineRule({
 		if (!enclosingFunction) return;
 		const displayName = componentOrHookDisplayNameForFunction(enclosingFunction);
 		if (!displayName) return;
-		if (!(isReactHookName(displayName) || functionContainsReactRenderOutput(enclosingFunction, context.scopes))) return;
+		if (!(isReactHookName(displayName) || functionContainsReactRenderOutput(enclosingFunction, context.scopes, context.cfg))) return;
 		context.report({
 			node,
 			message: MESSAGE$30
@@ -29982,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 = [];
@@ -30868,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({
@@ -32252,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",
@@ -32853,7 +33579,7 @@ const noGiantComponent = defineRule({
 			FunctionDeclaration(node) {
 				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
 				if (getOversizedComponentLineCount(node) === null) return;
-				if (!functionContainsReactRenderOutput(node, context.scopes)) return;
+				if (!functionContainsReactRenderOutput(node, context.scopes, context.cfg)) return;
 				reportOversizedComponent(node.id, node.id.name);
 			},
 			VariableDeclarator(node) {
@@ -32861,7 +33587,7 @@ const noGiantComponent = defineRule({
 				const functionNode = unwrapReactHocFunction(node.init);
 				if (!functionNode) return;
 				if (getOversizedComponentLineCount(functionNode) === null) return;
-				if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
+				if (!functionContainsReactRenderOutput(functionNode, context.scopes, context.cfg)) return;
 				reportOversizedComponent(node.id, node.id.name);
 			}
 		};
@@ -33499,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",
@@ -35141,7 +35847,7 @@ const noManyBooleanProps = defineRule({
 			if (!param) return;
 			const propsBinding = resolveFirstArgumentBinding(param);
 			if (!propsBinding) return;
-			if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
+			if (!functionContainsReactRenderOutput(functionNode, context.scopes, context.cfg)) return;
 			if (isNodeOfType(propsBinding, "ObjectPattern")) {
 				const callbackUsedNames = collectCallbackUsedNames(body, param, context.scopes);
 				const booleanLikePropNames = [];
@@ -38103,6 +38809,174 @@ const noPropCallbackInRender = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-proven-react-class-component.ts
+const REACT_COMPONENT_CLASS_NAMES = new Set(["Component", "PureComponent"]);
+const isReactComponentClassValue = (node, scopes, visitedClassNodes, visitedSymbolIds) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "MemberExpression")) {
+		const propertyName = getStaticPropertyName(expression);
+		const receiver = stripParenExpression(expression.object);
+		return Boolean(propertyName && REACT_COMPONENT_CLASS_NAMES.has(propertyName) && isNodeOfType(receiver, "Identifier") && !hasStaticPropertyWriteBefore(receiver, propertyName, expression, scopes) && isReactNamespaceImport(receiver, scopes));
+	}
+	if (isNodeOfType(expression, "ClassExpression")) return isProvenReactClassComponent(expression, scopes, visitedClassNodes, visitedSymbolIds);
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, expression, scopes)) return false;
+	visitedSymbolIds.add(symbol.id);
+	if (isImportedFromReact(symbol)) {
+		const importedName = getImportedName(symbol.declarationNode);
+		return Boolean(importedName && REACT_COMPONENT_CLASS_NAMES.has(importedName));
+	}
+	if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes, visitedClassNodes, visitedSymbolIds);
+	return Boolean(symbol.kind === "const" && symbol.initializer && isReactComponentClassValue(symbol.initializer, scopes, visitedClassNodes, visitedSymbolIds));
+};
+const isProvenReactClassComponent = (classNode, scopes, visitedClassNodes = /* @__PURE__ */ new Set(), visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression") || visitedClassNodes.has(classNode) || !classNode.superClass) return false;
+	visitedClassNodes.add(classNode);
+	return isReactComponentClassValue(classNode.superClass, scopes, visitedClassNodes, visitedSymbolIds);
+};
+//#endregion
+//#region src/plugin/utils/function-contains-proven-react-hook-call.ts
+const functionContainsProvenReactHookCall = (functionNode, scopes) => {
+	if (!isFunctionLike$2(functionNode)) return false;
+	let containsReactHookCall = false;
+	walkAst(functionNode.body, (node) => {
+		if (containsReactHookCall) return false;
+		if (node !== functionNode.body && (isFunctionLike$2(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (isNodeOfType(node, "CallExpression") && isReactApiCall(node, BUILTIN_HOOK_NAMES, scopes, { resolveNamedAliases: true })) {
+			containsReactHookCall = true;
+			return false;
+		}
+	});
+	return containsReactHookCall;
+};
+//#endregion
+//#region src/plugin/utils/function-returns-props-children.ts
+const functionReturnsPropsChildren = (functionNode, scopes, controlFlow) => {
+	if (!isFunctionLike$2(functionNode) || functionNode.params.length === 0) return false;
+	const firstParameter = stripParenExpression(functionNode.params[0]);
+	const firstParameterPattern = isNodeOfType(firstParameter, "AssignmentPattern") ? stripParenExpression(firstParameter.left) : firstParameter;
+	const propsParameterSymbol = isNodeOfType(firstParameterPattern, "Identifier") ? scopes.symbolFor(firstParameterPattern) : null;
+	const childrenBindingSymbolIds = /* @__PURE__ */ new Set();
+	if (isNodeOfType(firstParameterPattern, "ObjectPattern")) {
+		for (const property of firstParameterPattern.properties) if (isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "children") {
+			const propertyValue = stripParenExpression(property.value);
+			const childrenBinding = isNodeOfType(propertyValue, "AssignmentPattern") ? stripParenExpression(propertyValue.left) : propertyValue;
+			if (!isNodeOfType(childrenBinding, "Identifier")) continue;
+			const childrenBindingSymbol = scopes.symbolFor(childrenBinding);
+			if (childrenBindingSymbol) childrenBindingSymbolIds.add(childrenBindingSymbol.id);
+		}
+	}
+	return functionReturnsMatchingExpression(functionNode, scopes, (expression) => {
+		const candidate = stripParenExpression(expression);
+		if (isNodeOfType(candidate, "Identifier")) {
+			const symbol = scopes.symbolFor(candidate);
+			return Boolean(symbol && childrenBindingSymbolIds.has(symbol.id) && !hasSymbolWriteBefore(symbol, candidate, scopes));
+		}
+		if (!isNodeOfType(candidate, "MemberExpression")) return false;
+		if (getStaticPropertyName(candidate) !== "children") return false;
+		const receiver = stripParenExpression(candidate.object);
+		if (!isNodeOfType(receiver, "Identifier")) return false;
+		const receiverSymbol = scopes.symbolFor(receiver);
+		if (!receiverSymbol || !propsParameterSymbol) return false;
+		return receiverSymbol.id === propsParameterSymbol.id && !hasSymbolWriteBefore(receiverSymbol, candidate, scopes) && !hasStaticPropertyWriteBefore(receiver, "children", candidate, scopes);
+	}, controlFlow);
+};
+//#endregion
+//#region src/plugin/utils/function-returns-only-null.ts
+const isNullExpression = (expression) => {
+	const candidate = stripParenExpression(expression);
+	return isNodeOfType(candidate, "Literal") && candidate.value === null;
+};
+const functionReturnsOnlyNull = (functionNode) => {
+	if (!isFunctionLike$2(functionNode)) return false;
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isNullExpression(functionNode.body);
+	const returnStatements = collectFunctionReturnStatements(functionNode);
+	return returnStatements.length > 0 && returnStatements.every((returnStatement) => Boolean(returnStatement.argument && isNullExpression(returnStatement.argument)));
+};
+//#endregion
+//#region src/plugin/utils/is-proven-styled-component-expression.ts
+const findFactoryRoot = (node) => {
+	const candidate = stripParenExpression(node);
+	if (isNodeOfType(candidate, "Identifier")) return candidate;
+	if (isNodeOfType(candidate, "MemberExpression")) return findFactoryRoot(candidate.object);
+	if (isNodeOfType(candidate, "CallExpression")) return findFactoryRoot(candidate.callee);
+	return null;
+};
+const findFactoryPropertyName = (node) => {
+	const candidate = stripParenExpression(node);
+	if (isNodeOfType(candidate, "MemberExpression")) return findFactoryPropertyName(candidate.object) ?? getStaticPropertyName(candidate);
+	if (isNodeOfType(candidate, "CallExpression")) return findFactoryPropertyName(candidate.callee);
+	return null;
+};
+const isProvenStyledComponentExpression = (expression, scopes) => {
+	const candidate = stripParenExpression(expression);
+	if (!isNodeOfType(candidate, "TaggedTemplateExpression")) return false;
+	const factoryRoot = findFactoryRoot(candidate.tag);
+	if (!factoryRoot) return false;
+	const factoryPropertyName = findFactoryPropertyName(candidate.tag);
+	if (factoryPropertyName && hasStaticPropertyWriteBefore(factoryRoot, factoryPropertyName, candidate, scopes)) return false;
+	const symbol = resolveConstIdentifierAlias(factoryRoot, scopes);
+	if (!symbol || symbol.kind !== "import") return false;
+	if (!(isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || getImportedName(symbol.declarationNode) === "styled")) return false;
+	const importDeclaration = symbol.declarationNode.parent;
+	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "styled-components");
+};
+//#endregion
+//#region src/plugin/utils/is-proven-react-component-symbol.ts
+const REACT_COMPONENT_HOC_NAMES = new Set(["memo", "forwardRef"]);
+const functionHasComponentEvidence = (functionNode, scopes, controlFlow) => functionContainsReactRenderOutput(functionNode, scopes, controlFlow) || functionReturnsPropsChildren(functionNode, scopes, controlFlow) || functionContainsProvenReactHookCall(functionNode, scopes) && functionReturnsOnlyNull(functionNode);
+const isProvenReactComponentExpression = (expression, scopes, controlFlow, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isInlineFunctionExpression(candidate)) return functionHasComponentEvidence(candidate, scopes, controlFlow);
+	if (isNodeOfType(candidate, "ClassExpression")) return isProvenReactClassComponent(candidate, scopes);
+	if (isProvenStyledComponentExpression(candidate, scopes)) return true;
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = scopes.symbolFor(candidate);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, candidate, scopes)) return false;
+		visitedSymbolIds.add(symbol.id);
+		if (isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return functionHasComponentEvidence(symbol.declarationNode, scopes, controlFlow);
+		if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes);
+		return Boolean(symbol.initializer && isProvenReactComponentExpression(symbol.initializer, scopes, controlFlow, visitedSymbolIds));
+	}
+	if (!isNodeOfType(candidate, "CallExpression")) return false;
+	if (!hasStableCallTarget(candidate, scopes)) return false;
+	if (isReactApiCall(candidate, REACT_COMPONENT_HOC_NAMES, scopes, { resolveNamedAliases: true })) {
+		const wrappedComponent = candidate.arguments[0];
+		return Boolean(wrappedComponent && !isNodeOfType(wrappedComponent, "SpreadElement") && isProvenReactComponentExpression(wrappedComponent, scopes, controlFlow, visitedSymbolIds));
+	}
+	if (!isReactApiCall(candidate, "useMemo", scopes, { resolveNamedAliases: true })) return false;
+	const factory = candidate.arguments[0];
+	if (!factory || isNodeOfType(factory, "SpreadElement")) return false;
+	const unwrappedFactory = stripParenExpression(factory);
+	if (!isInlineFunctionExpression(unwrappedFactory)) return false;
+	if (!isNodeOfType(unwrappedFactory.body, "BlockStatement")) return isProvenReactComponentExpression(unwrappedFactory.body, scopes, controlFlow, visitedSymbolIds);
+	const returnStatements = collectFunctionReturnStatements(unwrappedFactory);
+	const returnedExpression = returnStatements[0]?.argument;
+	return Boolean(returnStatements.length === 1 && returnedExpression && isProvenReactComponentExpression(returnedExpression, scopes, controlFlow, visitedSymbolIds));
+};
+const isProvenReactComponentSymbol = (symbol, scopes, controlFlow, componentReference) => {
+	const candidateSymbols = symbol.kind === "ts-module" ? symbol.scope.symbols.filter((candidateSymbol) => candidateSymbol.name === symbol.name && candidateSymbol.kind !== "ts-module") : [symbol];
+	for (const candidateSymbol of candidateSymbols) {
+		if (hasSymbolWriteBefore(candidateSymbol, componentReference, scopes)) continue;
+		if (isComponentDeclaration(candidateSymbol.declarationNode)) {
+			if (functionHasComponentEvidence(candidateSymbol.declarationNode, scopes, controlFlow)) return true;
+			continue;
+		}
+		const initializer = candidateSymbol.initializer ? stripParenExpression(candidateSymbol.initializer) : null;
+		if (isNodeOfType(candidateSymbol.declarationNode, "VariableDeclarator") && isNodeOfType(candidateSymbol.declarationNode.id, "Identifier") && isUppercaseName(candidateSymbol.declarationNode.id.name) && initializer) {
+			if (isProvenReactComponentExpression(initializer, scopes, controlFlow)) return true;
+			continue;
+		}
+		if (isNodeOfType(candidateSymbol.declarationNode, "ClassDeclaration") || isNodeOfType(candidateSymbol.declarationNode, "ClassExpression")) {
+			if (isProvenReactClassComponent(candidateSymbol.declarationNode, scopes)) return true;
+			continue;
+		}
+		if (initializer && isNodeOfType(initializer, "ClassExpression") && isProvenReactClassComponent(initializer, scopes)) return true;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/architecture/no-prop-types.ts
 const PROP_TYPES_PROPERTY = "propTypes";
 const isPropTypesKey = (key, computed) => {
@@ -38110,20 +38984,19 @@ const isPropTypesKey = (key, computed) => {
 	if (computed) return isNodeOfType(key, "Literal") && key.value === PROP_TYPES_PROPERTY;
 	return isNodeOfType(key, "Identifier") && key.name === PROP_TYPES_PROPERTY;
 };
-const getComponentNameFromPropTypesAssignment = (left) => {
+const getComponentFromPropTypesAssignment = (left) => {
 	if (!isNodeOfType(left, "MemberExpression")) return null;
 	if (!isPropTypesKey(left.property, Boolean(left.computed))) return null;
-	if (!isNodeOfType(left.object, "Identifier")) return null;
-	if (!isUppercaseName(left.object.name)) return null;
-	return left.object.name;
+	const receiver = stripParenExpression(left.object);
+	if (!isNodeOfType(receiver, "Identifier")) return null;
+	if (!isUppercaseName(receiver.name)) return null;
+	return receiver;
 };
-const getComponentNameFromClassProperty = (node) => {
+const getComponentNameFromClassProperty = (node, scopes) => {
 	if (!node.static) return null;
 	if (!isPropTypesKey(node.key, Boolean(node.computed))) return null;
-	const classBody = node.parent;
-	if (!isNodeOfType(classBody, "ClassBody")) return null;
-	const classNode = classBody.parent;
-	if (!classNode) return null;
+	const classNode = isNodeOfType(node.parent, "ClassBody") ? node.parent.parent : null;
+	if (!classNode || !isProvenReactClassComponent(classNode, scopes)) return null;
 	if ((isNodeOfType(classNode, "ClassDeclaration") || isNodeOfType(classNode, "ClassExpression")) && classNode.id?.name && isUppercaseName(classNode.id.name)) return classNode.id.name;
 	if (!isNodeOfType(classNode, "ClassExpression")) return null;
 	const declarator = classNode.parent;
@@ -38144,15 +39017,17 @@ const noPropTypes = defineRule({
 	create: (context) => ({
 		AssignmentExpression(node) {
 			if (node.operator !== "=") return;
-			const componentName = getComponentNameFromPropTypesAssignment(node.left);
-			if (!componentName) return;
+			const component = getComponentFromPropTypesAssignment(node.left);
+			if (!component) return;
+			const symbol = context.scopes.symbolFor(component);
+			if (!symbol || !isProvenReactComponentSymbol(symbol, context.scopes, context.cfg, component)) return;
 			context.report({
 				node: node.left,
-				message: buildMessage$11(componentName)
+				message: buildMessage$11(component.name)
 			});
 		},
 		PropertyDefinition(node) {
-			const componentName = getComponentNameFromClassProperty(node);
+			const componentName = getComponentNameFromClassProperty(node, context.scopes);
 			if (!componentName) return;
 			context.report({
 				node: node.key,
@@ -40313,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);
@@ -40331,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;
@@ -40630,7 +41504,7 @@ const noThisInSfc = defineRule({
 			const enclosingFunction = findEnclosingFunctionComponent(node);
 			if (!enclosingFunction) return;
 			if (!looksLikeFunctionComponent(enclosingFunction)) return;
-			if (!functionContainsReactRenderOutput(enclosingFunction, context.scopes)) return;
+			if (!functionContainsReactRenderOutput(enclosingFunction, context.scopes, context.cfg)) return;
 			if (functionHasOwnThisMemberWrite(enclosingFunction)) return;
 			context.report({
 				node,
@@ -42295,21 +43169,21 @@ const expressionContainsJsxOrCreateElement = (root) => {
 	});
 	return found;
 };
-const functionContainsJsxOrCreateElement = (functionNode, scopes) => expressionContainsJsxOrCreateElement(functionNode) || functionReturnsMatchingExpression(functionNode, scopes, expressionContainsJsxOrCreateElement);
+const functionContainsJsxOrCreateElement = (functionNode, scopes, controlFlow) => expressionContainsJsxOrCreateElement(functionNode) || functionReturnsMatchingExpression(functionNode, scopes, expressionContainsJsxOrCreateElement, controlFlow);
 const isReactClassComponent = (classNode) => {
 	if (isEs6Component(classNode)) return true;
 	return expressionContainsJsxOrCreateElement(classNode);
 };
-const findEnclosingComponent = (node, scopes) => {
+const findEnclosingComponent = (node, scopes, controlFlow) => {
 	let walker = node.parent;
 	while (walker) {
 		if (isFunctionLike$2(walker)) {
 			const componentName = inferFunctionLikeName(walker);
-			if (componentName && isReactComponentName(componentName) && functionContainsJsxOrCreateElement(walker, scopes)) return {
+			if (componentName && isReactComponentName(componentName) && functionContainsJsxOrCreateElement(walker, scopes, controlFlow)) return {
 				component: walker,
 				name: componentName
 			};
-			if (!componentName && functionContainsJsxOrCreateElement(walker, scopes) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
+			if (!componentName && functionContainsJsxOrCreateElement(walker, scopes, controlFlow) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
 				component: walker,
 				name: null
 			};
@@ -42548,7 +43422,7 @@ const noUnstableNestedComponents = defineRule({
 				if (renderPropRegex.test(propInfo.propName)) return;
 				if (settings.allowAsProps) return;
 			}
-			const enclosing = findEnclosingComponent(candidateNode, context.scopes);
+			const enclosing = findEnclosingComponent(candidateNode, context.scopes, context.cfg);
 			if (!enclosing) return;
 			const gatedName = propInfo ? null : requiredInstantiationName;
 			queuedReports.push({
@@ -42559,7 +43433,7 @@ const noUnstableNestedComponents = defineRule({
 			});
 		};
 		const checkFunctionLike = (node) => {
-			if (!functionContainsJsxOrCreateElement(node, context.scopes)) return;
+			if (!functionContainsJsxOrCreateElement(node, context.scopes, context.cfg)) return;
 			const inferredName = inferFunctionLikeName(node);
 			const propInfo = isComponentDeclaredInProp(node);
 			const isObjectCallback = isObjectCallbackCandidate(node);
@@ -43170,7 +44044,7 @@ const objectExpressionBundlesComponents = (objectExpression, state) => {
 			continue;
 		}
 		if (!(!property.computed && isNodeOfType(property.key, "Identifier") && isReactComponentName(property.key.name))) continue;
-		if ((isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) && functionContainsReactRenderOutput(value, state.scopes)) return true;
+		if ((isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) && functionContainsReactRenderOutput(value, state.scopes, state.controlFlow)) return true;
 		if (isNodeOfType(value, "CallExpression") && isHocCallee(value.callee, state) && value.arguments.length > 0) return true;
 	}
 	return false;
@@ -43280,11 +44154,12 @@ const onlyExportComponents = defineRule({
 					allowExportNames: new Set(settings.allowExportNames),
 					allowConstantExport: settings.allowConstantExport,
 					localComponentNames,
-					scopes: context.scopes
+					scopes: context.scopes,
+					controlFlow: context.cfg
 				};
 				for (const child of componentCandidates) {
 					if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes)) localComponentNames.add(child.id.name);
+						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes, context.cfg)) localComponentNames.add(child.id.name);
 					}
 					if (isNodeOfType(child, "ClassDeclaration") && child.id) {
 						if (isReactComponentName(child.id.name) && isEs6Component(child) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
@@ -43293,7 +44168,7 @@ const onlyExportComponents = defineRule({
 						const initializer = child.init;
 						if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) {
 							const expression = initializer ? skipTsExpression(initializer) : null;
-							if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes)) localComponentNames.add(child.id.name);
+							if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes, context.cfg)) localComponentNames.add(child.id.name);
 						}
 					}
 				}
@@ -44793,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;
@@ -44879,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;
@@ -44897,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;
@@ -46443,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) => {
@@ -47515,10 +48465,10 @@ const rerenderLazyStateInit = defineRule({
 //#endregion
 //#region src/plugin/rules/performance/rerender-memo-before-early-return.ts
 const isJsxExpression = (node) => Boolean(node && isJsxElementOrFragment(stripParenExpression(node)));
-const callbackReturnsJsx = (callback, scopes) => {
+const callbackReturnsJsx = (callback, scopes, controlFlow) => {
 	if (!callback) return false;
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	return functionReturnsMatchingExpression(callback, scopes, isJsxExpression);
+	return functionReturnsMatchingExpression(callback, scopes, isJsxExpression, controlFlow);
 };
 const returnArgumentUsesAnyName = (returnStatement, names) => {
 	if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return false;
@@ -47596,7 +48546,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 					if (!isNodeOfType(stmt, "VariableDeclaration")) continue;
 					for (const declarator of stmt.declarations ?? []) {
 						const init = declarator.init;
-						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0], context.scopes)) {
+						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0], context.scopes, context.cfg)) {
 							memoNode = declarator;
 							callbackGuardTests = collectLeadingCallbackGuardTests(init.arguments?.[0]);
 							if (isNodeOfType(declarator.id, "Identifier")) memoConsumerNames.add(declarator.id.name);
@@ -48132,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",
@@ -57307,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;
@@ -57321,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,