oxlint-plugin-react-doctor 0.7.9-dev.842a55f → 0.7.9-dev.95f9937

package/dist/index.js

@@ -1237,13 +1237,12 @@ const stripParenExpression = (node) => {
 };
 //#endregion
 //#region src/plugin/utils/resolve-const-identifier-alias.ts
-const resolveConstIdentifierAlias = (identifier, scopes, allowPatternBinding = false) => {
+const resolveConstIdentifierAlias = (identifier, scopes) => {
 	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
 	const visitedSymbolIds = /* @__PURE__ */ new Set();
 	let symbol = scopes.symbolFor(identifier);
 	while (symbol?.kind === "const") {
-		if (visitedSymbolIds.has(symbol.id) || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return null;
-		if (symbol.declarationNode.id !== symbol.bindingIdentifier) return allowPatternBinding ? symbol : null;
+		if (visitedSymbolIds.has(symbol.id) || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
 		visitedSymbolIds.add(symbol.id);
 		const initializer = stripParenExpression(symbol.initializer);
 		if (!isNodeOfType(initializer, "Identifier")) return symbol;
@@ -6737,28 +6736,6 @@ const asyncParallel = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/collect-function-return-statements.ts
-const collectFunctionReturnStatements = (functionNode) => {
-	if (!isFunctionLike$1(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return [];
-	const returnStatements = [];
-	walkAst(functionNode.body, (node) => {
-		if (node !== functionNode.body && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
-		if (isNodeOfType(node, "ReturnStatement")) returnStatements.push(node);
-	});
-	return returnStatements;
-};
-//#endregion
-//#region src/plugin/utils/is-nullish-expression.ts
-const isNullishExpression = (expression) => isNodeOfType(expression, "Literal") && expression.value === null || isNodeOfType(expression, "Identifier") && expression.name === "undefined" || isNodeOfType(expression, "UnaryExpression") && expression.operator === "void";
-//#endregion
-//#region src/plugin/utils/strip-this-parameter.ts
-const stripThisParameter = (parameters) => {
-	const firstParameter = parameters[0];
-	if (!firstParameter) return parameters;
-	if (isNodeOfType(firstParameter, "Identifier") && firstParameter.name === "this") return parameters.slice(1);
-	return parameters;
-};
-//#endregion
 //#region src/plugin/rules/security/auth-token-in-web-storage.ts
 const MESSAGE$60 = "Storing an auth token in `localStorage`/`sessionStorage` exposes it to any XSS on the page: JavaScript can read web storage and exfiltrate the token. Keep tokens in an `HttpOnly`, `Secure`, `SameSite` cookie instead.";
 const STORAGE_NAMES = new Set(["localStorage", "sessionStorage"]);
@@ -6770,8 +6747,12 @@ const STORAGE_GLOBALS = new Set([
 const SENSITIVE_KEY_PATTERN = /token|jwt|secret|password|passwd|credential|api[-_]?key|bearer|private[-_]?key/i;
 const NON_AUTH_TOKEN_PATTERN = /csrf|xsrf|device|fcm|apns|push|design|tokeniz|syntax|css|theme|color/i;
 const STRONG_AUTH_KEY_PATTERN = /jwt|secret|password|passwd|credential|private[-_]?key|api[-_]?key|bearer|access[-_]?token|refresh[-_]?token|auth[-_]?token|id[-_]?token|session/i;
+const PRODUCT_API_KEY_RECORDS_PATTERN = /(?:^|[._:-])(?:created|saved|integration|mailing)[-_]?api[-_]?keys$/i;
+const PRODUCT_API_KEY_COLLECTION_PATTERN = /[._:-](?:created|generated|saved)[-_]?api[-_]?keys$/i;
 const isAuthCredentialKey = (key) => {
+	if (PRODUCT_API_KEY_RECORDS_PATTERN.test(key)) return false;
 	if (!SENSITIVE_KEY_PATTERN.test(key)) return false;
+	if (PRODUCT_API_KEY_COLLECTION_PATTERN.test(key)) return false;
 	if (NON_AUTH_TOKEN_PATTERN.test(key) && !STRONG_AUTH_KEY_PATTERN.test(key)) return false;
 	return true;
 };
@@ -6780,63 +6761,11 @@ const isDirectWebStorageObject = (node) => {
 	if (isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.object, "Identifier") && STORAGE_GLOBALS.has(node.object.name) && isNodeOfType(node.property, "Identifier")) return STORAGE_NAMES.has(node.property.name);
 	return false;
 };
-const immutableInitializer = (identifier, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
-	if (visitedIdentifiers.has(identifier)) return null;
-	visitedIdentifiers.add(identifier);
-	const binding = findVariableInitializer(identifier, identifier.name);
-	if (!binding?.initializer) return null;
-	if (isNodeOfType(binding.initializer, "FunctionDeclaration")) return binding.initializer;
-	const declarator = binding.bindingIdentifier.parent;
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return null;
-	const declaration = declarator.parent;
-	if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) return null;
-	if (declaration.kind !== "const") return null;
-	const initializer = stripParenExpression(binding.initializer);
-	if (!isNodeOfType(initializer, "Identifier")) return initializer;
-	return immutableInitializer(initializer, visitedIdentifiers) ?? initializer;
-};
-const isWebStorageFactoryResult = (node, visitedNodes) => {
-	const expression = stripParenExpression(node);
-	if (isWebStorageObject(expression, new Set(visitedNodes))) return true;
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		const consequent = stripParenExpression(expression.consequent);
-		const alternate = stripParenExpression(expression.alternate);
-		return (isNullishExpression(consequent) || isWebStorageFactoryResult(consequent, visitedNodes)) && (isNullishExpression(alternate) || isWebStorageFactoryResult(alternate, visitedNodes)) && (!isNullishExpression(consequent) || !isNullishExpression(alternate));
-	}
-	if (isNodeOfType(expression, "LogicalExpression")) {
-		if (expression.operator === "&&") return isWebStorageFactoryResult(expression.right, visitedNodes);
-		const left = stripParenExpression(expression.left);
-		const right = stripParenExpression(expression.right);
-		const isLeftStorage = isWebStorageFactoryResult(left, visitedNodes);
-		const isRightStorage = isWebStorageFactoryResult(right, visitedNodes);
-		return (isLeftStorage || isNullishExpression(left)) && (isRightStorage || isNullishExpression(right)) && (isLeftStorage || isRightStorage);
-	}
-	return false;
-};
-const isWebStorageObject = (node, visitedNodes = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(node);
-	if (visitedNodes.has(expression)) return false;
-	visitedNodes.add(expression);
-	if (isDirectWebStorageObject(expression)) return true;
-	if (isNodeOfType(expression, "Identifier")) {
-		const initializer = immutableInitializer(expression);
-		return initializer ? isWebStorageObject(initializer, new Set(visitedNodes)) : false;
-	}
-	if (!isNodeOfType(expression, "CallExpression")) return false;
-	const callee = stripParenExpression(expression.callee);
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	const factory = immutableInitializer(callee);
-	if (!isFunctionLike$1(factory)) return false;
-	if (isNodeOfType(factory, "ArrowFunctionExpression") && !isNodeOfType(factory.body, "BlockStatement")) return isWebStorageFactoryResult(factory.body, visitedNodes);
-	let didReturnWebStorage = false;
-	for (const returnStatement of collectFunctionReturnStatements(factory)) {
-		if (!returnStatement.argument) continue;
-		const strippedReturn = stripParenExpression(returnStatement.argument);
-		if (isNullishExpression(strippedReturn)) continue;
-		if (!isWebStorageFactoryResult(strippedReturn, visitedNodes)) return false;
-		didReturnWebStorage = true;
-	}
-	return didReturnWebStorage;
+const isWebStorageObject = (node) => {
+	if (isDirectWebStorageObject(node)) return true;
+	if (!isNodeOfType(node, "Identifier")) return false;
+	const binding = findVariableInitializer(node, node.name);
+	return binding?.initializer ? isDirectWebStorageObject(binding.initializer) : false;
 };
 const resolveStaticKeyString = (node) => {
 	if (isNodeOfType(node, "Literal") && typeof node.value === "string") return node.value;
@@ -6856,56 +6785,6 @@ const staticMemberName = (member) => {
 	if (member.computed && isNodeOfType(member.property, "Literal") && typeof member.property.value === "string") return member.property.value;
 	return null;
 };
-const parameterIndex = (expression, parameterSymbolIds, scopes, canUnwrapSerialization, visitedNodes = /* @__PURE__ */ new Set()) => {
-	const strippedExpression = stripParenExpression(expression);
-	if (visitedNodes.has(strippedExpression)) return null;
-	visitedNodes.add(strippedExpression);
-	if (isNodeOfType(strippedExpression, "Identifier")) {
-		const directSymbolId = scopes.symbolFor(strippedExpression)?.id;
-		const directIndex = directSymbolId === void 0 ? -1 : parameterSymbolIds.indexOf(directSymbolId);
-		if (directIndex !== -1) return directIndex;
-		const initializer = immutableInitializer(strippedExpression);
-		return initializer ? parameterIndex(initializer, parameterSymbolIds, scopes, canUnwrapSerialization, visitedNodes) : null;
-	}
-	if (canUnwrapSerialization && isNodeOfType(strippedExpression, "CallExpression") && isNodeOfType(strippedExpression.callee, "MemberExpression") && !strippedExpression.callee.computed && isNodeOfType(strippedExpression.callee.object, "Identifier") && strippedExpression.callee.object.name === "JSON" && isNodeOfType(strippedExpression.callee.property, "Identifier") && strippedExpression.callee.property.name === "stringify") {
-		const serializedArgument = strippedExpression.arguments[0];
-		return serializedArgument ? parameterIndex(serializedArgument, parameterSymbolIds, scopes, true, visitedNodes) : null;
-	}
-	return null;
-};
-const storageHelperSinkCache = /* @__PURE__ */ new WeakMap();
-const findStorageHelperSinks = (functionNode, scopes) => {
-	const cachedSinks = storageHelperSinkCache.get(functionNode);
-	if (cachedSinks) return cachedSinks;
-	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) {
-		storageHelperSinkCache.set(functionNode, []);
-		return [];
-	}
-	const parameterSymbolIds = stripThisParameter(functionNode.params).map((parameter) => {
-		const strippedParameter = stripParenExpression(parameter);
-		const identifier = isNodeOfType(strippedParameter, "Identifier") ? strippedParameter : isNodeOfType(strippedParameter, "AssignmentPattern") && isNodeOfType(strippedParameter.left, "Identifier") ? strippedParameter.left : null;
-		return identifier ? scopes.symbolFor(identifier)?.id ?? null : null;
-	});
-	const helperSinks = [];
-	walkAst(functionNode.body, (child) => {
-		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = stripParenExpression(child.callee);
-		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "setItem" || !isWebStorageObject(callee.object)) return;
-		const keyExpression = child.arguments[0];
-		const valueExpression = child.arguments[1];
-		if (!keyExpression || !valueExpression) return;
-		const keyParameterIndex = parameterIndex(keyExpression, parameterSymbolIds, scopes, false);
-		const valueParameterIndex = parameterIndex(valueExpression, parameterSymbolIds, scopes, true);
-		if (keyParameterIndex === null || valueParameterIndex === null) return;
-		helperSinks.push({
-			keyParameterIndex,
-			valueParameterIndex
-		});
-	});
-	storageHelperSinkCache.set(functionNode, helperSinks);
-	return helperSinks;
-};
 const authTokenInWebStorage = defineRule({
 	id: "auth-token-in-web-storage",
 	title: "Auth token in web storage",
@@ -6913,23 +6792,14 @@ const authTokenInWebStorage = defineRule({
 	recommendation: "Don't persist auth tokens (JWTs, access/refresh tokens, secrets) in `localStorage`/`sessionStorage`; they're readable by any XSS. Use an `HttpOnly` cookie set by the server.",
 	create: skipNonProductionFiles((context) => ({
 		CallExpression(node) {
-			const callee = stripParenExpression(node.callee);
-			const keyArguments = [];
-			if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "setItem" && isWebStorageObject(stripParenExpression(callee.object))) {
-				const keyArgument = node.arguments[0];
-				if (keyArgument) keyArguments.push(keyArgument);
-			} else if (isNodeOfType(callee, "Identifier")) {
-				const helperFunction = immutableInitializer(callee);
-				const helperSinks = helperFunction ? findStorageHelperSinks(helperFunction, context.scopes) : [];
-				for (const helperSink of helperSinks) {
-					const keyArgument = node.arguments[helperSink.keyParameterIndex];
-					if (keyArgument && node.arguments[helperSink.valueParameterIndex]) keyArguments.push(keyArgument);
-				}
-			}
-			if (!keyArguments.some((keyArgument) => {
-				const keyString = resolveStaticKeyString(keyArgument);
-				return keyString !== null && isAuthCredentialKey(keyString);
-			})) return;
+			const callee = node.callee;
+			if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return;
+			if (!isNodeOfType(callee.property, "Identifier") || callee.property.name !== "setItem") return;
+			if (!isWebStorageObject(stripParenExpression(callee.object))) return;
+			const keyArgument = node.arguments?.[0];
+			if (!keyArgument) return;
+			const keyString = resolveStaticKeyString(keyArgument);
+			if (keyString === null || !isAuthCredentialKey(keyString)) return;
 			context.report({
 				node,
 				message: MESSAGE$60
@@ -7177,6 +7047,9 @@ const isCreateElementCall = (node) => {
 	return false;
 };
 //#endregion
+//#region src/plugin/utils/is-nullish-expression.ts
+const isNullishExpression = (expression) => isNodeOfType(expression, "Literal") && expression.value === null || isNodeOfType(expression, "Identifier") && expression.name === "undefined" || isNodeOfType(expression, "UnaryExpression") && expression.operator === "void";
+//#endregion
 //#region src/plugin/rules/react-builtins/button-has-type.ts
 const MISSING_MESSAGE$2 = "Your users can submit the form by accident because a `<button>` with no `type` defaults to submit.";
 const INVALID_MESSAGE = "This button has an invalid `type`, so the browser may treat it like a submit button.";
@@ -7638,7 +7511,6 @@ const areExpressionsStructurallyEqual = (a, b) => {
 	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, "PrivateIdentifier") && isNodeOfType(b, "PrivateIdentifier")) 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;
@@ -8694,6 +8566,17 @@ const createMethodMutationAnalysis = (context) => {
 //#region src/plugin/utils/is-member-property.ts
 const isMemberProperty = (node, propertyName) => Boolean(node && isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && node.property.name === propertyName);
 //#endregion
+//#region src/plugin/utils/collect-function-return-statements.ts
+const collectFunctionReturnStatements = (functionNode) => {
+	if (!isFunctionLike$1(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return [];
+	const returnStatements = [];
+	walkAst(functionNode.body, (node) => {
+		if (node !== functionNode.body && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (isNodeOfType(node, "ReturnStatement")) returnStatements.push(node);
+	});
+	return returnStatements;
+};
+//#endregion
 //#region src/plugin/utils/statement-always-exits.ts
 const statementAlwaysExits = (statement) => {
 	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement")) return true;
@@ -8960,7 +8843,7 @@ const isReactNamespaceImport = (identifier, scopes) => {
 	if (!symbol || !isImportedFromReact(symbol)) return false;
 	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier") || getImportedName(symbol.declarationNode) === "default";
 };
-const isReactNamespaceReceiver$1 = (receiver, scopes, options) => {
+const isReactNamespaceReceiver = (receiver, scopes, options) => {
 	if (!isNodeOfType(receiver, "Identifier")) return false;
 	if (isReactNamespaceImport(receiver, scopes)) return true;
 	return Boolean(options.allowGlobalReactNamespace && receiver.name === "React" && scopes.isGlobalReference(receiver));
@@ -8973,7 +8856,7 @@ const isDestructuredReactApiBinding = (identifier, apiNames, scopes, options) =>
 	for (const property of pattern.properties) {
 		if (!isNodeOfType(property, "Property") || property.value !== symbol.bindingIdentifier) continue;
 		const propertyName = getStaticPropertyKeyName(property);
-		return Boolean(propertyName && includesApiName(apiNames, propertyName) && isReactNamespaceReceiver$1(stripParenExpression(symbol.initializer), scopes, options));
+		return Boolean(propertyName && includesApiName(apiNames, propertyName) && isReactNamespaceReceiver(stripParenExpression(symbol.initializer), scopes, options));
 	}
 	return false;
 };
@@ -8997,7 +8880,7 @@ const isReactApiCallee = (rawCallee, apiNames, scopes, options, visitedSymbolIds
 		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
 	}
 	if (!isNodeOfType(callee, "MemberExpression") || !includesApiName(apiNames, getStaticPropertyName(callee) ?? "")) return false;
-	return isReactNamespaceReceiver$1(stripParenExpression(callee.object), scopes, options);
+	return isReactNamespaceReceiver(stripParenExpression(callee.object), scopes, options);
 };
 //#endregion
 //#region src/plugin/utils/is-proven-browser-api-receiver.ts
@@ -13653,7 +13536,7 @@ const getPromiseChainCallForCallback = (candidate) => {
 	if (!callbackContainer.arguments?.some((argument) => stripParenExpression(argument) === candidate)) return null;
 	return isPromiseChainCall(stripParenExpression(callbackContainer.callee)) ? callbackContainer : null;
 };
-const collectInvokedFunctions = (effectCallback, includePromiseCallbacks) => {
+const collectEffectInvokedFunctions = (effectCallback) => {
 	const invokedFunctions = new Set([effectCallback]);
 	const localFunctionBindings = /* @__PURE__ */ new Map();
 	const calledBindingNames = /* @__PURE__ */ new Set();
@@ -13687,14 +13570,12 @@ const collectInvokedFunctions = (effectCallback, includePromiseCallbacks) => {
 				calledBindingNames.add(callee.name);
 				return;
 			}
-			if (includePromiseCallbacks && isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
+			if (isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
 		});
 		for (const calledName of calledBindingNames) enqueue(localFunctionBindings.get(calledName));
 	}
 	return invokedFunctions;
 };
-const collectEffectInvokedFunctions = (effectCallback) => collectInvokedFunctions(effectCallback, true);
-const collectSynchronouslyEffectInvokedFunctions = (effectCallback) => collectInvokedFunctions(effectCallback, false);
 //#endregion
 //#region src/plugin/utils/is-react-hook-name.ts
 const isReactHookName = (name) => {
@@ -13853,19 +13734,15 @@ const resolveReactRefSymbol = (memberExpression, scopes) => {
 	if (!isNodeOfType(initializer, "CallExpression")) return null;
 	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
 };
-const resolveReactRefCurrentOriginSymbol = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+const hasReactRefCurrentOrigin = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(node);
-	const refSymbol = resolveReactRefSymbol(expression, scopes);
-	if (refSymbol) return refSymbol;
-	if (!isNodeOfType(expression, "Identifier")) return null;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return null;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	if (!initializer) return null;
+	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 resolveReactRefCurrentOriginSymbol(initializer, scopes, visitedSymbolIds);
+	return hasReactRefCurrentOrigin(symbol.initializer, scopes, visitedSymbolIds);
 };
-const hasReactRefCurrentOrigin = (node, scopes) => resolveReactRefCurrentOriginSymbol(node, scopes) !== null;
 //#endregion
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
@@ -14347,39 +14224,6 @@ const findContainingCollectionKey = (resourceNode, context) => {
 	}
 	return null;
 };
-const findPushedResourceCollectionKey = (usage, context) => {
-	if (!isNodeOfType(usage.node, "CallExpression")) return null;
-	const registrationCallee = stripParenExpression(usage.node.callee);
-	if (!isNodeOfType(registrationCallee, "MemberExpression") || registrationCallee.computed) return null;
-	const resourceIdentifier = stripParenExpression(registrationCallee.object);
-	if (!isPrivatePlainConstIdentifier(resourceIdentifier, context)) return null;
-	const resourceSymbol = context.scopes.symbolFor(resourceIdentifier);
-	if (!resourceSymbol) return null;
-	const pushCalls = resourceSymbol.references.flatMap((reference) => {
-		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-		const callNode = referenceRoot.parent;
-		if (!isNodeOfType(callNode, "CallExpression") || !callNode.arguments?.some((argument) => argument === referenceRoot)) return [];
-		const pushCallee = stripParenExpression(callNode.callee);
-		return isNodeOfType(pushCallee, "MemberExpression") && !pushCallee.computed && isNodeOfType(pushCallee.object, "Identifier") && isNodeOfType(pushCallee.property, "Identifier") && pushCallee.property.name === "push" ? [callNode] : [];
-	});
-	if (pushCalls.length !== 1) return null;
-	const pushCall = pushCalls[0];
-	if (findEnclosingFunction$1(pushCall) !== findEnclosingFunction$1(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [pushCall], context)) return null;
-	const pushCallee = stripParenExpression(pushCall.callee);
-	if (!isNodeOfType(pushCallee, "MemberExpression") || !isNodeOfType(pushCallee.object, "Identifier") || !isPrivatePlainConstIdentifier(pushCallee.object, context)) return null;
-	const collectionSymbol = context.scopes.symbolFor(pushCallee.object);
-	const collectionInitializer = collectionSymbol?.initializer ? stripParenExpression(collectionSymbol.initializer) : null;
-	if (!collectionSymbol || !isNodeOfType(collectionInitializer, "ArrayExpression") || (collectionInitializer.elements?.length ?? 0) !== 0 || findEnclosingFunction$1(collectionSymbol.declarationNode) !== findEnclosingFunction$1(usage.node)) return null;
-	return collectionSymbol.references.every((reference) => {
-		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-		const forOfStatement = referenceRoot.parent;
-		if (isNodeOfType(forOfStatement, "ForOfStatement") && forOfStatement.right === referenceRoot && forOfStatement.await !== true) return true;
-		const memberNode = referenceRoot.parent;
-		const callNode = memberNode?.parent;
-		if (!isNodeOfType(memberNode, "MemberExpression") || memberNode.object !== referenceRoot || memberNode.computed || !isNodeOfType(memberNode.property, "Identifier") || !isNodeOfType(callNode, "CallExpression") || callNode.callee !== memberNode) return false;
-		return memberNode.property.name === "forEach" || memberNode.property.name === "push";
-	}) ? resolveExpressionKey(pushCallee.object, context) : null;
-};
 const isWithinAssignmentTarget = (identifier) => {
 	let currentNode = identifier;
 	let parentNode = currentNode.parent;
@@ -14438,14 +14282,6 @@ const isSynchronousIteratorCallback = (functionNode) => {
 	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from") return callNode.arguments?.[1] === functionNode;
 	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$2.has(callee.property.name) && callNode.arguments?.[0] === functionNode;
 };
-const findEnclosingForEachCall = (node) => {
-	const callbackNode = findEnclosingFunction$1(node);
-	if (!callbackNode) return null;
-	const callNode = callbackNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression") || callNode.arguments?.[0] !== callbackNode) return null;
-	const callee = stripParenExpression(callNode.callee);
-	return isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "forEach" ? callNode : null;
-};
 const findDirectCallForReference = (identifier) => {
 	const expressionRoot = findTransparentExpressionRoot(identifier);
 	const callNode = expressionRoot.parent;
@@ -14460,7 +14296,7 @@ const findSingleDirectInvocation = (functionNode, caller, context) => {
 		const callNode = findDirectCallForReference(reference.identifier);
 		return callNode ? [callNode] : [];
 	});
-	if (invocationCalls.length !== 1 || symbol.references.length !== 1) return null;
+	if (invocationCalls.length !== 1) return null;
 	const invocationCall = invocationCalls[0];
 	return findEnclosingFunction$1(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
 };
@@ -14494,15 +14330,7 @@ const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visite
 		if (cleanupChild !== cleanupFunction.body && isFunctionLike$1(cleanupChild) && !isSynchronousIteratorCallback(cleanupChild)) return false;
 		const cleanupCall = isNodeOfType(cleanupChild, "ChainExpression") ? cleanupChild.expression : cleanupChild;
 		if (doesReleaseCallMatchUsage(cleanupChild, usage, context)) {
-			const cleanupForEachCall = findEnclosingForEachCall(cleanupChild);
-			const cleanupCallee = isNodeOfType(cleanupCall, "CallExpression") ? stripParenExpression(cleanupCall.callee) : null;
-			const cleanupReceiverForOfStatement = isNodeOfType(cleanupCallee, "MemberExpression") ? findForOfStatementForIteratorExpression(cleanupCallee.object, context) : null;
-			const cleanupReceiverCollectionKey = cleanupReceiverForOfStatement ? resolveExpressionKey(cleanupReceiverForOfStatement.right, context) : isNodeOfType(cleanupCallee, "MemberExpression") ? resolveIteratorCollectionKey(cleanupCallee.object, context) : null;
-			if (cleanupReceiverCollectionKey !== null && findEnclosingFunction$1(cleanupChild) !== cleanupFunction) {
-				if (cleanupForEachCall && findPushedResourceCollectionKey(usage, context) === cleanupReceiverCollectionKey) matchingLoopOrHelperAnchors.push(cleanupForEachCall);
-				return;
-			}
-			const cleanupForOfStatement = findForOfStatementForIteratorExpression(isNodeOfType(cleanupCall, "CallExpression") ? cleanupCall.arguments?.[0] : null, context) ?? cleanupReceiverForOfStatement;
+			const cleanupForOfStatement = findForOfStatementForIteratorExpression(isNodeOfType(cleanupCall, "CallExpression") ? cleanupCall.arguments?.[0] : null, context);
 			if (!cleanupForOfStatement) {
 				didCleanupFunctionMatch = true;
 				return false;
@@ -14546,28 +14374,28 @@ const callbackReturnsCleanupForUsage = (callback, usage, context) => {
 	});
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
 };
-const doesTestRequireLiveExpressionKey = (test, expressionKey, context) => {
-	if (resolveExpressionKey(test, context) === expressionKey) return true;
-	const unwrappedTest = stripParenExpression(test);
-	if (!isNodeOfType(unwrappedTest, "BinaryExpression") || unwrappedTest.operator !== "!=" && unwrappedTest.operator !== "!==") return false;
-	const isNullishOperand = (operand) => {
-		const unwrappedOperand = stripParenExpression(operand);
-		return isNodeOfType(unwrappedOperand, "Literal") && unwrappedOperand.value === null || isNodeOfType(unwrappedOperand, "Identifier") && unwrappedOperand.name === "undefined" && context.scopes.isGlobalReference(unwrappedOperand);
+const findDirectHandleGuardForRelease = (releaseCall, owner, usage, context) => {
+	if (usage.handleKey === null) return null;
+	const doesTestRequireLiveHandle = (test) => {
+		if (resolveExpressionKey(test, context) === usage.handleKey) return true;
+		const unwrappedTest = stripParenExpression(test);
+		if (!isNodeOfType(unwrappedTest, "BinaryExpression") || unwrappedTest.operator !== "!=" && unwrappedTest.operator !== "!==") return false;
+		const isNullishOperand = (operand) => {
+			const unwrappedOperand = stripParenExpression(operand);
+			return isNodeOfType(unwrappedOperand, "Literal") && unwrappedOperand.value === null || isNodeOfType(unwrappedOperand, "Identifier") && unwrappedOperand.name === "undefined" && context.scopes.isGlobalReference(unwrappedOperand);
+		};
+		return resolveExpressionKey(unwrappedTest.left, context) === usage.handleKey && isNullishOperand(unwrappedTest.right) || resolveExpressionKey(unwrappedTest.right, context) === usage.handleKey && isNullishOperand(unwrappedTest.left);
 	};
-	return resolveExpressionKey(unwrappedTest.left, context) === expressionKey && isNullishOperand(unwrappedTest.right) || resolveExpressionKey(unwrappedTest.right, context) === expressionKey && isNullishOperand(unwrappedTest.left);
-};
-const findLiveExpressionGuardForRelease = (releaseCall, owner, expressionKey, context) => {
 	let ancestor = releaseCall.parent;
 	while (ancestor && ancestor !== owner) {
 		if (isNodeOfType(ancestor, "IfStatement")) {
-			if (ancestor.alternate !== null || !doesTestRequireLiveExpressionKey(ancestor.test, expressionKey, context) || !doMatchingNodesCoverEveryPathAfterUsage(ancestor.consequent, [releaseCall], context)) return null;
+			if (ancestor.alternate !== null || !doesTestRequireLiveHandle(ancestor.test) || !doMatchingNodesCoverEveryPathAfterUsage(ancestor.consequent, [releaseCall], context)) return null;
 			return ancestor;
 		}
 		ancestor = ancestor.parent;
 	}
 	return null;
 };
-const findDirectHandleGuardForRelease = (releaseCall, owner, usage, context) => usage.handleKey === null ? null : findLiveExpressionGuardForRelease(releaseCall, owner, usage.handleKey, context);
 const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") || !isNodeOfType(callback.body, "BlockStatement")) return false;
 	const functionCfg = context.cfg.cfgFor(callback);
@@ -14755,108 +14583,7 @@ const hasPotentialInterruptionAfterGuard = (callback, guardState, usageNode, con
 	});
 	return hasPotentialInterruption;
 };
-const getNumericReactRefCurrentKey = (expression, context) => {
-	const refSymbol = resolveReactRefSymbol(stripParenExpression(expression), context.scopes);
-	const initializer = refSymbol?.initializer ? stripParenExpression(refSymbol.initializer) : null;
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	const initialValue = initializer.arguments?.[0] ? stripParenExpression(initializer.arguments[0]) : null;
-	if (!isNodeOfType(initialValue, "Literal") || typeof initialValue.value !== "number") return null;
-	return resolveExpressionKey(expression, context);
-};
-const getBlockingGenerationKey = (expression, context) => {
-	const test = stripParenExpression(expression);
-	if (isNodeOfType(test, "LogicalExpression") && test.operator === "||") return getBlockingGenerationKey(test.left, context) ?? getBlockingGenerationKey(test.right, context);
-	if (!isNodeOfType(test, "BinaryExpression") || test.operator !== "!==" && test.operator !== "!=") return null;
-	const leftKey = getNumericReactRefCurrentKey(test.left, context);
-	const rightKey = getNumericReactRefCurrentKey(test.right, context);
-	const snapshotExpression = leftKey ? stripParenExpression(test.right) : stripParenExpression(test.left);
-	const key = leftKey ?? rightKey;
-	return key && isNodeOfType(snapshotExpression, "Identifier") ? key : null;
-};
-const findGenerationGuardKeyForDeferredUsage = (usageFunction, usageNode, context) => {
-	if (!isFunctionLike$1(usageFunction)) return null;
-	let generationKey = null;
-	walkAst(usageFunction.body, (child) => {
-		if (generationKey) return false;
-		if (child !== usageFunction.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "IfStatement") || child.alternate) return;
-		const key = getBlockingGenerationKey(child.test, context);
-		if (!key || canNodeReachLaterNodeWithinFunction(child.consequent, usageNode, usageFunction, context) || !doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], usageFunction, context)) return;
-		generationKey = key;
-	});
-	return generationKey;
-};
-const isGenerationAdvance = (node, generationKey, context) => {
-	if (isNodeOfType(node, "UpdateExpression") && resolveExpressionKey(node.argument, context) === generationKey) return true;
-	if (!isNodeOfType(node, "AssignmentExpression") || resolveExpressionKey(node.left, context) !== generationKey || node.operator !== "+=" && node.operator !== "-=") return false;
-	const amount = stripParenExpression(node.right);
-	return isNodeOfType(amount, "Literal") && typeof amount.value === "number" && amount.value !== 0;
-};
-const functionAdvancesGeneration = (owner, generationKey, context) => {
-	if (!isFunctionLike$1(owner)) return false;
-	let didAdvanceGeneration = false;
-	walkAst(owner.body, (child) => {
-		if (didAdvanceGeneration) return false;
-		if (child !== owner.body && isFunctionLike$1(child)) return false;
-		if (isGenerationAdvance(child, generationKey, context)) {
-			didAdvanceGeneration = true;
-			return false;
-		}
-	});
-	return didAdvanceGeneration;
-};
-const cleanupReturnsReleaseUsage = (cleanupReturns, usage, context) => cleanupReturns.length > 0 && cleanupReturns.every((cleanupReturn) => {
-	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
-	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
-	return Boolean(cleanupFunction && isFunctionLike$1(cleanupFunction) && doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context));
-});
-const getOwnedFunctionReference = (reference, usageFunction, usageNode, callback, cleanupReturns, context) => {
-	const directCall = findDirectCallForReference(reference);
-	if (directCall) {
-		const referenceOwner = findEnclosingFunction$1(directCall);
-		if (referenceOwner && referenceOwner !== usageFunction && collectSynchronouslyEffectInvokedFunctions(callback).has(referenceOwner)) return { generationKey: null };
-		const generationKey = referenceOwner ? findGenerationGuardKeyForDeferredUsage(referenceOwner, directCall, context) : null;
-		return generationKey ? { generationKey } : null;
-	}
-	const referenceRoot = findTransparentExpressionRoot(reference);
-	const schedulerCall = referenceRoot.parent;
-	if (!isNodeOfType(schedulerCall, "CallExpression") || !schedulerCall.arguments.some((argument) => argument === referenceRoot) || !isNodeOfType(schedulerCall.callee, "Identifier") || schedulerCall.callee.name !== "setTimeout" || !context.scopes.isGlobalReference(schedulerCall.callee)) return null;
-	const schedulerUsage = {
-		kind: "timer",
-		node: schedulerCall,
-		resourceName: schedulerCall.callee.name,
-		handleKey: findAssignedResourceKey(schedulerCall, context),
-		receiverKey: null,
-		registrationVerbName: schedulerCall.callee.name,
-		eventKey: null,
-		handlerKey: null
-	};
-	const generationKey = findGenerationGuardKeyForDeferredUsage(usageFunction, usageNode, context);
-	return schedulerUsage.handleKey !== null && cleanupReturnsReleaseUsage(cleanupReturns, schedulerUsage, context) && generationKey ? { generationKey } : null;
-};
-const hasGuardedRefOwnedNestedCleanup = (callback, usage, cleanupReturns, context) => {
-	const usageFunction = findEnclosingFunction$1(usage.node);
-	const usageExpression = findTransparentExpressionRoot(usage.node);
-	const usageAssignment = usageExpression.parent;
-	if (usage.kind !== "subscribe" && usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !resolveReactRefSymbol(stripParenExpression(usageAssignment.left), context.scopes) || !collectSynchronouslyEffectInvokedFunctions(callback).has(usageFunction) || !cleanupReturnsReleaseUsage(cleanupReturns, usage, context) || !doMatchingNodesCoverEveryPathFromFunctionEntry(callback, cleanupReturns, context)) return false;
-	const cleanupFunctions = cleanupReturns.flatMap((cleanupReturn) => {
-		if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return [];
-		const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
-		return cleanupFunction && isFunctionLike$1(cleanupFunction) ? [cleanupFunction] : [];
-	});
-	const bindingIdentifier = getFunctionBindingIdentifier$1(usageFunction);
-	const functionSymbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
-	if (!functionSymbol || functionSymbol.references.length === 0) return false;
-	const ownedReferences = functionSymbol.references.map((reference) => getOwnedFunctionReference(reference.identifier, usageFunction, usage.node, callback, cleanupReturns, context));
-	if (ownedReferences.some((reference) => reference === null)) return false;
-	const generationKeys = new Set(ownedReferences.flatMap((reference) => reference?.generationKey ? [reference.generationKey] : []));
-	if (generationKeys.size !== 1) return false;
-	const generationKey = generationKeys.values().next().value;
-	if (typeof generationKey !== "string") return false;
-	return [...collectSynchronouslyEffectInvokedFunctions(callback), ...cleanupFunctions].some((owner) => functionAdvancesGeneration(owner, generationKey, context));
-};
 const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
-	if (hasGuardedRefOwnedNestedCleanup(callback, usage, cleanupReturns, context)) return true;
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
 	if (usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usage.node, "CallExpression") || !isNodeOfType(usage.node.callee, "Identifier") || !context.scopes.isGlobalReference(usage.node.callee) || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
@@ -15024,85 +14751,6 @@ const getReleaseVerbName = (node) => {
 	}
 	return null;
 };
-const isRetainedAbortControllerRefRelease = (releaseReceiver, usage, context) => {
-	const releaseFunction = findEnclosingFunction$1(releaseReceiver);
-	const usageFunction = findEnclosingFunction$1(usage.node);
-	if (!releaseFunction || !usageFunction || !isFunctionLike$1(usageFunction) || !isReturnedEffectCleanupFunction(releaseFunction) || !resolveReactRefCurrentOriginSymbol(releaseReceiver, context.scopes)) return false;
-	const controllerKey = getListenerAbortControllerKey(usage, context);
-	const refCurrentKey = resolveExpressionKey(releaseReceiver, context);
-	if (controllerKey === null || refCurrentKey === null) return false;
-	const usageFunctionBody = usageFunction.body;
-	const previousAbortCalls = [];
-	const ownershipAssignments = [];
-	walkAst(usageFunctionBody, (child) => {
-		if (child !== usageFunctionBody && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "AssignmentExpression") && resolveExpressionKey(child.left, context) === refCurrentKey && resolveExpressionKey(child.right, context) === controllerKey) {
-			ownershipAssignments.push(child);
-			return;
-		}
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const childCallee = isNodeOfType(child.callee, "ChainExpression") ? child.callee.expression : stripParenExpression(child.callee);
-		if (isNodeOfType(childCallee, "MemberExpression") && !childCallee.computed && isNodeOfType(childCallee.property, "Identifier") && childCallee.property.name === "abort" && resolveExpressionKey(childCallee.object, context) === refCurrentKey) previousAbortCalls.push(child);
-	});
-	const safeOwnershipAssignments = ownershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, previousAbortCalls, usageFunction, context));
-	return doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
-};
-const isJsxRefAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && node.name.name === "ref";
-const isFunctionForwardedToReactRef = (functionNode, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
-	if (!bindingIdentifier) return false;
-	const symbol = context.scopes.symbolFor(bindingIdentifier);
-	if (!symbol) return false;
-	return symbol.references.some((reference) => {
-		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-		const expressionContainer = referenceRoot.parent;
-		return Boolean(isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === referenceRoot && isJsxRefAttribute(expressionContainer.parent));
-	});
-};
-const isFunctionReturnedFromReactHook = (functionNode, context, requireRefPropertyName) => {
-	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
-	if (!bindingIdentifier) return false;
-	const symbol = context.scopes.symbolFor(bindingIdentifier);
-	if (!symbol) return false;
-	return symbol.references.some((reference) => {
-		const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-		const property = referenceRoot.parent;
-		const propertyName = isNodeOfType(property, "Property") ? getStaticPropertyKeyName(property) : null;
-		if (!isNodeOfType(property, "Property") || property.value !== referenceRoot || !isNodeOfType(property.parent, "ObjectExpression") || requireRefPropertyName && propertyName !== "ref" && !propertyName?.endsWith("Ref")) return false;
-		const returnedObject = findTransparentExpressionRoot(property.parent);
-		const returnStatement = returnedObject.parent;
-		if (!isNodeOfType(returnStatement, "ReturnStatement") || returnStatement.argument !== returnedObject) return false;
-		const ownerFunction = findEnclosingFunction$1(returnStatement);
-		return Boolean(ownerFunction && isReactHookName(getFunctionBindingIdentifier$1(ownerFunction)?.name ?? ""));
-	});
-};
-const isFunctionUsedAsReactRef = (functionNode, context) => isFunctionForwardedToReactRef(functionNode, context) || isFunctionReturnedFromReactHook(functionNode, context, true);
-const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
-	if (!isNodeOfType(usage.node, "CallExpression")) return false;
-	const usageFunction = findEnclosingFunction$1(usage.node);
-	if (!usageFunction || !isFunctionLike$1(usageFunction) || usageFunction !== findEnclosingFunction$1(releaseCall) || !isFunctionUsedAsReactRef(usageFunction, context)) return false;
-	const registrationCallee = stripParenExpression(usage.node.callee);
-	const releaseCallee = stripParenExpression(releaseCall.callee);
-	const releaseRefSymbol = isNodeOfType(releaseCallee, "MemberExpression") ? resolveReactRefCurrentOriginSymbol(releaseCallee.object, context.scopes) : null;
-	if (!isNodeOfType(registrationCallee, "MemberExpression") || registrationCallee.computed || !isNodeOfType(registrationCallee.property, "Identifier") || registrationCallee.property.name !== "addEventListener" || !isNodeOfType(releaseCallee, "MemberExpression") || releaseCallee.computed || !isNodeOfType(releaseCallee.property, "Identifier") || releaseCallee.property.name !== "removeEventListener" || !releaseRefSymbol) return false;
-	const registrationReceiverKey = resolveExpressionKey(stripParenExpression(registrationCallee.object), context);
-	const nodeParameterKey = resolveExpressionKey(usageFunction.params?.[0], context);
-	const releaseReceiverKey = resolveExpressionKey(releaseCallee.object, context);
-	if (registrationReceiverKey === null || registrationReceiverKey !== nodeParameterKey || releaseReceiverKey === null || usage.eventKey === null || usage.eventKey !== resolveExpressionKey(releaseCall.arguments?.[0], context) || usage.handlerKey === null || usage.handlerKey !== resolveExpressionKey(releaseCall.arguments?.[1], context)) return false;
-	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
-	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
-	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
-	const releaseStart = getRangeStart(releaseCall);
-	const matchingOwnershipAssignments = [];
-	const usageFunctionBody = usageFunction.body;
-	walkAst(usageFunctionBody, (child) => {
-		if (child !== usageFunctionBody && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "AssignmentExpression") && child.operator === "=" && resolveReactRefSymbol(stripParenExpression(child.left), context.scopes)?.id === releaseRefSymbol.id && resolveExpressionKey(child.right, context) === registrationReceiverKey && releaseStart !== null && (getRangeStart(child) ?? -1) > releaseStart) matchingOwnershipAssignments.push(child);
-	});
-	const releaseAnchor = findLiveExpressionGuardForRelease(releaseCall, usageFunction, releaseReceiverKey, context) ?? releaseCall;
-	const safeOwnershipAssignments = matchingOwnershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, [releaseAnchor], usageFunction, context));
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
-};
 const doesReleaseCallMatchUsage = (node, usage, context) => {
 	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
 	if (!isNodeOfType(callNode, "CallExpression")) return false;
@@ -15119,21 +14767,13 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (!releaseVerbName) return false;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
 	const releaseReceiverKey = resolveExpressionKey(callee.object, context);
-	const releaseEventKey = resolveExpressionKey(callNode.arguments?.[0], context);
-	const pairedReleaseVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
-	const pushedResourceCollectionKey = findPushedResourceCollectionKey(usage, context);
-	const releaseReceiverForOfStatement = findForOfStatementForIteratorExpression(callee.object, context);
-	const releaseReceiverCollectionKey = releaseReceiverForOfStatement ? resolveExpressionKey(releaseReceiverForOfStatement.right, context) : resolveIteratorCollectionKey(callee.object, context);
-	if (pairedReleaseVerbNames && matchesPairedReleaseVerb(releaseVerbName, pairedReleaseVerbNames) && pushedResourceCollectionKey !== null && pushedResourceCollectionKey === releaseReceiverCollectionKey && (releaseVerbName !== "unobserve" || usage.eventKey !== null && releaseEventKey === usage.eventKey)) return true;
-	if (isReactRefListenerReplacementRelease(callNode, usage, context)) return true;
 	if (usage.kind === "socket") return usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (SOCKET_RELEASE_VERB_NAMES.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName));
 	if (usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub" || releaseVerbName === "close" || releaseVerbName === "unwatch" || releaseVerbName === "unlisten" || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(releaseVerbName))) return true;
 	if (releaseVerbName === "abort" && releaseReceiverKey === getListenerAbortControllerKey(usage, context)) return true;
-	if (releaseVerbName === "abort" && isRetainedAbortControllerRefRelease(callee.object, usage, context)) return true;
 	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) return false;
-	if (usage.registrationVerbName === "subscribe" && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub") && usage.handleKey !== null && resolveExpressionKey(callNode.arguments?.[0], context) === usage.handleKey) return true;
 	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;
@@ -15163,12 +14803,9 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 		return isNodeOfType(handlerArgument, "Literal") && handlerArgument.value === null;
 	}
 	if (releaseVerbName === "removeEventListener" || releaseVerbName === "removeListener" || releaseVerbName === "off") {
-		const usesUnaryListenerSignature = usage.registrationVerbName === "addListener" && isNodeOfType(usage.node, "CallExpression") && usage.node.arguments?.length === 1 && callNode.arguments?.length === 1;
-		const releaseHandler = usesUnaryListenerSignature ? callNode.arguments?.[0] : callNode.arguments?.[1];
+		const releaseHandler = callNode.arguments?.[1];
 		if (!releaseHandler) return releaseVerbName === "off";
-		const expectedHandlerKey = usesUnaryListenerSignature ? usage.eventKey : usage.handlerKey;
-		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignature ? 0 : 1] : null;
-		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
+		return usage.handlerKey !== null && resolveExpressionKey(releaseHandler, context) === usage.handlerKey;
 	}
 	if (releaseVerbName === "unobserve" && usage.eventKey !== null) return releaseEventKey === usage.eventKey;
 	return true;
@@ -15181,7 +14818,8 @@ const isReturnedEffectCleanupFunction = (functionNode) => {
 		currentNode = parentNode;
 		parentNode = currentNode.parent;
 	}
-	const effectCallback = isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode ? findEnclosingFunction$1(parentNode) : isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode ? parentNode : null;
+	if (!isNodeOfType(parentNode, "ReturnStatement") || parentNode.argument !== currentNode) return false;
+	const effectCallback = findEnclosingFunction$1(parentNode);
 	const effectCall = effectCallback?.parent;
 	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isHookCall$2(effectCall, CLEANUP_EFFECT_HOOK_NAMES));
 };
@@ -15193,165 +14831,13 @@ const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (!symbol) return false;
 	return symbol.references.some((reference) => findEnclosingFunction$1(reference.identifier) !== functionNode);
 };
-const findRetainedDisposerStorages = (disposerFunction, usage, context) => {
-	if (!isFunctionLike$1(disposerFunction) || disposerFunction.async || disposerFunction.generator) return [];
-	const usageFunction = findEnclosingFunction$1(usage.node);
-	if (!usageFunction || !isFunctionLike$1(usageFunction)) return [];
-	const assignments = /* @__PURE__ */ new Map();
-	const collectAssignment = (expression) => {
-		const expressionRoot = findTransparentExpressionRoot(expression);
-		const assignment = expressionRoot.parent;
-		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.right !== expressionRoot) return;
-		const refSymbol = resolveReactRefSymbol(stripParenExpression(assignment.left), context.scopes);
-		const refCurrentKey = resolveExpressionKey(assignment.left, context);
-		const retainedFunction = findEnclosingFunction$1(assignment);
-		const assignmentStart = getRangeStart(assignment);
-		if (!refSymbol || !refCurrentKey || !retainedFunction || retainedFunction !== usageFunction || assignmentStart === null) return;
-		assignments.set(assignmentStart, {
-			assignmentNode: assignment,
-			refCurrentKey,
-			retainedFunction
-		});
-	};
-	collectAssignment(disposerFunction);
-	const bindingIdentifier = getFunctionBindingIdentifier$1(disposerFunction);
-	const symbol = bindingIdentifier ? context.scopes.symbolFor(bindingIdentifier) : null;
-	for (const reference of symbol?.references ?? []) collectAssignment(reference.identifier);
-	walkAst(usageFunction.body, (child) => {
-		if (child !== usageFunction.body && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "AssignmentExpression") && resolveStableValue(child.right, context) === disposerFunction) collectAssignment(child.right);
-	});
-	return [...assignments.values()];
-};
-const isRetainedDisposerStorageEstablished = (storage, usage, context) => doMatchingNodesCoverEveryPathBeforeUsage(usage.node, [storage.assignmentNode], storage.retainedFunction, context) || doMatchingNodesCoverEveryPathAfterUsage(usage.node, [storage.assignmentNode], context);
-const hasUnsafeRetainedDisposerOverwrite = (storage, usage, context) => {
-	let hasUnsafeOverwrite = false;
-	walkAst(storage.retainedFunction.body, (child) => {
-		if (hasUnsafeOverwrite) return false;
-		if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "AssignmentExpression") || child === storage.assignmentNode || resolveExpressionKey(child.left, context) !== storage.refCurrentKey || !canNodeReachLaterNodeWithinFunction(usage.node, child, storage.retainedFunction, context)) return;
-		const storedValue = resolveStableValue(child.right, context);
-		if (!storedValue || !isFunctionLike$1(storedValue) || !doesCleanupFunctionReleaseUsage(storedValue, usage, context)) {
-			hasUnsafeOverwrite = true;
-			return false;
-		}
-	});
-	return hasUnsafeOverwrite;
-};
-const hasEffectCleanupInvocation = (storage, usage, context) => {
-	const componentFunction = findEnclosingFunction$1(storage.retainedFunction);
-	if (!componentFunction || !isFunctionLike$1(componentFunction)) return false;
-	const cleanupFunctionInvokesRef = (cleanupFunction) => {
-		if (!isFunctionLike$1(cleanupFunction)) return false;
-		let didFindCleanupCall = false;
-		walkAst(cleanupFunction.body, (child) => {
-			if (didFindCleanupCall) return false;
-			if (child !== cleanupFunction.body && isFunctionLike$1(child)) return false;
-			if (isNodeOfType(child, "CallExpression") && resolveExpressionKey(child.callee, context) === storage.refCurrentKey) {
-				const callRoot = findTransparentExpressionRoot(child);
-				const callStatement = callRoot.parent;
-				const isDirectBlockStatement = isNodeOfType(cleanupFunction.body, "BlockStatement") && isNodeOfType(callStatement, "ExpressionStatement") && callStatement.parent === cleanupFunction.body;
-				const isConciseBody = cleanupFunction.body === callRoot;
-				if ((isDirectBlockStatement || isConciseBody) && !hasUnprovenReturnBeforeRefOwnedRelease(cleanupFunction, child, storage.refCurrentKey, context)) {
-					didFindCleanupCall = true;
-					return false;
-				}
-			}
-		});
-		return didFindCleanupCall;
-	};
-	const effectReturnsCleanup = (effectCallback) => {
-		if (!isFunctionLike$1(effectCallback)) return false;
-		if (!isNodeOfType(effectCallback.body, "BlockStatement")) {
-			const cleanupFunction = resolveRefOwnedCleanupFunction(effectCallback.body, context);
-			return Boolean(cleanupFunction && cleanupFunctionInvokesRef(cleanupFunction));
-		}
-		const matchingReturns = [];
-		walkInsideStatementBlocks(effectCallback.body, (child) => {
-			if (!isNodeOfType(child, "ReturnStatement") || !child.argument) return;
-			const cleanupFunction = resolveRefOwnedCleanupFunction(child.argument, context);
-			if (!cleanupFunction || !cleanupFunctionInvokesRef(cleanupFunction)) return;
-			matchingReturns.push(child);
-		});
-		return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
-	};
-	let didFindInvocation = false;
-	walkAst(componentFunction.body, (child) => {
-		if (didFindInvocation) return false;
-		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
-		const effectCallback = getEffectCallback(child);
-		if (effectCallback && effectReturnsCleanup(effectCallback)) {
-			didFindInvocation = true;
-			return false;
-		}
-	});
-	return didFindInvocation;
-};
-const hasCallbackRefReplacementInvocation = (storage, usage, context) => {
-	const isReturnedCallbackRefShape = () => {
-		if (!isFunctionLike$1(storage.retainedFunction)) return false;
-		const callbackCall = findTransparentExpressionRoot(storage.retainedFunction).parent;
-		if (!isNodeOfType(callbackCall, "CallExpression") || !isReactApiCall(callbackCall, "useCallback", context.scopes)) return false;
-		const nodeParameter = storage.retainedFunction.params?.[0];
-		const nodeParameterKey = resolveExpressionKey(nodeParameter, context);
-		if (!nodeParameterKey || usage.receiverKey !== nodeParameterKey) return false;
-		if (!isFunctionReturnedFromReactHook(storage.retainedFunction, context, false)) return false;
-		const usageStart = getRangeStart(usage.node);
-		if (usageStart === null) return false;
-		let hasNullExit = false;
-		walkAst(storage.retainedFunction.body, (child) => {
-			if (hasNullExit) return false;
-			if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
-			if (!isNodeOfType(child, "IfStatement") || (getRangeStart(child) ?? usageStart) >= usageStart) return;
-			const test = stripParenExpression(child.test);
-			if (!isNodeOfType(test, "UnaryExpression") || test.operator !== "!" || resolveExpressionKey(test.argument, context) !== nodeParameterKey) return;
-			const consequent = child.consequent;
-			hasNullExit = isNodeOfType(consequent, "ReturnStatement") || isNodeOfType(consequent, "BlockStatement") && consequent.body.some((statement) => isNodeOfType(statement, "ReturnStatement"));
-			if (hasNullExit) return false;
-		});
-		return hasNullExit;
-	};
-	if (!isFunctionForwardedToReactRef(storage.retainedFunction, context) && !isReturnedCallbackRefShape()) return false;
-	const cleanupCalls = [];
-	walkAst(storage.retainedFunction.body, (child) => {
-		if (child !== storage.retainedFunction.body && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "CallExpression") && resolveExpressionKey(child.callee, context) === storage.refCurrentKey) cleanupCalls.push(child);
-	});
-	return doMatchingNodesCoverEveryPathBeforeUsage(usage.node, cleanupCalls, storage.retainedFunction, context);
-};
-const isRetainedDisposerRefRelease = (releaseNode, usage, context) => {
-	const disposerFunction = findEnclosingFunction$1(releaseNode);
-	if (!disposerFunction) return false;
-	return findRetainedDisposerStorages(disposerFunction, usage, context).some((storage) => isRetainedDisposerStorageEstablished(storage, usage, context) && !hasUnsafeRetainedDisposerOverwrite(storage, usage, context) && (hasEffectCleanupInvocation(storage, usage, context) || hasCallbackRefReplacementInvocation(storage, usage, context)));
-};
-const isSelfReleasingListenerRelease = (releaseNode, releaseFunction, usage, context) => {
-	if (usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.receiverKey === null || usage.eventKey === null || !isNodeOfType(usage.node, "CallExpression") || !isFunctionLike$1(releaseFunction) || releaseFunction.async || releaseFunction.generator || !isNodeOfType(releaseFunction.body, "BlockStatement") || !doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
-	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
-	const releaseCall = isNodeOfType(releaseNode, "ChainExpression") ? releaseNode.expression : releaseNode;
-	if (!isNodeOfType(releaseCall, "CallExpression")) return false;
-	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
-	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
-	const ownerFunction = findEnclosingFunction$1(releaseFunction);
-	if (!ownerFunction || !isFunctionLike$1(ownerFunction)) return false;
-	const triggerRegistrations = [];
-	walkAst(ownerFunction.body, (child) => {
-		if (child !== ownerFunction.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const registrationDetails = getCallRegistrationDetails(child, context);
-		if (registrationDetails.registrationVerbName === "addEventListener" && registrationDetails.receiverKey === usage.receiverKey && resolveStableValue(child.arguments?.[1], context) === releaseFunction) triggerRegistrations.push(child);
-	});
-	if (triggerRegistrations.some((triggerRegistration) => triggerRegistration === usage.node)) return true;
-	return doMatchingNodesCoverEveryPathAfterUsage(usage.node, triggerRegistrations, context) || doMatchingNodesCoverEveryPathBeforeUsage(usage.node, triggerRegistrations, ownerFunction, context);
-};
 const isReleaseReachableForUsage = (releaseNode, usage, context) => {
 	if (!isNodeReachableWithinFunction(releaseNode, context)) return false;
 	const releaseFunction = findEnclosingFunction$1(releaseNode);
 	if (!releaseFunction) return true;
 	if (releaseFunction === findEnclosingFunction$1(usage.node)) return true;
-	if (isRetainedDisposerRefRelease(releaseNode, usage, context)) return true;
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	if (usageFunction && isFunctionLike$1(usageFunction) && getAssignedReactRefSymbol(usageFunction, context) && isCleanupFunctionReferencedByReturn(usageFunction, releaseFunction, context)) return isReactRefCallbackCleanupOwnedByEffect(usageFunction, releaseFunction, usage, context);
-	if (isSelfReleasingListenerRelease(releaseNode, releaseFunction, usage, context)) return true;
 	return isPotentiallyReachableFunction(releaseFunction, context);
 };
 const fileContainsReleaseForUsage = (usage, context) => {
@@ -15619,11 +15105,6 @@ const doesResourceResultEscape = (resourceNode, allowReturnedResourceEscape, all
 			parentNode = currentNode.parent;
 			continue;
 		}
-		if (isNodeOfType(parentNode, "ConditionalExpression") && (parentNode.consequent === currentNode || parentNode.alternate === currentNode) || isNodeOfType(parentNode, "LogicalExpression") && (parentNode.right === currentNode || parentNode.left === currentNode && parentNode.operator !== "&&")) {
-			currentNode = parentNode;
-			parentNode = currentNode.parent;
-			continue;
-		}
 		if (isNodeOfType(parentNode, "VariableDeclarator") && parentNode.init === currentNode && isNodeOfType(parentNode.id, "Identifier") && isNodeOfType(parentNode.parent, "VariableDeclaration") && parentNode.parent.kind === "const") {
 			const ownerFunction = findEnclosingFunction$1(resourceNode);
 			const resourceSymbol = context.scopes.symbolFor(parentNode.id);
@@ -17283,38 +16764,7 @@ const symbolHasStableImportedAlias = (symbol, scopes) => {
 	const resolvedSymbol = resolveConstIdentifierAlias(symbol.bindingIdentifier, scopes);
 	return resolvedSymbol !== null && resolvedSymbol !== symbol && resolvedSymbol.kind === "import";
 };
-const isAssignmentTarget = (node) => {
-	let currentNode = findTransparentExpressionRoot(node);
-	while (currentNode.parent) {
-		const parentNode = currentNode.parent;
-		if (isNodeOfType(parentNode, "AssignmentExpression")) return parentNode.left === currentNode;
-		if (isNodeOfType(parentNode, "UpdateExpression")) return parentNode.argument === currentNode;
-		if (isNodeOfType(parentNode, "UnaryExpression")) return parentNode.operator === "delete" && parentNode.argument === currentNode;
-		if (isNodeOfType(parentNode, "ForInStatement") || isNodeOfType(parentNode, "ForOfStatement")) return parentNode.left === currentNode;
-		if (isNodeOfType(parentNode, "ArrayPattern") && parentNode.elements.some((element) => element === currentNode) || isNodeOfType(parentNode, "ObjectPattern") && parentNode.properties.some((property) => property === currentNode) || isNodeOfType(parentNode, "RestElement") && parentNode.argument === currentNode || isNodeOfType(parentNode, "AssignmentPattern") && parentNode.left === currentNode || isNodeOfType(parentNode, "Property") && parentNode.value === currentNode && isNodeOfType(parentNode.parent, "ObjectPattern")) {
-			currentNode = parentNode;
-			continue;
-		}
-		return false;
-	}
-	return false;
-};
-const symbolHasStableRefLazyInitialization = (symbol, scopes) => {
-	if (symbol.kind !== "const" || symbol.references.some((reference) => reference.flag !== "read")) return false;
-	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
-	if (!isNodeOfType(initializer, "AssignmentExpression") || initializer.operator !== "??=") return false;
-	const refSymbol = resolveReactRefSymbol(unwrapExpression$3(initializer.left), scopes);
-	if (!refSymbol) return false;
-	return refSymbol.references.every((reference) => {
-		const memberExpression = findTransparentExpressionRoot(reference.identifier).parent;
-		if (!isNodeOfType(memberExpression, "MemberExpression") || unwrapExpression$3(memberExpression.object) !== reference.identifier || getStaticPropertyName(memberExpression) !== "current") return false;
-		const referenceRoot = findTransparentExpressionRoot(memberExpression);
-		const parentNode = referenceRoot.parent;
-		if (isNodeOfType(parentNode, "AssignmentExpression") && parentNode.left === referenceRoot) return parentNode === initializer;
-		return !isAssignmentTarget(referenceRoot);
-	});
-};
-const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol, scopes) || symbolHasStableRefLazyInitialization(symbol, scopes) || symbolHasStableImportedAlias(symbol, scopes) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
+const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol, scopes) || symbolHasStableImportedAlias(symbol, scopes) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
 //#endregion
 //#region src/plugin/utils/symbol-has-react-use-effect-event-origin.ts
 const symbolHasReactUseEffectEventOrigin = (symbol, scopes) => {
@@ -17516,7 +16966,7 @@ const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys, allow
 				keys.add(depKey);
 				continue;
 			}
-			const identitySourceKeys = resolvePureCalledFunctionSourceKeys(reference, symbol, scopes) ?? resolveRenderDerivedMutableSourceKeys(reference, symbol, scopes) ?? resolveReactiveIdentitySourceKeys(symbol, scopes);
+			const identitySourceKeys = resolveReactiveIdentitySourceKeys(symbol, scopes);
 			if (identitySourceKeys) {
 				if (identitySourceKeys.size === 0) stableCapturedNames.add(depKey);
 				for (const identitySourceKey of identitySourceKeys) keys.add(identitySourceKey);
@@ -17599,161 +17049,6 @@ const resolveReactiveIdentitySourceKeys = (symbol, scopes) => {
 	if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || symbol.references.some((reference) => reference.flag !== "read")) return null;
 	return resolveIdentitySourceKeysFromExpression(symbol.initializer, scopes, new Set([symbol.id]));
 };
-const isPureDerivedExpression = (expression) => {
-	const candidate = unwrapExpression$3(expression);
-	if (isNodeOfType(candidate, "Literal") || isNodeOfType(candidate, "Identifier")) return true;
-	if (isNodeOfType(candidate, "MemberExpression")) return isPureDerivedExpression(candidate.object) && (!candidate.computed || isPureDerivedExpression(candidate.property));
-	if (isNodeOfType(candidate, "BinaryExpression") || isNodeOfType(candidate, "LogicalExpression")) return isPureDerivedExpression(candidate.left) && isPureDerivedExpression(candidate.right);
-	if (isNodeOfType(candidate, "UnaryExpression")) return candidate.operator !== "delete" && isPureDerivedExpression(candidate.argument);
-	if (isNodeOfType(candidate, "ConditionalExpression")) return isPureDerivedExpression(candidate.test) && isPureDerivedExpression(candidate.consequent) && isPureDerivedExpression(candidate.alternate);
-	if (isNodeOfType(candidate, "TemplateLiteral")) return candidate.expressions.every((nestedExpression) => isPureDerivedExpression(nestedExpression));
-	return false;
-};
-const isPureDerivedStatement = (statement) => {
-	if (isNodeOfType(statement, "BlockStatement")) return statement.body.every((nestedStatement) => isPureDerivedStatement(nestedStatement));
-	if (isNodeOfType(statement, "ReturnStatement")) return !statement.argument || isPureDerivedExpression(statement.argument);
-	if (isNodeOfType(statement, "IfStatement")) return isPureDerivedExpression(statement.test) && isPureDerivedStatement(statement.consequent) && (!statement.alternate || isPureDerivedStatement(statement.alternate));
-	return false;
-};
-const isPureDerivedFunction = (functionNode) => {
-	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return false;
-	if (functionNode.async || functionNode.generator) return false;
-	return isNodeOfType(functionNode.body, "BlockStatement") ? isPureDerivedStatement(functionNode.body) : isPureDerivedExpression(functionNode.body);
-};
-const resolvePureCalledFunctionSourceKeys = (reference, symbol, scopes) => {
-	if (symbol.references.some((symbolReference) => symbolReference.flag !== "read")) return null;
-	const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-	const callExpression = referenceRoot.parent;
-	if (!isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== referenceRoot) return null;
-	const functionNode = getFunctionValueNode(symbol);
-	if (!functionNode || !isPureDerivedFunction(functionNode)) return null;
-	const sourceKeys = /* @__PURE__ */ new Set();
-	for (const capturedReference of closureCaptures(functionNode, scopes)) {
-		const capturedSymbol = capturedReference.resolvedSymbol;
-		if (!capturedSymbol || capturedSymbol.id === symbol.id) continue;
-		if (isOutsideAllFunctions(capturedSymbol) || symbolHasStableValue(capturedSymbol, scopes)) continue;
-		const capturedKey = computeDepKey(capturedReference);
-		if (!capturedKey) return null;
-		if (capturedKey === capturedSymbol.name) {
-			const nestedSourceKeys = resolveReactiveIdentitySourceKeys(capturedSymbol, scopes);
-			if (nestedSourceKeys) {
-				for (const nestedSourceKey of nestedSourceKeys) sourceKeys.add(nestedSourceKey);
-				continue;
-			}
-		}
-		sourceKeys.add(capturedKey);
-	}
-	return sourceKeys.size > 0 ? sourceKeys : null;
-};
-const mergeDerivedExpressionSourceKeys = (expressions, scopes, visitedSymbolIds) => {
-	const sourceKeys = /* @__PURE__ */ new Set();
-	for (const expression of expressions) {
-		const expressionSourceKeys = resolveDerivedExpressionSourceKeys(expression, scopes, visitedSymbolIds);
-		if (!expressionSourceKeys) return null;
-		for (const expressionSourceKey of expressionSourceKeys) sourceKeys.add(expressionSourceKey);
-	}
-	return sourceKeys;
-};
-const resolveDerivedExpressionSourceKeys = (expression, scopes, visitedSymbolIds) => {
-	const candidate = unwrapExpression$3(expression);
-	if (isNodeOfType(candidate, "Literal")) return /* @__PURE__ */ new Set();
-	if (isNodeOfType(candidate, "Identifier")) {
-		if (scopes.isGlobalReference(candidate)) return /* @__PURE__ */ new Set();
-		const sourceSymbol = scopes.symbolFor(candidate);
-		if (!sourceSymbol) return null;
-		if (isOutsideAllFunctions(sourceSymbol) || symbolHasStableValue(sourceSymbol, scopes)) return /* @__PURE__ */ new Set();
-		if (sourceSymbol.kind === "const" && sourceSymbol.initializer && isNodeOfType(sourceSymbol.declarationNode, "VariableDeclarator") && sourceSymbol.declarationNode.id === sourceSymbol.bindingIdentifier && sourceSymbol.references.every((sourceReference) => sourceReference.flag === "read") && !visitedSymbolIds.has(sourceSymbol.id)) {
-			visitedSymbolIds.add(sourceSymbol.id);
-			const sourceKeys = resolveDerivedExpressionSourceKeys(sourceSymbol.initializer, scopes, visitedSymbolIds);
-			visitedSymbolIds.delete(sourceSymbol.id);
-			if (sourceKeys) return sourceKeys;
-		}
-		return new Set([sourceSymbol.name]);
-	}
-	if (isNodeOfType(candidate, "MemberExpression")) {
-		if (hasComputedMemberExpression(candidate)) return null;
-		const sourceKey = stringifyMemberChain(candidate);
-		const rootIdentifier = getMemberRootIdentifier(candidate);
-		const rootSymbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
-		if (!sourceKey || !rootSymbol) return null;
-		if (isOutsideAllFunctions(rootSymbol) || symbolHasStableValue(rootSymbol, scopes)) return /* @__PURE__ */ new Set();
-		return new Set([sourceKey]);
-	}
-	if (isNodeOfType(candidate, "BinaryExpression") || isNodeOfType(candidate, "LogicalExpression")) return mergeDerivedExpressionSourceKeys([candidate.left, candidate.right], scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator !== "delete") return resolveDerivedExpressionSourceKeys(candidate.argument, scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "ConditionalExpression")) return mergeDerivedExpressionSourceKeys([
-		candidate.test,
-		candidate.consequent,
-		candidate.alternate
-	], scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "TemplateLiteral")) return mergeDerivedExpressionSourceKeys(candidate.expressions, scopes, visitedSymbolIds);
-	if (isNodeOfType(candidate, "NewExpression")) {
-		const callee = unwrapExpression$3(candidate.callee);
-		if (!isNodeOfType(callee, "Identifier") || callee.name !== "Error" || !scopes.isGlobalReference(callee)) return null;
-		const argumentsToAnalyze = [];
-		for (const argument of candidate.arguments) {
-			if (!isAstNode(argument) || isNodeOfType(argument, "SpreadElement")) return null;
-			argumentsToAnalyze.push(argument);
-		}
-		return mergeDerivedExpressionSourceKeys(argumentsToAnalyze, scopes, visitedSymbolIds);
-	}
-	return null;
-};
-const resolveWriteControlSourceKeys = (assignment, boundaryFunction, scopes) => {
-	const sourceKeys = /* @__PURE__ */ new Set();
-	let currentNode = assignment;
-	while (currentNode.parent && currentNode.parent !== boundaryFunction) {
-		const parentNode = currentNode.parent;
-		if (isNodeOfType(parentNode, "IfStatement")) {
-			if (parentNode.test === currentNode) return null;
-			const testSourceKeys = resolveDerivedExpressionSourceKeys(parentNode.test, scopes, /* @__PURE__ */ new Set());
-			if (!testSourceKeys) return null;
-			for (const testSourceKey of testSourceKeys) sourceKeys.add(testSourceKey);
-		} else if (!isNodeOfType(parentNode, "ExpressionStatement") && !isNodeOfType(parentNode, "BlockStatement")) return null;
-		currentNode = parentNode;
-	}
-	return currentNode.parent === boundaryFunction ? sourceKeys : null;
-};
-const isReadOnlyInitialStateUse = (referenceNode, scopes) => {
-	const referenceRoot = findTransparentExpressionRoot(referenceNode);
-	const callExpression = referenceRoot.parent;
-	return isNodeOfType(callExpression, "CallExpression") && callExpression.arguments.some((argument) => argument === referenceRoot) && isReactApiCall(callExpression, "useState", scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true,
-		resolveNamedAliases: true
-	});
-};
-const resolveRenderDerivedMutableSourceKeys = (capturedReference, symbol, scopes) => {
-	if (symbol.kind !== "let" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
-	const boundaryFunction = findEnclosingFunction$1(symbol.bindingIdentifier);
-	if (!boundaryFunction) return null;
-	const capturingFunction = findEnclosingFunction$1(capturedReference.identifier);
-	if (!capturingFunction || capturingFunction === boundaryFunction) return null;
-	const sourceKeys = /* @__PURE__ */ new Set();
-	if (symbol.initializer) {
-		const initializerSourceKeys = resolveDerivedExpressionSourceKeys(symbol.initializer, scopes, new Set([symbol.id]));
-		if (!initializerSourceKeys) return null;
-		for (const initializerSourceKey of initializerSourceKeys) sourceKeys.add(initializerSourceKey);
-	}
-	let writeCount = 0;
-	for (const symbolReference of symbol.references) {
-		if (symbolReference.flag === "read") {
-			if (findEnclosingFunction$1(symbolReference.identifier) !== capturingFunction && !isReadOnlyInitialStateUse(symbolReference.identifier, scopes)) return null;
-			continue;
-		}
-		if (symbolReference.flag !== "write") return null;
-		const referenceRoot = findTransparentExpressionRoot(symbolReference.identifier);
-		const assignment = referenceRoot.parent;
-		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== referenceRoot || findEnclosingFunction$1(referenceRoot) !== boundaryFunction) return null;
-		const assignmentSourceKeys = resolveDerivedExpressionSourceKeys(assignment.right, scopes, new Set([symbol.id]));
-		const controlSourceKeys = resolveWriteControlSourceKeys(assignment, boundaryFunction, scopes);
-		if (!assignmentSourceKeys || !controlSourceKeys) return null;
-		for (const assignmentSourceKey of assignmentSourceKeys) sourceKeys.add(assignmentSourceKey);
-		for (const controlSourceKey of controlSourceKeys) sourceKeys.add(controlSourceKey);
-		writeCount += 1;
-	}
-	return writeCount > 0 && sourceKeys.size > 0 ? sourceKeys : null;
-};
 const isUseCallbackResultDep = (node, scopes) => {
 	const rootSymbol = getRootSymbol(node, scopes);
 	const initializer = rootSymbol?.initializer ? unwrapExpression$3(rootSymbol.initializer) : null;
@@ -18497,7 +17792,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (!isUsed) continue;
 				const reportNode = declaredKeyToReportNode.get(declaredKey) ?? depsArgument;
 				const rootSymbol = getRootSymbol(reportNode, context.scopes);
-				if (!rootSymbol || !hasDirectIdentifierDeclarator(rootSymbol) || symbolHasStableValue(rootSymbol, context.scopes) || !isUnstableInitializer(rootSymbol.initializer)) continue;
+				if (!rootSymbol || !hasDirectIdentifierDeclarator(rootSymbol) || !isUnstableInitializer(rootSymbol.initializer)) continue;
 				context.report({
 					node: reportNode,
 					message: buildUnstableDepMessage(hookName, declaredKey)
@@ -29981,7 +29276,7 @@ const nextjsNoVercelOgImport = defineRule({
 //#endregion
 //#region src/plugin/rules/a11y/no-access-key.ts
 const MESSAGE$39 = "Screen reader users can lose their shortcuts because `accessKey` clashes with them, so remove it.";
-const isUndefinedIdentifier$1 = (expression) => isNodeOfType(expression, "Identifier") && expression.name === "undefined";
+const isUndefinedIdentifier = (expression) => isNodeOfType(expression, "Identifier") && expression.name === "undefined";
 const noAccessKey = defineRule({
 	id: "no-access-key",
 	title: "accessKey attribute used",
@@ -30006,7 +29301,7 @@ const noAccessKey = defineRule({
 			if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
 				const expression = attributeValue.expression;
 				if (!expression || expression.type === "JSXEmptyExpression") return;
-				if (isUndefinedIdentifier$1(expression)) return;
+				if (isUndefinedIdentifier(expression)) return;
 				context.report({
 					node: accessKey,
 					message: MESSAGE$39
@@ -30771,12 +30066,6 @@ const isReactNamespaceImportReference = (ref) => Boolean(ref?.resolved?.defs.som
 	const importDeclaration = declarationNode.parent;
 	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
 }));
-const isReactNamespaceReceiver = (analysis, node) => {
-	const receiver = stripParenExpression(node);
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	const namespaceReference = getRef(analysis, receiver);
-	return namespaceReference?.resolved ? isReactNamespaceImportReference(namespaceReference) : receiver.name === "React";
-};
 const isGenuineReactHookDeclarator = (analysis, declarator, hookName) => {
 	if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) return false;
 	const callee = stripParenExpression(declarator.init.callee);
@@ -30785,20 +30074,24 @@ const isGenuineReactHookDeclarator = (analysis, declarator, hookName) => {
 		if (!reference?.resolved) return callee.name === hookName;
 		return isReactNamedImportReference(reference, hookName);
 	}
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== hookName) return false;
-	return isReactNamespaceReceiver(analysis, callee.object);
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== hookName) return false;
+	const namespaceReference = getRef(analysis, callee.object);
+	if (!namespaceReference?.resolved) return callee.object.name === "React";
+	return isReactNamespaceImportReference(namespaceReference);
 };
 const isHookCallee$1 = (analysis, node, hookName) => {
 	if (!node) return false;
 	if (isNodeOfType(node, "Identifier")) {
 		if (node.name === hookName) return true;
 		if (isReactNamedImportReference(getRef(analysis, node), hookName)) return true;
-		const receiverRoot = findTransparentExpressionRoot(node);
-		const parent = receiverRoot.parent;
-		if (parent && isNodeOfType(parent, "MemberExpression") && parent.object === receiverRoot && isReactNamespaceReceiver(analysis, node) && isNodeOfType(parent.property, "Identifier") && parent.property.name === hookName) return true;
+		const parent = node.parent;
+		if (parent && isNodeOfType(parent, "MemberExpression") && isNodeOfType(parent.object, "Identifier") && parent.object.name === "React" && isNodeOfType(parent.property, "Identifier") && parent.property.name === hookName) return true;
 		return false;
 	}
-	if (isNodeOfType(node, "MemberExpression")) return isReactNamespaceReceiver(analysis, node.object) && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
+	if (isNodeOfType(node, "MemberExpression")) {
+		const receiver = stripParenExpression(node.object);
+		return isNodeOfType(receiver, "Identifier") && receiver.name === "React" && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
+	}
 	return false;
 };
 const isUseEffect = (node) => {
@@ -30906,27 +30199,7 @@ const isRefCurrent = (ref) => {
 	if (!isNodeOfType(parent.property, "Identifier")) return false;
 	return parent.property.name === "current";
 };
-const resolveStateSetterReference = (analysis, ref) => {
-	const visitedReferences = /* @__PURE__ */ new Set();
-	let currentReference = ref;
-	while (currentReference && !visitedReferences.has(currentReference)) {
-		if (isStateSetter(analysis, currentReference)) return currentReference;
-		visitedReferences.add(currentReference);
-		const definitions = currentReference.resolved?.defs ?? [];
-		if (definitions.length !== 1) return null;
-		const definitionNode = definitions[0].node;
-		if (!isNodeOfType(definitionNode, "VariableDeclarator")) return null;
-		if (!isNodeOfType(definitionNode.id, "Identifier")) return null;
-		const declaration = definitionNode.parent;
-		if (!isNodeOfType(declaration, "VariableDeclaration") || declaration.kind !== "const") return null;
-		if (!definitionNode.init) return null;
-		const initializer = stripParenExpression(definitionNode.init);
-		if (!isNodeOfType(initializer, "Identifier")) return null;
-		currentReference = getRef(analysis, initializer);
-	}
-	return null;
-};
-const isStateSetterCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => resolveStateSetterReference(analysis, innerRef) !== null);
+const isStateSetterCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isStateSetter(analysis, innerRef));
 const isSyncStateSetterCall = (analysis, ref, effectFn) => isStateSetterCall(analysis, ref) && isSynchronous(ref.identifier, effectFn) && !resolvesToAsyncFunction(ref);
 const HANDLER_NAMED_METHOD_PATTERN = /^(on|handle)[A-Z]/;
 const SYNCHRONOUS_CALLBACK_ARGUMENT_INDEX_BY_METHOD = new Map([
@@ -31077,11 +30350,9 @@ const isPropCallbackInvocationRef = (analysis, ref, options = {}) => {
 };
 const isRefCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isRefCurrent(innerRef) || isRef(analysis, innerRef));
 const getUseStateDecl = (analysis, ref) => {
-	const definition = getUpstreamRefs(analysis, ref).find((upstreamReference) => isState(analysis, upstreamReference) || isStateSetter(analysis, upstreamReference))?.resolved?.defs.find((candidateDefinition) => {
-		const definitionNode = candidateDefinition.node;
-		return isNodeOfType(definitionNode, "VariableDeclarator") && isNodeOfType(definitionNode.init, "CallExpression") && isHookCallee$1(analysis, definitionNode.init.callee, "useState");
-	});
-	return definition ? definition.node : null;
+	let node = getUpstreamRefs(analysis, ref).find((upRef) => isHookCallee$1(analysis, upRef.identifier, "useState"))?.identifier;
+	while (node && !isNodeOfType(node, "VariableDeclarator")) node = node.parent;
+	return node ?? null;
 };
 const isCleanupReturnArgument = (analysis, node) => {
 	if (isFunctionLike$1(node)) return true;
@@ -31244,88 +30515,7 @@ const isIndependentWriterIdentifier = (componentFunction, identifier, includeDef
 	if (HANDLER_BINDING_NAME_PATTERN.test(bindingName)) return true;
 	return isSetterWiredToJsxHandler(componentFunction, bindingName);
 };
-const isSynchronousFunction = (functionNode) => {
-	const functionMetadata = functionNode;
-	return functionMetadata.async !== true && functionMetadata.generator !== true;
-};
-const findBindingVariable = (analysis, bindingIdentifier) => {
-	for (const scope of analysis.scopeManager.scopes) for (const variable of scope.variables) if (variable.identifiers.includes(bindingIdentifier)) return variable;
-	return null;
-};
-const getImmutableFunctionVariable = (analysis, componentFunction, functionNode) => {
-	if (!isSynchronousFunction(functionNode) || !isAstDescendant(functionNode, componentFunction)) return null;
-	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
-	if (!bindingIdentifier) return null;
-	const variable = findBindingVariable(analysis, bindingIdentifier);
-	if (!variable || variable.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
-	const definition = variable.defs[0];
-	if (definition.type === "FunctionName") return definition.node === functionNode ? variable : null;
-	if (definition.type !== "Variable") return null;
-	const declarator = definition.node;
-	if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.parent, "VariableDeclaration") || declarator.parent.kind !== "const") return null;
-	if (declarator.init === functionNode) return variable;
-	if (isNodeOfType(declarator.init, "CallExpression") && declarator.init.arguments?.[0] === functionNode && isGenuineReactHookDeclarator(analysis, declarator, "useCallback")) return variable;
-	return null;
-};
-const getJsxEventValueAttribute = (identifier) => {
-	const expression = findTransparentExpressionRoot(identifier);
-	const expressionContainer = expression.parent;
-	if (!isNodeOfType(expressionContainer, "JSXExpressionContainer") || expressionContainer.expression !== expression) return null;
-	const attribute = expressionContainer.parent;
-	if (!isNodeOfType(attribute, "JSXAttribute")) return null;
-	const attributeName = getJsxAttributeName(attribute.name);
-	return attributeName && isEventHandlerName(attributeName) ? attribute : null;
-};
-const getInlineJsxEventCallbackAttribute = (callExpression) => {
-	const callbackFunction = findEnclosingFunction$1(callExpression);
-	if (!callbackFunction || !isSynchronousFunction(callbackFunction)) return null;
-	return getJsxEventValueAttribute(callbackFunction);
-};
-const isReactHookDependencyReference = (identifier) => {
-	const expression = findTransparentExpressionRoot(identifier);
-	const dependencyArray = expression.parent;
-	if (!isNodeOfType(dependencyArray, "ArrayExpression") || !(dependencyArray.elements ?? []).includes(expression)) return false;
-	const hookCall = dependencyArray.parent;
-	if (!isNodeOfType(hookCall, "CallExpression") || hookCall.arguments?.[1] !== dependencyArray) return false;
-	const callee = hookCall.callee;
-	if (isNodeOfType(callee, "Identifier")) return /^use[A-Z0-9]/.test(callee.name);
-	return Boolean(isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && /^use[A-Z0-9]/.test(callee.property.name));
-};
-const hasReachableJsxEventCallPath = (analysis, context, componentFunction, functionVariable, visitedVariables) => {
-	if (visitedVariables.has(functionVariable)) return false;
-	const nextVisitedVariables = new Set(visitedVariables).add(functionVariable);
-	const callExpressions = [];
-	let hasDirectJsxEventReference = false;
-	for (const reference of functionVariable.references) {
-		if (reference.init) continue;
-		const identifier = reference.identifier;
-		if (reference.isWrite()) return false;
-		const jsxEventValueAttribute = getJsxEventValueAttribute(identifier);
-		if (jsxEventValueAttribute) {
-			if (isNodeReachableWithinFunction(jsxEventValueAttribute, context)) hasDirectJsxEventReference = true;
-			continue;
-		}
-		if (isReactHookDependencyReference(identifier)) continue;
-		const callExpression = getCallExpr(reference);
-		if (!callExpression) return false;
-		const jsxEventCallbackAttribute = getInlineJsxEventCallbackAttribute(callExpression);
-		if (jsxEventCallbackAttribute) {
-			if (isNodeReachableWithinFunction(callExpression, context) && isNodeReachableWithinFunction(jsxEventCallbackAttribute, context)) hasDirectJsxEventReference = true;
-			continue;
-		}
-		callExpressions.push(callExpression);
-	}
-	if (hasDirectJsxEventReference) return true;
-	for (const callExpression of callExpressions) {
-		if (!isNodeReachableWithinFunction(callExpression, context)) continue;
-		const callerFunction = findEnclosingFunction$1(callExpression);
-		if (!callerFunction || callerFunction === componentFunction) continue;
-		const callerVariable = getImmutableFunctionVariable(analysis, componentFunction, callerFunction);
-		if (callerVariable && hasReachableJsxEventCallPath(analysis, context, componentFunction, callerVariable, nextVisitedVariables)) return true;
-	}
-	return false;
-};
-const hasUserInputSetterWriter = (analysis, context, setterRef, effectNode, includeDeferredWriters = false) => {
+const hasUserInputSetterWriter = (setterRef, effectNode, includeDeferredWriters = false) => {
 	if (!setterRef.resolved) return false;
 	const componentFunction = findEnclosingFunction$1(effectNode);
 	if (!componentFunction) return false;
@@ -31334,11 +30524,6 @@ const hasUserInputSetterWriter = (analysis, context, setterRef, effectNode, incl
 		const identifier = reference.identifier;
 		if (isAstDescendant(identifier, effectNode)) continue;
 		if (isIndependentWriterIdentifier(componentFunction, identifier, includeDeferredWriters)) return true;
-		if (!isNodeReachableWithinFunction(identifier, context)) continue;
-		const writerFunction = findEnclosingFunction$1(identifier);
-		if (!writerFunction || writerFunction === componentFunction) continue;
-		const writerVariable = getImmutableFunctionVariable(analysis, componentFunction, writerFunction);
-		if (writerVariable && hasReachableJsxEventCallPath(analysis, context, componentFunction, writerVariable, /* @__PURE__ */ new Set())) return true;
 	}
 	return false;
 };
@@ -32228,7 +31413,7 @@ const areInMutuallyExclusiveBranches = (leftNode, rightNode) => {
 	}
 	return false;
 };
-const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFilename) => {
+const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) => {
 	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode, currentFilename);
 	if (frames.length === 0) return [];
 	const effectHasCleanup = hasCleanup(analysis, effectNode);
@@ -32258,7 +31443,7 @@ const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFile
 			for (const returnedExpression of returnedExpressions) mergeEvidence(valueEvidence, collectValueEvidence(analysis, returnedExpression, updaterFrame, remainingValueCallFrames));
 		} else valueEvidence = collectValueEvidence(analysis, writtenValue, frame, remainingValueCallFrames);
 		const sourceReferences = [...valueEvidence.sourceReferences].filter((sourceReference) => getUseStateDecl(analysis, sourceReference) !== stateDeclarator);
-		const hasIndependentWriter = hasUserInputSetterWriter(analysis, context, setterReference, effectNode, true);
+		const hasIndependentWriter = hasUserInputSetterWriter(setterReference, effectNode, true);
 		const doesMatchStateInitializer = matchesStateInitializer(analysis, callExpression, stateDeclarator);
 		if (effectHasCleanup && (frame.isDeferred || valueEvidence.hasUnknownSource || valueEvidence.hasDeferredIntroducedValue || valueEvidence.readsExternalValue)) cleanupManagedStateDeclarators.add(stateDeclarator);
 		const isRenderKnownCopy = sourceReferences.length > 0 && !frame.isDeferred && !valueEvidence.hasUnknownSource && !valueEvidence.hasDeferredIntroducedValue && !valueEvidence.readsExternalValue && !hasIndependentWriter;
@@ -32293,18 +31478,13 @@ const noAdjustStateOnPropChange = defineRule({
 	tags: ["test-noise"],
 	recommendation: "Adjust the state inline during render with a `prev`-prop comparison (`if (prop !== prevProp) { setPrevProp(prop); setX(...); }`), or refactor to remove the duplicated state. Routing the adjustment through a useEffect forces an extra render with a stale UI between the two commits. See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes",
 	create: (context) => ({ CallExpression(node) {
-		if (!isReactApiCall(node, "useEffect", context.scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true,
-			resolveConditionalAliases: true,
-			resolveNamedAliases: true
-		})) return;
+		if (!isUseEffect(node)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const dependencyReferences = getEffectDepsRefs(analysis, node);
 		if (!dependencyReferences) return;
 		if (!dependencyReferences.flatMap((reference) => isState(analysis, reference) ? [] : getUpstreamRefs(analysis, reference)).some((reference) => isProp(analysis, reference))) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 			context.report({
 				node: fact.callExpression,
@@ -35025,7 +34205,7 @@ const noChainStateUpdates = defineRule({
 			if (!callExpr) continue;
 			if (!isReachableFromStateTrigger(callExpr)) continue;
 			if (!readsPostMountValueThroughLocals(callExpr, effectFn, { ignoreBareRefCurrent: true })) continue;
-			const declarator = getUseStateDeclarator(resolveStateSetterReference(analysis, ref) ?? ref);
+			const declarator = getUseStateDeclarator(ref);
 			if (declarator) domSyncedStateDeclarators.add(declarator);
 		}
 		for (const ref of effectFnRefs) {
@@ -35034,7 +34214,7 @@ const noChainStateUpdates = defineRule({
 			if (!callExpr) continue;
 			if (!isReachableFromStateTrigger(callExpr)) continue;
 			if (getArgsUpstreamRefs(analysis, ref).some((argRef) => isState(analysis, argRef))) continue;
-			const setterDeclarator = getUseStateDeclarator(resolveStateSetterReference(analysis, ref) ?? ref);
+			const setterDeclarator = getUseStateDeclarator(ref);
 			if (setterDeclarator && domSyncedStateDeclarators.has(setterDeclarator)) continue;
 			const isSelfTargeting = setterDeclarator !== null && stateDepDeclarators.has(setterDeclarator);
 			const setterArguments = isNodeOfType(callExpr, "CallExpression") ? callExpr.arguments ?? [] : [];
@@ -36875,15 +36055,10 @@ const noDerivedState = defineRule({
 				for (const fact of collectRenderStateWriteFacts(analysis, componentBody, context.filename)) reportStateWrite(fact.callExpression, fact.stateDeclarator);
 			} }).visitors,
 			CallExpression(node) {
-				if (!isReactApiCall(node, "useEffect", context.scopes, {
-					allowGlobalReactNamespace: true,
-					allowUnboundBareCalls: true,
-					resolveConditionalAliases: true,
-					resolveNamedAliases: true
-				})) return;
+				if (!isUseEffect(node)) return;
 				const analysis = getProgramAnalysis(node);
 				if (!analysis) return;
-				for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
+				for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 					if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 					reportStateWrite(fact.callExpression, fact.stateDeclarator);
 				}
@@ -36900,15 +36075,10 @@ const noDerivedStateEffect = defineRule({
 	tags: ["test-noise"],
 	recommendation: "Work out derived values while rendering: `const x = fn(dep)`. To reset a component's state when a prop changes, give it a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
 	create: (context) => ({ CallExpression(node) {
-		if (!isReactApiCall(node, EFFECT_HOOK_NAMES$1, context.scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true,
-			resolveConditionalAliases: true,
-			resolveNamedAliases: true
-		})) return;
+		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		if (!collectEffectStateWriteFacts(analysis, context, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
+		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
 		context.report({
 			node,
 			message: "You pay an extra render for state you can derive from other values."
@@ -37384,20 +36554,9 @@ const noDidMountSetState = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/find-enclosing-class.ts
-const findEnclosingClass = (node) => {
-	let ancestor = node.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "ClassDeclaration") || isNodeOfType(ancestor, "ClassExpression")) return ancestor;
-		ancestor = ancestor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/no-did-update-set-state.ts
 const LIFECYCLE_NAMES$1 = new Set(["componentDidUpdate"]);
 const MESSAGE$27 = "Calling setState in componentDidUpdate can trigger another update immediately, loop forever, and freeze the component.";
-const DIFFERENCE_OPERATORS = new Set(["!=", "!=="]);
 const EQUALITY_OPERATORS = new Set([
 	"==",
 	"===",
@@ -37409,8 +36568,6 @@ const FUNCTION_NODE_TYPES = new Set([
 	"FunctionExpression",
 	"ArrowFunctionExpression"
 ]);
-const CLASS_NODE_TYPES = new Set(["ClassDeclaration", "ClassExpression"]);
-const callbackRefFieldNamesByClass = /* @__PURE__ */ new WeakMap();
 const isLifecycleMethodFunction = (node) => {
 	if (!FUNCTION_NODE_TYPES.has(node.type)) return false;
 	const parent = node.parent;
@@ -37466,187 +36623,6 @@ const getStaticMemberName = (node) => {
 	if (!isNodeOfType(node, "MemberExpression") || node.computed === true) return null;
 	return isNodeOfType(node.property, "Identifier") ? node.property.name : null;
 };
-const getMemberIdentity = (property) => {
-	const propertyName = getPropertyKeyName$2(property);
-	if (propertyName !== void 0) return isNodeOfType(property, "PrivateIdentifier") ? `#${propertyName}` : propertyName;
-	return isNodeOfType(property, "Literal") && typeof property.value === "string" ? property.value : null;
-};
-const collectPreviousSourcePaths = (pattern, domain, members, previousSourcePaths) => {
-	if (!pattern) return;
-	const unwrappedPattern = stripParenExpression(pattern);
-	if (isNodeOfType(unwrappedPattern, "Identifier")) {
-		previousSourcePaths.set(unwrappedPattern.name, {
-			domain,
-			members: [...members],
-			source: "previous"
-		});
-		return;
-	}
-	if (isNodeOfType(unwrappedPattern, "AssignmentPattern")) {
-		collectPreviousSourcePaths(unwrappedPattern.left, domain, members, previousSourcePaths);
-		return;
-	}
-	if (!isNodeOfType(unwrappedPattern, "ObjectPattern")) return;
-	for (const property of unwrappedPattern.properties) {
-		if (!isNodeOfType(property, "Property")) continue;
-		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
-		if (!propertyName) continue;
-		collectPreviousSourcePaths(property.value, domain, [...members, propertyName], previousSourcePaths);
-	}
-};
-const getStateSourcePath = (node, previousSourcePaths) => {
-	let currentNode = stripParenExpression(node);
-	const members = [];
-	while (isNodeOfType(currentNode, "MemberExpression")) {
-		const memberName = getStaticMemberName(currentNode);
-		if (!memberName) return null;
-		members.unshift(memberName);
-		currentNode = stripParenExpression(currentNode.object);
-	}
-	if (isNodeOfType(currentNode, "ThisExpression")) {
-		const [domain, ...pathMembers] = members;
-		if (domain !== "props" && domain !== "state") return null;
-		return {
-			domain,
-			members: pathMembers,
-			source: "current"
-		};
-	}
-	if (!isNodeOfType(currentNode, "Identifier")) return null;
-	const previousSourcePath = previousSourcePaths.get(currentNode.name);
-	return previousSourcePath ? {
-		...previousSourcePath,
-		members: [...previousSourcePath.members, ...members]
-	} : null;
-};
-const haveMatchingStateSourcePaths = (left, right) => left.domain === right.domain && left.members.length === right.members.length && left.members.every((member, index) => member === right.members[index]);
-const collectConjunctiveStateSourceComparisons = (test, previousSourcePaths, comparisons) => {
-	const expression = stripParenExpression(test);
-	if (isNodeOfType(expression, "LogicalExpression") && expression.operator === "&&") {
-		collectConjunctiveStateSourceComparisons(expression.left, previousSourcePaths, comparisons);
-		collectConjunctiveStateSourceComparisons(expression.right, previousSourcePaths, comparisons);
-		return;
-	}
-	if (!isNodeOfType(expression, "BinaryExpression") || !EQUALITY_OPERATORS.has(expression.operator)) return;
-	const leftPath = getStateSourcePath(expression.left, previousSourcePaths);
-	const rightPath = getStateSourcePath(expression.right, previousSourcePaths);
-	if (Boolean(leftPath) === Boolean(rightPath)) return;
-	const path = leftPath ?? rightPath;
-	if (!path) return;
-	comparisons.push({
-		comparedValue: leftPath ? expression.right : expression.left,
-		isDifference: DIFFERENCE_OPERATORS.has(expression.operator),
-		path
-	});
-};
-const isHistoricalToCurrentTransitionGuard = (test, previousSourcePaths) => {
-	const expression = stripParenExpression(test);
-	if (isNodeOfType(expression, "LogicalExpression") && expression.operator === "||") return isHistoricalToCurrentTransitionGuard(expression.left, previousSourcePaths) && isHistoricalToCurrentTransitionGuard(expression.right, previousSourcePaths);
-	const comparisons = [];
-	collectConjunctiveStateSourceComparisons(expression, previousSourcePaths, comparisons);
-	return comparisons.some((comparison, index) => comparisons.slice(index + 1).some((candidate) => comparison.path.source !== candidate.path.source && comparison.isDifference !== candidate.isDifference && haveMatchingStateSourcePaths(comparison.path, candidate.path) && areExpressionsStructurallyEqual(comparison.comparedValue, candidate.comparedValue)));
-};
-const getThisFieldName = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "MemberExpression") || unwrappedNode.computed === true || !isNodeOfType(stripParenExpression(unwrappedNode.object), "ThisExpression")) return null;
-	return getMemberIdentity(unwrappedNode.property);
-};
-const isUndefinedIdentifier = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	return isNodeOfType(unwrappedNode, "Identifier") && unwrappedNode.name === "undefined";
-};
-const isDirectRefParameterValue = (node, parameterSymbolId, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (isNodeOfType(unwrappedNode, "Identifier")) return scopes.symbolFor(unwrappedNode)?.id === parameterSymbolId;
-	if (!isNodeOfType(unwrappedNode, "LogicalExpression") || unwrappedNode.operator !== "??") return false;
-	const left = stripParenExpression(unwrappedNode.left);
-	return isNodeOfType(left, "Identifier") && scopes.symbolFor(left)?.id === parameterSymbolId && isUndefinedIdentifier(unwrappedNode.right);
-};
-const getCallbackRefAssignedFields = (callback, scopes) => {
-	const firstParameter = (callback.params ?? [])[0];
-	if (!firstParameter) return /* @__PURE__ */ new Set();
-	const parameterIdentifier = isNodeOfType(firstParameter, "AssignmentPattern") ? firstParameter.left : firstParameter;
-	if (!isNodeOfType(parameterIdentifier, "Identifier")) return /* @__PURE__ */ new Set();
-	const parameterSymbolId = scopes.symbolFor(parameterIdentifier)?.id;
-	if (parameterSymbolId === void 0) return /* @__PURE__ */ new Set();
-	const body = callback.body;
-	if (!body) return /* @__PURE__ */ new Set();
-	const assignedFieldNames = /* @__PURE__ */ new Set();
-	walkAst(body, (node) => {
-		if (node !== body && (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node) || CLASS_NODE_TYPES.has(node.type))) return false;
-		const assignmentTarget = isNodeOfType(node, "AssignmentExpression") && node.left || isNodeOfType(node, "UpdateExpression") && node.argument || isNodeOfType(node, "UnaryExpression") && node.operator === "delete" && node.argument || null;
-		if (!assignmentTarget) return;
-		const fieldName = getThisFieldName(assignmentTarget);
-		if (!fieldName) return;
-		if (isNodeOfType(node, "AssignmentExpression") && node.operator === "=" && isDirectRefParameterValue(node.right, parameterSymbolId, scopes)) {
-			assignedFieldNames.add(fieldName);
-			return;
-		}
-		assignedFieldNames.delete(fieldName);
-	});
-	return assignedFieldNames;
-};
-const getClassMemberCallback = (classNode, memberName) => {
-	const classBody = classNode.body?.body ?? [];
-	for (const member of classBody) {
-		if (!isNodeOfType(member, "MethodDefinition") && !isNodeOfType(member, "PropertyDefinition")) continue;
-		if (member.static === true) continue;
-		const key = member.key;
-		if (getMemberIdentity(key) !== memberName) continue;
-		const value = member.value;
-		return value && FUNCTION_NODE_TYPES.has(value.type) ? value : null;
-	}
-	return null;
-};
-const collectCallbackRefFieldsFromExpression = (expression, classNode, fieldNames, scopes) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (FUNCTION_NODE_TYPES.has(unwrappedExpression.type)) {
-		for (const fieldName of getCallbackRefAssignedFields(unwrappedExpression, scopes)) fieldNames.add(fieldName);
-		return;
-	}
-	const handlerName = getThisFieldName(unwrappedExpression);
-	if (handlerName) {
-		const callback = getClassMemberCallback(classNode, handlerName);
-		if (callback) for (const fieldName of getCallbackRefAssignedFields(callback, scopes)) fieldNames.add(fieldName);
-		return;
-	}
-	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
-		collectCallbackRefFieldsFromExpression(unwrappedExpression.consequent, classNode, fieldNames, scopes);
-		collectCallbackRefFieldsFromExpression(unwrappedExpression.alternate, classNode, fieldNames, scopes);
-		return;
-	}
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		if (unwrappedExpression.operator !== "&&") collectCallbackRefFieldsFromExpression(unwrappedExpression.left, classNode, fieldNames, scopes);
-		collectCallbackRefFieldsFromExpression(unwrappedExpression.right, classNode, fieldNames, scopes);
-	}
-};
-const getCallbackRefFieldNames = (classNode, scopes) => {
-	if (!classNode) return /* @__PURE__ */ new Set();
-	const cachedFieldNames = callbackRefFieldNamesByClass.get(classNode);
-	if (cachedFieldNames) return cachedFieldNames;
-	const fieldNames = /* @__PURE__ */ new Set();
-	const classBody = classNode.body;
-	if (classBody) walkAst(classBody, (node) => {
-		if (node !== classBody && CLASS_NODE_TYPES.has(node.type)) return false;
-		if (!isNodeOfType(node, "JSXAttribute") || !isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "ref" || !node.value || !isNodeOfType(node.value, "JSXExpressionContainer") || !node.value.expression) return;
-		collectCallbackRefFieldsFromExpression(node.value.expression, classNode, fieldNames, scopes);
-	});
-	callbackRefFieldNamesByClass.set(classNode, fieldNames);
-	return fieldNames;
-};
-const collectLifecycleWrittenFieldNames = (lifecycleFunction) => {
-	const fieldNames = /* @__PURE__ */ new Set();
-	const body = lifecycleFunction.body;
-	if (!body) return fieldNames;
-	walkAst(body, (node) => {
-		if (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node)) return false;
-		const target = isNodeOfType(node, "AssignmentExpression") && node.left || isNodeOfType(node, "UpdateExpression") && node.argument || null;
-		if (!target) return;
-		const fieldName = getThisFieldName(target);
-		if (fieldName) fieldNames.add(fieldName);
-	});
-	return fieldNames;
-};
 const getThisStateFieldName = (node) => {
 	const unwrappedNode = stripParenExpression(node);
 	if (!isNodeOfType(unwrappedNode, "MemberExpression")) return null;
@@ -37664,17 +36640,15 @@ const collectLocalInitializers = (lifecycleFunction) => {
 	});
 	return initializers;
 };
-const derivesFromPostMountValue = (node, localInitializers, callbackRefFieldNames, visitedNames = /* @__PURE__ */ new Set()) => {
+const derivesFromPostMountValue = (node, localInitializers, visitedNames = /* @__PURE__ */ new Set()) => {
 	if (readsPostMountValue(node)) return true;
-	const fieldName = getThisFieldName(node);
-	if (fieldName && callbackRefFieldNames.has(fieldName)) return true;
 	const referencedNames = /* @__PURE__ */ new Set();
 	collectReferenceIdentifierNames(node, referencedNames);
 	for (const referencedName of referencedNames) {
 		if (visitedNames.has(referencedName)) continue;
 		const initializer = localInitializers.get(referencedName);
 		if (!initializer) continue;
-		if (derivesFromPostMountValue(initializer, localInitializers, callbackRefFieldNames, new Set([...visitedNames, referencedName]))) return true;
+		if (derivesFromPostMountValue(initializer, localInitializers, new Set([...visitedNames, referencedName]))) return true;
 	}
 	return false;
 };
@@ -37688,84 +36662,50 @@ const getSetStateFieldValue = (setStateCall, fieldName) => {
 	}
 	return null;
 };
-const isConvergentPostMountGuard = (test, setStateCall, localInitializers, callbackRefFieldNames, isTruthfulBranch) => {
-	const expression = stripParenExpression(test);
-	if (isNodeOfType(expression, "LogicalExpression")) {
-		if (expression.operator !== "&&" && expression.operator !== "||") return false;
-		const leftIsConvergent = isConvergentPostMountGuard(expression.left, setStateCall, localInitializers, callbackRefFieldNames, isTruthfulBranch);
-		const rightIsConvergent = isConvergentPostMountGuard(expression.right, setStateCall, localInitializers, callbackRefFieldNames, isTruthfulBranch);
-		return isTruthfulBranch && expression.operator === "||" || !isTruthfulBranch && expression.operator === "&&" ? leftIsConvergent && rightIsConvergent : leftIsConvergent || rightIsConvergent;
-	}
-	if (!isNodeOfType(expression, "BinaryExpression") || !(isTruthfulBranch ? DIFFERENCE_OPERATORS.has(expression.operator) : EQUALITY_OPERATORS.has(expression.operator) && !DIFFERENCE_OPERATORS.has(expression.operator))) return false;
-	const leftFieldName = getThisStateFieldName(expression.left);
-	const rightFieldName = getThisStateFieldName(expression.right);
-	const fieldName = leftFieldName ?? rightFieldName;
-	const comparedValue = leftFieldName ? expression.right : expression.left;
-	if (!fieldName) return false;
-	const assignedValue = getSetStateFieldValue(setStateCall, fieldName);
-	if (!assignedValue || !areExpressionsStructurallyEqual(comparedValue, assignedValue)) return false;
-	return isUndefinedIdentifier(comparedValue) || derivesFromPostMountValue(comparedValue, localInitializers, callbackRefFieldNames);
-};
-const containsPositiveStateFieldTest = (test, fieldName) => {
-	const unwrappedTest = stripParenExpression(test);
-	if (getThisStateFieldName(unwrappedTest) === fieldName) return true;
-	return isNodeOfType(unwrappedTest, "LogicalExpression") && unwrappedTest.operator === "&&" && (containsPositiveStateFieldTest(unwrappedTest.left, fieldName) || containsPositiveStateFieldTest(unwrappedTest.right, fieldName));
-};
-const isConvergentUndefinedClearGuard = (test, setStateCall) => {
-	if (!isNodeOfType(setStateCall, "CallExpression")) return false;
-	const argument = setStateCall.arguments?.[0];
-	if (!argument || !isNodeOfType(argument, "ObjectExpression")) return false;
-	for (const property of argument.properties ?? []) {
-		if (!isNodeOfType(property, "Property") || property.computed === true || !isUndefinedIdentifier(property.value)) continue;
-		const fieldName = isNodeOfType(property.key, "Identifier") && property.key.name || isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" && property.key.value || null;
-		if (fieldName && containsPositiveStateFieldTest(test, fieldName)) return true;
-	}
-	return false;
-};
-const isDiffGuardTest = (test, paramNames, derivedNames, isTruthfulBranch) => {
-	const expression = stripParenExpression(test);
-	if (isNodeOfType(expression, "LogicalExpression")) {
-		if (expression.operator !== "&&" && expression.operator !== "||") return false;
-		const leftIsDiffGuard = isDiffGuardTest(expression.left, paramNames, derivedNames, isTruthfulBranch);
-		const rightIsDiffGuard = isDiffGuardTest(expression.right, paramNames, derivedNames, isTruthfulBranch);
-		return isTruthfulBranch && expression.operator === "||" || !isTruthfulBranch && expression.operator === "&&" ? leftIsDiffGuard && rightIsDiffGuard : leftIsDiffGuard || rightIsDiffGuard;
-	}
-	if (!isNodeOfType(expression, "BinaryExpression") || !(isTruthfulBranch ? DIFFERENCE_OPERATORS.has(expression.operator) : EQUALITY_OPERATORS.has(expression.operator) && !DIFFERENCE_OPERATORS.has(expression.operator))) return false;
-	return isStatefulOperand(expression.left, paramNames, derivedNames) && isStatefulOperand(expression.right, paramNames, derivedNames) && (referencesAnyName(expression.left, paramNames) || referencesAnyName(expression.right, paramNames) || referencesAnyName(expression.left, derivedNames) || referencesAnyName(expression.right, derivedNames));
+const isConvergentPostMountGuard = (test, setStateCall, localInitializers) => {
+	let qualifies = false;
+	walkAst(test, (node) => {
+		if (qualifies) return false;
+		if (!isNodeOfType(node, "BinaryExpression") || !EQUALITY_OPERATORS.has(node.operator)) return;
+		const leftFieldName = getThisStateFieldName(node.left);
+		const rightFieldName = getThisStateFieldName(node.right);
+		const fieldName = leftFieldName ?? rightFieldName;
+		const comparedValue = leftFieldName ? node.right : node.left;
+		if (!fieldName || !leftFieldName && !rightFieldName) return;
+		const assignedValue = getSetStateFieldValue(setStateCall, fieldName);
+		if (!assignedValue || !areExpressionsStructurallyEqual(comparedValue, assignedValue)) return;
+		if (!derivesFromPostMountValue(comparedValue, localInitializers)) return;
+		qualifies = true;
+		return false;
+	});
+	return qualifies;
+};
+const isDiffGuardTest = (test, paramNames, derivedNames) => {
+	if (referencesAnyName(test, paramNames)) return true;
+	let qualifies = false;
+	walkAst(test, (node) => {
+		if (qualifies) return false;
+		if (!isNodeOfType(node, "BinaryExpression")) return;
+		if (!EQUALITY_OPERATORS.has(node.operator)) return;
+		if (isStatefulOperand(node.left, paramNames, derivedNames) && isStatefulOperand(node.right, paramNames, derivedNames) && (referencesAnyName(node.left, derivedNames) || referencesAnyName(node.right, derivedNames))) {
+			qualifies = true;
+			return false;
+		}
+	});
+	return qualifies;
 };
-const isInsideDiffGuard = (setStateCall, scopes) => {
+const isInsideDiffGuard = (setStateCall) => {
 	const lifecycleFunction = findEnclosingLifecycleFunction(setStateCall);
 	if (!lifecycleFunction) return false;
 	const paramNames = /* @__PURE__ */ new Set();
-	const parameters = lifecycleFunction.params ?? [];
-	for (const param of parameters) collectPatternNames(param, paramNames);
-	const previousSourcePaths = /* @__PURE__ */ new Map();
-	const [previousPropsParameter, previousStateParameter] = parameters;
-	collectPreviousSourcePaths(previousPropsParameter, "props", [], previousSourcePaths);
-	collectPreviousSourcePaths(previousStateParameter, "state", [], previousSourcePaths);
+	for (const param of lifecycleFunction.params ?? []) collectPatternNames(param, paramNames);
 	const derivedNames = collectDiffSourceLocalNames(lifecycleFunction, paramNames);
 	const localInitializers = collectLocalInitializers(lifecycleFunction);
-	const lifecycleWrittenFieldNames = collectLifecycleWrittenFieldNames(lifecycleFunction);
-	const callbackRefFieldNames = new Set([...getCallbackRefFieldNames(findEnclosingClass(lifecycleFunction), scopes)].filter((fieldName) => !lifecycleWrittenFieldNames.has(fieldName)));
 	let child = setStateCall;
 	let ancestor = setStateCall.parent;
 	while (ancestor && ancestor !== lifecycleFunction) {
-		let guardTest = null;
-		let isTruthfulBranch = true;
-		if (isNodeOfType(ancestor, "IfStatement")) {
-			if (child === ancestor.consequent) guardTest = ancestor.test;
-			else if (child === ancestor.alternate) {
-				guardTest = ancestor.test;
-				isTruthfulBranch = false;
-			}
-		} else if (isNodeOfType(ancestor, "ConditionalExpression")) {
-			if (child === ancestor.consequent) guardTest = ancestor.test;
-			else if (child === ancestor.alternate) {
-				guardTest = ancestor.test;
-				isTruthfulBranch = false;
-			}
-		} else if (isNodeOfType(ancestor, "LogicalExpression") && ancestor.operator === "&&" && child === ancestor.right) guardTest = ancestor.left;
-		if (guardTest && (isDiffGuardTest(guardTest, paramNames, derivedNames, isTruthfulBranch) || isTruthfulBranch && isHistoricalToCurrentTransitionGuard(guardTest, previousSourcePaths) || isConvergentPostMountGuard(guardTest, setStateCall, localInitializers, callbackRefFieldNames, isTruthfulBranch) || isTruthfulBranch && isConvergentUndefinedClearGuard(guardTest, setStateCall))) return true;
+		const guardTest = isNodeOfType(ancestor, "IfStatement") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "ConditionalExpression") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "LogicalExpression") && ancestor.operator === "&&" && child === ancestor.right && ancestor.left || null;
+		if (guardTest && (isDiffGuardTest(guardTest, paramNames, derivedNames) || isConvergentPostMountGuard(guardTest, setStateCall, localInitializers))) return true;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
 	}
@@ -37787,7 +36727,7 @@ const noDidUpdateSetState = defineRule({
 			if (!isNodeOfType(stripParenExpression(node.callee.object), "ThisExpression")) return;
 			if (!isNodeOfType(node.callee.property, "Identifier") || node.callee.property.name !== "setState") return;
 			if (!isSetStateCallInLifecycle(node, LIFECYCLE_NAMES$1, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
-			if (isInsideDiffGuard(node, context.scopes)) return;
+			if (isInsideDiffGuard(node)) return;
 			context.report({
 				node: node.callee,
 				message: MESSAGE$27
@@ -37857,7 +36797,7 @@ const noDirectMutationState = defineRule({
 const isSetterIdentifier = (name) => SETTER_PATTERN.test(name);
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/collect-use-state-bindings.ts
-const collectUseStateBindings = (componentBody, scopes) => {
+const collectUseStateBindings = (componentBody) => {
 	const bindings = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return bindings;
 	for (const statement of componentBody.body ?? []) {
@@ -37870,12 +36810,7 @@ const collectUseStateBindings = (componentBody, scopes) => {
 			const setterElement = elements[1];
 			if (!isNodeOfType(valueElement, "Identifier") || !isNodeOfType(setterElement, "Identifier") || !isSetterIdentifier(setterElement.name)) continue;
 			if (!isNodeOfType(declarator.init, "CallExpression")) continue;
-			if (!(scopes ? isReactApiCall(declarator.init, "useState", scopes, {
-				allowGlobalReactNamespace: true,
-				allowUnboundBareCalls: true,
-				resolveConditionalAliases: true,
-				resolveNamedAliases: true
-			}) : isHookCall$2(declarator.init, "useState"))) continue;
+			if (!isHookCall$2(declarator.init, "useState")) continue;
 			bindings.push({
 				valueName: valueElement.name,
 				setterName: setterElement.name,
@@ -38602,36 +37537,25 @@ const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSub
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-effect-chain.ts
-const findTopLevelEffectCalls = (componentBody, scopes) => {
+const findTopLevelEffectCalls = (componentBody) => {
 	const effectCalls = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return effectCalls;
 	for (const statement of componentBody.body ?? []) {
 		if (!isNodeOfType(statement, "ExpressionStatement")) continue;
 		const expression = unwrapDiscardedExpression(statement);
 		if (!isNodeOfType(expression, "CallExpression")) continue;
-		if (!isReactApiCall(expression, EFFECT_HOOK_NAMES$1, scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true,
-			resolveConditionalAliases: true,
-			resolveNamedAliases: true
-		})) continue;
+		if (!isHookCall$2(expression, EFFECT_HOOK_NAMES$1)) continue;
 		effectCalls.push(expression);
 	}
 	return effectCalls;
 };
-const collectDependencyStateSymbolIds = (effectNode, stateSymbolIds, scopes) => {
-	const dependencyStateSymbolIds = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(effectNode, "CallExpression")) return dependencyStateSymbolIds;
+const collectDepIdentifierNames = (effectNode) => {
+	const depNames = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(effectNode, "CallExpression")) return depNames;
 	const depsNode = effectNode.arguments?.[1];
-	if (!isNodeOfType(depsNode, "ArrayExpression")) return dependencyStateSymbolIds;
-	for (const element of depsNode.elements ?? []) {
-		if (!element || isNodeOfType(element, "SpreadElement")) continue;
-		const rootIdentifier = getRootIdentifier$1(element);
-		if (!isNodeOfType(rootIdentifier, "Identifier")) continue;
-		const symbol = resolveConstIdentifierAlias(rootIdentifier, scopes, true);
-		if (symbol && stateSymbolIds.has(symbol.id)) dependencyStateSymbolIds.add(symbol.id);
-	}
-	return dependencyStateSymbolIds;
+	if (!isNodeOfType(depsNode, "ArrayExpression")) return depNames;
+	for (const element of depsNode.elements ?? []) if (isNodeOfType(element, "Identifier")) depNames.add(element.name);
+	return depNames;
 };
 const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
 	const analysisFunctions = new Set([effectCallback]);
@@ -38737,13 +37661,12 @@ const readStaticSetterValue = (setterCall, scopes) => {
 	if (updater) return readStaticUpdaterReturnValue(updater, scopes);
 	return readStaticEffectValue(argument, scopes, null, null);
 };
-const collectStateWritesInEffect = (analysisFunctions, setterSymbolIdToStateName, scopes) => {
+const collectStateWritesInEffect = (analysisFunctions, setterToStateName, scopes) => {
 	const stateWrites = /* @__PURE__ */ new Map();
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
-		const setterSymbol = resolveConstIdentifierAlias(child.callee, scopes, true);
-		const stateName = setterSymbol ? setterSymbolIdToStateName.get(setterSymbol.id) : void 0;
+		const stateName = setterToStateName.get(child.callee.name);
 		if (!stateName) return;
 		const writeInfo = stateWrites.get(stateName) ?? {
 			values: /* @__PURE__ */ new Set(),
@@ -38829,12 +37752,11 @@ const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
 	"keys",
 	"values"
 ]);
-const isFunctionShapedReturn = (returnedValue, setterToStateName, setterSymbolIdToStateName, scopes, isExplicitReturnStatement) => {
+const isFunctionShapedReturn = (returnedValue, setterToStateName, isExplicitReturnStatement) => {
 	if (isNodeOfType(returnedValue, "ArrowFunctionExpression") || isNodeOfType(returnedValue, "FunctionExpression")) return true;
 	if (isNodeOfType(returnedValue, "CallExpression")) {
 		if (isNodeOfType(returnedValue.callee, "Identifier")) {
-			const setterSymbol = resolveConstIdentifierAlias(returnedValue.callee, scopes, true);
-			if (setterToStateName.has(returnedValue.callee.name) || setterSymbol && setterSymbolIdToStateName.has(setterSymbol.id)) return false;
+			if (setterToStateName.has(returnedValue.callee.name)) return false;
 			if (isSetterIdentifier(returnedValue.callee.name)) return true;
 		}
 		return isCleanupReturn(returnedValue, EMPTY_CLEANUP_NAME_SET, EMPTY_CLEANUP_NAME_SET, { allowOpaqueReturn: isExplicitReturnStatement });
@@ -39001,11 +37923,11 @@ const isExternalSyncNode = (node) => {
 	const receiverRootName = getRootIdentifierName(node.callee.object);
 	return receiverRootName !== null && EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS.has(receiverRootName);
 };
-const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, setterSymbolIdToStateName, scopes, allowCommittedDomSync) => {
+const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, scopes, allowCommittedDomSync) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
 	if (!isNodeOfType(effectCallback.body, "BlockStatement")) {
-		if (isFunctionShapedReturn(effectCallback.body, setterToStateName, setterSymbolIdToStateName, scopes, false)) return true;
-	} else for (const statement of effectCallback.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument && isFunctionShapedReturn(statement.argument, setterToStateName, setterSymbolIdToStateName, scopes, true)) return true;
+		if (isFunctionShapedReturn(effectCallback.body, setterToStateName, false)) return true;
+	} else for (const statement of effectCallback.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument && isFunctionShapedReturn(statement.argument, setterToStateName, true)) return true;
 	let didFindExternalCall = false;
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (isExternalSyncNode(child) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
@@ -39021,11 +37943,10 @@ const noEffectChain = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const useStateBindings = collectUseStateBindings(componentBody, context.scopes);
+			const useStateBindings = collectUseStateBindings(componentBody);
 			if (useStateBindings.length === 0) return;
 			const setterToStateName = /* @__PURE__ */ new Map();
 			const stateSymbolIds = /* @__PURE__ */ new Map();
-			const setterSymbolIdToStateName = /* @__PURE__ */ new Map();
 			for (const binding of useStateBindings) {
 				setterToStateName.set(binding.setterName, binding.valueName);
 				if (!isNodeOfType(binding.declarator.id, "ArrayPattern")) continue;
@@ -39034,27 +37955,21 @@ const noEffectChain = defineRule({
 					const stateSymbol = context.scopes.symbolFor(stateIdentifier);
 					if (stateSymbol) stateSymbolIds.set(binding.valueName, stateSymbol.id);
 				}
-				const setterIdentifier = binding.declarator.id.elements[1];
-				if (isNodeOfType(setterIdentifier, "Identifier")) {
-					const setterSymbol = context.scopes.symbolFor(setterIdentifier);
-					if (setterSymbol) setterSymbolIdToStateName.set(setterSymbol.id, binding.valueName);
-				}
 			}
 			const storageSetterNames = collectStorageHookSetterNames(componentBody);
-			const stateSymbolIdSet = new Set(stateSymbolIds.values());
 			const effectInfos = [];
-			for (const effectCall of findTopLevelEffectCalls(componentBody, context.scopes)) {
+			for (const effectCall of findTopLevelEffectCalls(componentBody)) {
 				const callback = getEffectCallback(effectCall, context.scopes);
 				if (!callback || !isFunctionLike$1(callback) || callback.async) continue;
 				const analysisFunctions = collectSynchronouslyInvokedFunctions(callback, context.scopes);
-				const stateWrites = collectStateWritesInEffect(analysisFunctions, setterSymbolIdToStateName, context.scopes);
+				const stateWrites = collectStateWritesInEffect(analysisFunctions, setterToStateName, context.scopes);
 				const writtenStateNames = new Set(stateWrites.keys());
 				effectInfos.push({
 					node: effectCall,
-					dependencyStateSymbolIds: collectDependencyStateSymbolIds(effectCall, stateSymbolIdSet, context.scopes),
+					depNames: collectDepIdentifierNames(effectCall),
 					stateWrites,
 					analysisFunctions,
-					isExternalSync: isExternalSyncEffect(callback, analysisFunctions, setterToStateName, setterSymbolIdToStateName, context.scopes, writtenStateNames.size === 0) || callsStorageHookSetter(analysisFunctions, storageSetterNames) || writtenStateNames.size === 0 && callsOpaqueExternalSetter(analysisFunctions, setterToStateName)
+					isExternalSync: isExternalSyncEffect(callback, analysisFunctions, setterToStateName, context.scopes, writtenStateNames.size === 0) || callsStorageHookSetter(analysisFunctions, storageSetterNames) || writtenStateNames.size === 0 && callsOpaqueExternalSetter(analysisFunctions, setterToStateName)
 				});
 			}
 			if (effectInfos.length < 2) return;
@@ -39065,11 +37980,10 @@ const noEffectChain = defineRule({
 				for (const readerEffect of effectInfos) {
 					if (readerEffect === writerEffect) continue;
 					if (readerEffect.isExternalSync) continue;
-					if (readerEffect.dependencyStateSymbolIds.size === 0) continue;
+					if (readerEffect.depNames.size === 0) continue;
 					let chainedStateName = null;
 					for (const [writtenName, writeInfo] of writerEffect.stateWrites) {
-						const writtenStateSymbolId = stateSymbolIds.get(writtenName);
-						if (writtenStateSymbolId === void 0 || !readerEffect.dependencyStateSymbolIds.has(writtenStateSymbolId)) continue;
+						if (!readerEffect.depNames.has(writtenName)) continue;
 						if (!canStateWriteReachReaderWork(writeInfo, readerEffect, stateSymbolIds.get(writtenName) ?? null, context.scopes)) continue;
 						chainedStateName = writtenName;
 						break;
@@ -40885,17 +39799,6 @@ const DOM_MEASUREMENT_NAMES = new Set([
 	"scrollHeight"
 ]);
 const MEASUREMENT_HELPER_CALLEE_PATTERN = /^(?:get|measure|read)\w*(?:Width|Height|Rect|Rects|Size|Bounds|Position)$/;
-const IMPERATIVE_DOM_MUTATION_NAMES = new Set([
-	"blur",
-	"focus",
-	"restoreSelection",
-	"scroll",
-	"scrollBy",
-	"scrollIntoView",
-	"scrollTo",
-	"setRangeText",
-	"setSelectionRange"
-]);
 const subtreeReadsDomMeasurement = (root) => {
 	if (!root) return false;
 	let found = false;
@@ -40914,66 +39817,29 @@ const subtreeReadsDomMeasurement = (root) => {
 	});
 	return found;
 };
-const collectFunctionNamesMatchingBody = (program, matchesBody) => {
+const collectMeasuringFunctionNames = (program) => {
 	const names = /* @__PURE__ */ new Set();
 	walkAst(program, (child) => {
 		if (isNodeOfType(child, "FunctionDeclaration")) {
-			if (child.id && isNodeOfType(child.id, "Identifier") && matchesBody(child.body)) names.add(child.id.name);
+			if (child.id && isNodeOfType(child.id, "Identifier") && subtreeReadsDomMeasurement(child.body)) names.add(child.id.name);
 			return;
 		}
 		if (!isNodeOfType(child, "VariableDeclarator") || !isNodeOfType(child.id, "Identifier")) return;
 		let functionValue = child.init;
 		if (functionValue && isNodeOfType(functionValue, "CallExpression") && isNodeOfType(functionValue.callee, "Identifier") && /^use[A-Z]/.test(functionValue.callee.name)) functionValue = functionValue.arguments?.[0];
-		if (functionValue && isFunctionLike$1(functionValue) && matchesBody(functionValue.body)) names.add(child.id.name);
+		if (functionValue && isFunctionLike$1(functionValue) && subtreeReadsDomMeasurement(functionValue.body)) names.add(child.id.name);
 	});
 	return names;
 };
-const collectMeasuringFunctionNames = (program) => collectFunctionNamesMatchingBody(program, subtreeReadsDomMeasurement);
-const subtreeMutatesDomImperatively = (root) => {
-	if (!root || isFunctionLike$1(root)) return false;
-	let found = false;
-	walkAst(root, (child) => {
-		if (found) return false;
-		if (child !== root && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = stripParenExpression(child.callee);
-		const propertyName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : null;
-		if (propertyName !== null && IMPERATIVE_DOM_MUTATION_NAMES.has(propertyName)) {
-			found = true;
-			return false;
-		}
-	});
-	return found;
-};
-const collectImperativeDomFunctionNames = (program) => collectFunctionNamesMatchingBody(program, subtreeMutatesDomImperatively);
-const callsAnyName = (root, names, shouldSkipNestedFunctions = false) => {
-	if (!root || names.size === 0 || shouldSkipNestedFunctions && isFunctionLike$1(root)) return false;
+const callsAnyName = (root, names) => {
+	if (!root || names.size === 0) return false;
 	let found = false;
 	walkAst(root, (child) => {
 		if (found) return false;
-		if (shouldSkipNestedFunctions && child !== root && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && names.has(child.callee.name)) found = true;
 	});
 	return found;
 };
-const isFollowedByImperativeDomMutation = (call, imperativeDomFunctionNames) => {
-	let statement = call;
-	let parent = statement.parent;
-	while (parent) {
-		const statements = isNodeOfType(parent, "BlockStatement") || isNodeOfType(parent, "Program") || isNodeOfType(parent, "StaticBlock") ? parent.body : isNodeOfType(parent, "SwitchCase") ? parent.consequent : null;
-		if (statements) {
-			const statementIndex = statements.findIndex((siblingStatement) => siblingStatement === statement);
-			if (statementIndex >= 0) {
-				const nextStatement = statements[statementIndex + 1];
-				return subtreeMutatesDomImperatively(nextStatement) || callsAnyName(nextStatement, imperativeDomFunctionNames, true);
-			}
-		}
-		if (isFunctionLike$1(parent) || parent.type.endsWith("Statement") && !isNodeOfType(parent, "ExpressionStatement")) return false;
-		statement = parent;
-		parent = parent.parent;
-	}
-	return false;
-};
 const isInsideStartViewTransition = (node) => {
 	let cursor = node.parent;
 	while (cursor) {
@@ -41014,12 +39880,11 @@ const importsImperativeDomLibrary = (program) => {
 };
 const hasExemptFlushSyncCall = (program, localName) => {
 	const measuringFunctionNames = collectMeasuringFunctionNames(program);
-	const imperativeDomFunctionNames = collectImperativeDomFunctionNames(program);
 	let exempt = false;
 	walkAst(program, (child) => {
 		if (exempt) return false;
 		if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "Identifier") || child.callee.name !== localName) return;
-		if (isInsideStartViewTransition(child) || enclosingFunctionChainReadsMeasurement(child, measuringFunctionNames) || isFollowedByImperativeDomMutation(child, imperativeDomFunctionNames)) {
+		if (isInsideStartViewTransition(child) || enclosingFunctionChainReadsMeasurement(child, measuringFunctionNames)) {
 			exempt = true;
 			return false;
 		}
@@ -41584,223 +40449,41 @@ const readLogicalConditionResult = (operator, leftResult, rightResult) => {
 	if (leftResult === false && rightResult === false) return false;
 	return null;
 };
-const readHydrationConditionResult = (expression, context, runtime, state) => {
+const readHydrationConditionResult = (expression, context, runtime) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
 	if (predicateMatch) return predicateMatch[`${runtime}Result`];
 	const staticResult = readInitialStateBoolean(unwrappedExpression, context.scopes);
 	if (staticResult !== null) return staticResult;
-	const expressionSymbol = isNodeOfType(unwrappedExpression, "Identifier") ? context.scopes.symbolFor(unwrappedExpression) : null;
-	const parameterValue = expressionSymbol ? state.parameterValuesBySymbolId.get(expressionSymbol.id) : null;
-	if (expressionSymbol && parameterValue && !state.visitedSymbolIds.has(expressionSymbol.id)) {
-		state.visitedSymbolIds.add(expressionSymbol.id);
-		const result = readHydrationConditionResult(parameterValue, context, runtime, state);
-		state.visitedSymbolIds.delete(expressionSymbol.id);
-		return result;
-	}
-	if (expressionSymbol && expressionSymbol.kind === "const" && expressionSymbol.initializer && expressionSymbol.references.every((reference) => reference.flag === "read") && !state.visitedSymbolIds.has(expressionSymbol.id)) {
-		state.visitedSymbolIds.add(expressionSymbol.id);
-		const result = readHydrationConditionResult(expressionSymbol.initializer, context, runtime, state);
-		state.visitedSymbolIds.delete(expressionSymbol.id);
-		return result;
-	}
-	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
-		const callArguments = unwrappedExpression.arguments ?? [];
-		if (isReactApiCall(unwrappedExpression, "useMemo", context.scopes, {
-			allowGlobalReactNamespace: true,
-			resolveNamedAliases: true
-		})) {
-			const callbackArgument = callArguments[0];
-			if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
-			const callbackFunction = resolveExactLocalFunction(callbackArgument, context.scopes);
-			return isFunctionLike$1(callbackFunction) && callbackFunction.params.length === 0 ? readHydrationFunctionResult(callbackFunction, context, runtime, state) : null;
-		}
-		const callee = stripParenExpression(unwrappedExpression.callee);
-		if (isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee) && callArguments.length === 1 && !isNodeOfType(callArguments[0], "SpreadElement")) return readHydrationConditionResult(callArguments[0], context, runtime, state);
-		const helperFunction = resolveExactLocalFunction(callee, context.scopes);
-		if (!isFunctionLike$1(helperFunction) || helperFunction.async || isNodeOfType(helperFunction, "FunctionDeclaration") && helperFunction.generator || isNodeOfType(helperFunction, "FunctionExpression") && helperFunction.generator || helperFunction.params.some((parameter) => !isNodeOfType(parameter, "Identifier")) || callArguments.some((argument) => isNodeOfType(argument, "SpreadElement"))) return null;
-		const parameterValuesBySymbolId = new Map(state.parameterValuesBySymbolId);
-		for (let parameterIndex = 0; parameterIndex < helperFunction.params.length; parameterIndex++) {
-			const parameter = helperFunction.params[parameterIndex];
-			const argument = callArguments[parameterIndex];
-			if (!argument || !isNodeOfType(parameter, "Identifier")) continue;
-			const parameterSymbol = context.scopes.symbolFor(parameter);
-			if (parameterSymbol) parameterValuesBySymbolId.set(parameterSymbol.id, argument);
-		}
-		return readHydrationFunctionResult(helperFunction, context, runtime, {
-			...state,
-			parameterValuesBySymbolId
-		});
-	}
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime, state);
+		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime);
 		return argumentResult === null ? null : !argumentResult;
 	}
 	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime, state), readHydrationConditionResult(unwrappedExpression.right, context, runtime, state));
-};
-const readHydrationStatementResult = (statement, context, runtime, state) => {
-	if (isNodeOfType(statement, "ReturnStatement")) return {
-		didReturn: true,
-		value: statement.argument ? readHydrationConditionResult(statement.argument, context, runtime, state) : null
-	};
-	if (isNodeOfType(statement, "BlockStatement")) {
-		for (const childStatement of statement.body) {
-			const result = readHydrationStatementResult(childStatement, context, runtime, state);
-			if (result.didReturn) return result;
-			if (statementAlwaysExits(childStatement)) break;
-		}
-		return {
-			didReturn: false,
-			value: null
-		};
-	}
-	if (!isNodeOfType(statement, "IfStatement")) return {
-		didReturn: false,
-		value: null
-	};
-	const conditionResult = readHydrationConditionResult(statement.test, context, runtime, state);
-	if (conditionResult !== null) {
-		const selectedBranch = conditionResult ? statement.consequent : statement.alternate;
-		return selectedBranch ? readHydrationStatementResult(selectedBranch, context, runtime, state) : {
-			didReturn: false,
-			value: null
-		};
-	}
-	const consequentResult = readHydrationStatementResult(statement.consequent, context, runtime, state);
-	const alternateResult = statement.alternate ? readHydrationStatementResult(statement.alternate, context, runtime, state) : {
-		didReturn: false,
-		value: null
-	};
-	return consequentResult.didReturn && alternateResult.didReturn && consequentResult.value !== null && consequentResult.value === alternateResult.value ? consequentResult : {
-		didReturn: consequentResult.didReturn || alternateResult.didReturn,
-		value: null
-	};
+	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime), readHydrationConditionResult(unwrappedExpression.right, context, runtime));
 };
-const readHydrationFunctionResult = (functionNode, context, runtime, state) => {
-	if (!isFunctionLike$1(functionNode) || state.visitedFunctionNodes.has(functionNode)) return null;
-	state.visitedFunctionNodes.add(functionNode);
-	const result = isNodeOfType(functionNode.body, "BlockStatement") ? readHydrationStatementResult(functionNode.body, context, runtime, state).value : readHydrationConditionResult(functionNode.body, context, runtime, state);
-	state.visitedFunctionNodes.delete(functionNode);
-	return result;
-};
-const doEquivalentExpressionBindingsMatch = (leftExpression, rightExpression, scopes) => {
-	const left = stripParenExpression(leftExpression);
-	const right = stripParenExpression(rightExpression);
-	if (isNodeOfType(left, "Identifier") && isNodeOfType(right, "Identifier")) {
-		const leftSymbol = scopes.symbolFor(left);
-		const rightSymbol = scopes.symbolFor(right);
-		return leftSymbol || rightSymbol ? leftSymbol?.id === rightSymbol?.id : true;
-	}
-	if (isNodeOfType(left, "MemberExpression") && isNodeOfType(right, "MemberExpression")) return doEquivalentExpressionBindingsMatch(left.object, right.object, scopes) && (!left.computed || doEquivalentExpressionBindingsMatch(left.property, right.property, scopes));
-	if (isNodeOfType(left, "CallExpression") && isNodeOfType(right, "CallExpression")) {
-		const rightArguments = right.arguments ?? [];
-		return doEquivalentExpressionBindingsMatch(left.callee, right.callee, scopes) && (left.arguments ?? []).every((argument, index) => {
-			const rightArgument = rightArguments[index];
-			return Boolean(rightArgument && doEquivalentExpressionBindingsMatch(argument, rightArgument, scopes));
-		});
-	}
-	return true;
-};
-const areHelperReturnValuesEquivalent = (leftValue, rightValue, context) => {
-	if (areExpressionsStructurallyEqual(leftValue, rightValue)) return doEquivalentExpressionBindingsMatch(leftValue, rightValue, context.scopes);
-	const leftBoolean = readInitialStateBoolean(leftValue, context.scopes);
-	const rightBoolean = readInitialStateBoolean(rightValue, context.scopes);
-	return leftBoolean !== null && rightBoolean !== null && leftBoolean === rightBoolean;
-};
-const doHelperReturnValuesDiffer = (leftValues, rightValues, context) => {
-	const everyValueHasEquivalent = (values, candidateValues) => values.every((value) => candidateValues.some((candidateValue) => areHelperReturnValuesEquivalent(value, candidateValue, context)));
-	return !everyValueHasEquivalent(leftValues, rightValues) || !everyValueHasEquivalent(rightValues, leftValues);
-};
-const matchHydrationConditionInternal = (expression, context, state) => {
+const matchHydrationCondition = (expression, context) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
 	if (predicateMatch) return {
 		predicateMatch,
 		predicateNode: unwrappedExpression
 	};
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const symbol = context.scopes.symbolFor(unwrappedExpression);
-		const parameterValue = symbol ? state.parameterValuesBySymbolId.get(symbol.id) : null;
-		if (symbol && parameterValue && !state.visitedSymbolIds.has(symbol.id)) {
-			state.visitedSymbolIds.add(symbol.id);
-			const match = matchHydrationConditionInternal(parameterValue, context, state);
-			state.visitedSymbolIds.delete(symbol.id);
-			return match;
-		}
-		if (!symbol || symbol.kind !== "const" || !symbol.initializer || symbol.references.some((reference) => reference.flag !== "read") || state.visitedSymbolIds.has(symbol.id)) return null;
-		state.visitedSymbolIds.add(symbol.id);
-		const match = matchHydrationConditionInternal(symbol.initializer, context, state);
-		state.visitedSymbolIds.delete(symbol.id);
-		return match;
-	}
-	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
-		const callArguments = unwrappedExpression.arguments ?? [];
-		if (isReactApiCall(unwrappedExpression, "useMemo", context.scopes, {
-			allowGlobalReactNamespace: true,
-			resolveNamedAliases: true
-		})) {
-			const callbackArgument = callArguments[0];
-			if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
-			const callbackFunction = resolveExactLocalFunction(callbackArgument, context.scopes);
-			return isFunctionLike$1(callbackFunction) && callbackFunction.params.length === 0 ? matchHydrationFunctionResult(callbackFunction, context, state) : null;
-		}
-		const callee = stripParenExpression(unwrappedExpression.callee);
-		if (isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee) && callArguments.length === 1 && !isNodeOfType(callArguments[0], "SpreadElement")) return matchHydrationConditionInternal(callArguments[0], context, state);
-		const helperFunction = resolveExactLocalFunction(callee, context.scopes);
-		if (!isFunctionLike$1(helperFunction) || helperFunction.async || isNodeOfType(helperFunction, "FunctionDeclaration") && helperFunction.generator || isNodeOfType(helperFunction, "FunctionExpression") && helperFunction.generator || helperFunction.params.some((parameter) => !isNodeOfType(parameter, "Identifier")) || callArguments.some((argument) => isNodeOfType(argument, "SpreadElement"))) return null;
-		const parameterValuesBySymbolId = new Map(state.parameterValuesBySymbolId);
-		for (let parameterIndex = 0; parameterIndex < helperFunction.params.length; parameterIndex++) {
-			const parameter = helperFunction.params[parameterIndex];
-			const argument = callArguments[parameterIndex];
-			if (!argument || !isNodeOfType(parameter, "Identifier")) continue;
-			const parameterSymbol = context.scopes.symbolFor(parameter);
-			if (parameterSymbol) parameterValuesBySymbolId.set(parameterSymbol.id, argument);
-		}
-		return matchHydrationFunctionResult(helperFunction, context, {
-			...state,
-			parameterValuesBySymbolId
-		});
-	}
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationConditionInternal(unwrappedExpression.argument, context, state);
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationCondition(unwrappedExpression.argument, context);
 	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	const leftMatch = matchHydrationConditionInternal(unwrappedExpression.left, context, state);
-	const rightMatch = matchHydrationConditionInternal(unwrappedExpression.right, context, state);
+	const leftMatch = matchHydrationCondition(unwrappedExpression.left, context);
+	const rightMatch = matchHydrationCondition(unwrappedExpression.right, context);
+	if (leftMatch && rightMatch) {
+		const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client");
+		const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server");
+		return clientResult !== null && serverResult !== null && clientResult !== serverResult ? leftMatch : null;
+	}
 	const nestedMatch = leftMatch ?? rightMatch;
 	if (!nestedMatch) return null;
-	const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client", state);
-	const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server", state);
-	return clientResult !== null && serverResult !== null && clientResult === serverResult ? null : nestedMatch;
+	const otherResult = readInitialStateBoolean(leftMatch ? unwrappedExpression.right : unwrappedExpression.left, context.scopes);
+	if (unwrappedExpression.operator === "&&" && otherResult === false || unwrappedExpression.operator === "||" && otherResult === true) return null;
+	return nestedMatch;
 };
-const matchHydrationReturningStatement = (statement, context, state) => {
-	if (isNodeOfType(statement, "ReturnStatement")) return statement.argument ? matchHydrationConditionInternal(statement.argument, context, state) : null;
-	if (isNodeOfType(statement, "IfStatement")) {
-		const conditionMatch = matchHydrationConditionInternal(statement.test, context, state);
-		const consequentValues = getReturnedValues(statement.consequent);
-		const alternateValues = statement.alternate ? getReturnedValues(statement.alternate) : findFollowingReturnedValues(statement);
-		if (conditionMatch && consequentValues.length > 0 && alternateValues.length > 0 && doHelperReturnValuesDiffer(consequentValues, alternateValues, context)) return conditionMatch;
-		return matchHydrationReturningStatement(statement.consequent, context, state) ?? (statement.alternate ? matchHydrationReturningStatement(statement.alternate, context, state) : null);
-	}
-	if (!isNodeOfType(statement, "BlockStatement")) return null;
-	for (const childStatement of statement.body) {
-		const match = matchHydrationReturningStatement(childStatement, context, state);
-		if (match) return match;
-		if (statementAlwaysExits(childStatement)) break;
-	}
-	return null;
-};
-const matchHydrationFunctionResult = (functionNode, context, state) => {
-	if (!isFunctionLike$1(functionNode) || state.visitedFunctionNodes.has(functionNode)) return null;
-	state.visitedFunctionNodes.add(functionNode);
-	const match = isNodeOfType(functionNode.body, "BlockStatement") ? matchHydrationReturningStatement(functionNode.body, context, state) : matchHydrationConditionInternal(functionNode.body, context, state);
-	state.visitedFunctionNodes.delete(functionNode);
-	return match;
-};
-const matchHydrationCondition = (expression, context) => matchHydrationConditionInternal(expression, context, {
-	parameterValuesBySymbolId: /* @__PURE__ */ new Map(),
-	visitedFunctionNodes: /* @__PURE__ */ new Set(),
-	visitedSymbolIds: /* @__PURE__ */ new Set()
-});
 const areNodeArraysEquivalent = (leftNodes, rightNodes) => leftNodes.length === rightNodes.length && leftNodes.every((leftNode, index) => areRenderedBranchesEquivalent(leftNode, rightNodes[index]));
 const areRenderedBranchesEquivalent = (leftNode, rightNode) => {
 	if (!leftNode || !rightNode) return leftNode === rightNode;
@@ -41943,17 +40626,17 @@ const noHydrationBranchOnBrowserGlobal = defineRule({
 			const { predicateMatch, predicateNode } = conditionMatch;
 			if (reportedNodes.has(predicateNode)) return;
 			if (rightBranch && areRenderedBranchesEquivalent(leftBranch, rightBranch)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(conditionNode, context.scopes);
+			const componentOrHookNode = findRenderPhaseComponentOrHook(predicateNode, context.scopes);
 			if (!componentOrHookNode) return;
 			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (requiresRenderedContext && !isInRenderedOutput(conditionNode, componentOrHookNode, context.scopes)) return;
+			if (requiresRenderedContext && !isInRenderedOutput(predicateNode, componentOrHookNode, context.scopes)) return;
 			if (!isRenderedValue(leftBranch) && (!rightBranch || !isRenderedValue(rightBranch))) {
-				const attribute = findEnclosingJsxAttribute(conditionNode);
+				const attribute = findEnclosingJsxAttribute(predicateNode);
 				if (!attribute || isEventHandlerAttribute(attribute)) return;
 			}
-			if (fileIsEmailTemplate || isGatedByFalsyInitialState(conditionNode, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(conditionNode, componentOrHookNode, context.scopes)) return;
-			const openingElement = findEnclosingJsxOpeningElement(conditionNode);
+			if (fileIsEmailTemplate || isGatedByFalsyInitialState(predicateNode, context.scopes)) return;
+			if (isAfterClientOnlyEarlyReturn(predicateNode, componentOrHookNode, context.scopes)) return;
+			const openingElement = findEnclosingJsxOpeningElement(predicateNode);
 			if (hasSuppressHydrationWarningAttribute(openingElement) && !isStructuralRenderedValue(leftBranch) && !isStructuralRenderedValue(rightBranch)) return;
 			if (branchRootsSuppressSameElement(leftBranch, rightBranch)) return;
 			if (isGeneratedImageRenderContext(context, openingElement ?? leftBranch)) return;
@@ -42335,7 +41018,7 @@ const noInitializeState = defineRule({
 		if (!dependencies || !isNodeOfType(dependencies, "ArrayExpression") || (dependencies.elements ?? []).length !== 0) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.matchesStateInitializer || fact.resetsSourceState) continue;
 			const stateName = getStateName(fact.stateDeclarator);
 			context.report({
@@ -42693,8 +41376,7 @@ const noJsxElementType = defineRule({
 	create: (context) => {
 		let isJsxImported = false;
 		const flaggedAnnotations = [];
-		const collectComponentReturnType = (functionNode, returnType) => {
-			if (!(isNodeOfType(functionNode, "TSDeclareFunction") ? Boolean(functionNode.id && isReactComponentName(functionNode.id.name)) : isComponentFunction$1(functionNode))) return;
+		const checkReturnType = (returnType) => {
 			const typeAnnotation = extractReturnTypeAnnotation(returnType);
 			if (!typeAnnotation) return;
 			if (isJsxElementTypeReference(typeAnnotation)) flaggedAnnotations.push(typeAnnotation);
@@ -42704,16 +41386,19 @@ const noJsxElementType = defineRule({
 				if (isJsxImportBinding(node)) isJsxImported = true;
 			},
 			FunctionDeclaration(node) {
-				collectComponentReturnType(node, node.returnType);
+				checkReturnType(node.returnType);
 			},
 			ArrowFunctionExpression(node) {
-				collectComponentReturnType(node, node.returnType);
+				checkReturnType(node.returnType);
 			},
 			FunctionExpression(node) {
-				collectComponentReturnType(node, node.returnType);
+				checkReturnType(node.returnType);
 			},
 			TSDeclareFunction(node) {
-				collectComponentReturnType(node, node.returnType);
+				checkReturnType(node.returnType);
+			},
+			TSMethodSignature(node) {
+				checkReturnType(node.returnType);
 			},
 			"Program:exit"() {
 				if (isJsxImported) return;
@@ -45740,114 +44425,6 @@ const DATA_SINK_METHOD_NAMES = new Set([
 	"deserialize"
 ]);
 //#endregion
-//#region src/plugin/utils/get-transparent-react-callback-wrapper-argument.ts
-const getTransparentReactCallbackWrapperArgument = (initializer, resultSymbol, scopes) => {
-	const callExpression = stripParenExpression(initializer);
-	if (!isNodeOfType(callExpression, "CallExpression")) return null;
-	const callbackArgument = callExpression.arguments[0];
-	if (!callbackArgument) return null;
-	if (resultSymbol && symbolHasReactUseEffectEventOrigin(resultSymbol, scopes)) return callbackArgument;
-	return isReactApiCall(callExpression, "useCallback", scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true
-	}) ? callbackArgument : null;
-};
-//#endregion
-//#region src/plugin/rules/state-and-effects/utils/resolve-parent-callback-provenance.ts
-const getDeclarationKind$1 = (declarator) => {
-	const declaration = declarator.parent;
-	return declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : null;
-};
-const hasMutableBindingWrite$2 = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
-const mergeRequiredBranches = (leftNames, rightNames) => {
-	if (!leftNames || !rightNames) return null;
-	return new Set([...leftNames, ...rightNames]);
-};
-const getPropReferenceName = (analysis, identifier) => {
-	if (!isNodeOfType(identifier, "Identifier")) return null;
-	const reference = getRef(analysis, identifier);
-	if (!reference || !isProp(analysis, reference) || isWholePropsObjectReference(analysis, reference)) return null;
-	const bindingIdentifier = (reference.resolved?.defs.find((definition) => definition.type === "Parameter"))?.name;
-	return (bindingIdentifier && getDestructuredBindingPropertyName(bindingIdentifier)) ?? identifier.name;
-};
-const getSingleConstDeclarator = (reference) => {
-	if (!reference.resolved || hasMutableBindingWrite$2(reference)) return null;
-	const declarators = reference.resolved.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
-	if (declarators.length !== 1) return null;
-	const declarator = declarators[0];
-	if (!declarator || getDeclarationKind$1(declarator) !== "const") return null;
-	return declarator;
-};
-const resolveParentCallbackPropNames = (analysis, expression, scopes, visitedReferences, allowFunctionForwarder = false) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isFunctionLike$1(unwrappedExpression)) {
-		if (!allowFunctionForwarder || Boolean(unwrappedExpression.async)) return null;
-		const callbackNames = /* @__PURE__ */ new Set();
-		walkInsideStatementBlocks(unwrappedExpression.body, (child) => {
-			if (!isNodeOfType(child, "CallExpression")) return;
-			const resolvedNames = resolveParentCallbackPropNames(analysis, child.callee, scopes, new Set(visitedReferences), false);
-			if (!resolvedNames) return;
-			for (const resolvedName of resolvedNames) callbackNames.add(resolvedName);
-		});
-		return callbackNames.size > 0 ? callbackNames : null;
-	}
-	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) return mergeRequiredBranches(resolveParentCallbackPropNames(analysis, unwrappedExpression.consequent, scopes, new Set(visitedReferences), false), resolveParentCallbackPropNames(analysis, unwrappedExpression.alternate, scopes, new Set(visitedReferences), false));
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) return mergeRequiredBranches(resolveParentCallbackPropNames(analysis, unwrappedExpression.left, scopes, new Set(visitedReferences), false), resolveParentCallbackPropNames(analysis, unwrappedExpression.right, scopes, new Set(visitedReferences)));
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const propName = getPropReferenceName(analysis, unwrappedExpression);
-		if (propName) return new Set([propName]);
-		const reference = getRef(analysis, unwrappedExpression);
-		if (!reference?.resolved || visitedReferences.has(reference.resolved)) return null;
-		const declarator = getSingleConstDeclarator(reference);
-		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !declarator.init) return null;
-		visitedReferences.add(reference.resolved);
-		const wrappedArgument = getTransparentReactCallbackWrapperArgument(declarator.init, scopes.symbolFor(unwrappedExpression), scopes);
-		const allowsFunctionForwarder = Boolean(wrappedArgument && !isReactApiCall(declarator.init, "useCallback", scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true
-		}));
-		return resolveParentCallbackPropNames(analysis, wrappedArgument ?? declarator.init, scopes, visitedReferences, allowsFunctionForwarder);
-	}
-	if (!isNodeOfType(unwrappedExpression, "MemberExpression")) return null;
-	const propertyName = getStaticMemberPropertyName(unwrappedExpression);
-	if (!propertyName) return null;
-	const receiver = stripParenExpression(unwrappedExpression.object);
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const receiverReference = getRef(analysis, receiver);
-	if (!receiverReference?.resolved || visitedReferences.has(receiverReference.resolved)) return null;
-	if (isWholePropsObjectReference(analysis, receiverReference)) return new Set([propertyName]);
-	const declarator = getSingleConstDeclarator(receiverReference);
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !declarator.init) return null;
-	visitedReferences.add(receiverReference.resolved);
-	const initializer = stripParenExpression(declarator.init);
-	if (propertyName === "current" && isNodeOfType(initializer, "CallExpression")) {
-		if (!isReactApiCall(initializer, "useRef", scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true
-		})) return null;
-		const callbackArgument = initializer.arguments[0];
-		if (!callbackArgument) return null;
-		let callbackNames = resolveParentCallbackPropNames(analysis, callbackArgument, scopes, new Set(visitedReferences), false);
-		if (!callbackNames) return null;
-		for (const candidateReference of receiverReference.resolved.references) {
-			const candidateIdentifier = candidateReference.identifier;
-			const candidateMember = candidateIdentifier.parent;
-			if (!candidateMember || !isNodeOfType(candidateMember, "MemberExpression") || candidateMember.object !== candidateIdentifier || getStaticMemberPropertyName(candidateMember) !== "current") continue;
-			const assignment = candidateMember.parent;
-			if (!assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.left !== candidateMember) continue;
-			if (assignment.operator !== "=") return null;
-			callbackNames = mergeRequiredBranches(callbackNames, resolveParentCallbackPropNames(analysis, assignment.right, scopes, new Set(visitedReferences), false));
-			if (!callbackNames) return null;
-		}
-		return callbackNames;
-	}
-	if (!isNodeOfType(initializer, "ObjectExpression")) return null;
-	const property = initializer.properties.find((candidateProperty) => isNodeOfType(candidateProperty, "Property") && getStaticPropertyKeyName(candidateProperty, { allowComputedString: true }) === propertyName);
-	if (!property || !isNodeOfType(property, "Property")) return null;
-	return resolveParentCallbackPropNames(analysis, property.value, scopes, visitedReferences, false);
-};
-const getParentCallbackPropNames = ({ analysis, expression, scopes }) => resolveParentCallbackPropNames(analysis, expression, scopes, /* @__PURE__ */ new Set(), false);
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-pass-data-to-parent.ts
 const isUseStateIdentifier = (identifier) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
@@ -45876,18 +44453,14 @@ const FUNCTION_WRAPPER_HOOK_NAMES$1 = new Set([
 	"useStableCallback",
 	"useCallbackRef"
 ]);
-const getWrapperHookWrappedFunction = (initializer, resultSymbol, scopes) => {
+const getWrapperHookWrappedFunction = (initializer) => {
 	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	const transparentReactArgument = getTransparentReactCallbackWrapperArgument(initializer, resultSymbol, scopes);
-	if (transparentReactArgument) return transparentReactArgument;
 	const callee = initializer.callee;
 	const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") ? callee.property.name : null;
 	if (!calleeName || !FUNCTION_WRAPPER_HOOK_NAMES$1.has(calleeName)) return null;
 	const wrapped = initializer.arguments?.[0];
-	if (!wrapped) return null;
-	if (calleeName === "useEffectEvent") return null;
-	if (isFunctionLike$1(wrapped)) return wrapped;
-	return null;
+	if (!wrapped || !isFunctionLike$1(wrapped)) return null;
+	return wrapped;
 };
 const HANDLER_NAMED_PROP_PATTERN = /^(on|handle)[A-Z]/;
 const wrappedFunctionNotifiesParent = (analysis, wrappedFunction) => getDownstreamRefs(analysis, wrappedFunction).some((innerRef) => {
@@ -45897,29 +44470,16 @@ const wrappedFunctionNotifiesParent = (analysis, wrappedFunction) => getDownstre
 	const innerParent = innerIdentifier.parent;
 	return Boolean(innerParent && isNodeOfType(innerParent, "CallExpression") && innerParent.callee === innerIdentifier);
 });
-const isDirectParentCallbackRef = (analysis, ref, scopes) => {
+const isDirectParentCallbackRef = (analysis, ref) => {
 	if (isProp(analysis, ref)) return true;
-	if (hasMutableBindingWrite$1(ref)) {
-		if (!(ref.resolved?.references.filter((candidateReference) => candidateReference.isWrite() && !candidateReference.init) ?? []).every((candidateReference) => {
-			const candidateIdentifier = candidateReference.identifier;
-			const assignment = candidateIdentifier.parent;
-			if (!assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== candidateIdentifier) return false;
-			const assignedReferences = getDownstreamRefs(analysis, assignment.right);
-			return assignedReferences.length > 0 && assignedReferences.every((assignedReference) => isProp(analysis, assignedReference));
-		})) return false;
-	}
 	return Boolean(ref.resolved?.defs.some((def) => {
 		const node = def.node;
 		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
 		const initializer = unwrapChainExpression(node.init);
-		const wrappedFunction = getWrapperHookWrappedFunction(initializer, isNodeOfType(node.id, "Identifier") ? scopes.symbolFor(node.id) ?? null : null, scopes);
+		const wrappedFunction = getWrapperHookWrappedFunction(initializer);
 		if (wrappedFunction) {
 			if (wrappedFunction.async) return false;
-			if (isFunctionLike$1(wrappedFunction)) return wrappedFunctionNotifiesParent(analysis, wrappedFunction);
-			const directName = getParentCallbackPropName(analysis, wrappedFunction);
-			const downstreamReferences = getDownstreamRefs(analysis, wrappedFunction);
-			if (directName !== null) return true;
-			return downstreamReferences.some((wrappedReference) => !hasMutableBindingWrite$1(wrappedReference) && getUpstreamRefs(analysis, wrappedReference).some((upstreamReference) => isProp(analysis, upstreamReference)));
+			return wrappedFunctionNotifiesParent(analysis, wrappedFunction);
 		}
 		if (!isNodeOfType(initializer, "Identifier") && !isNodeOfType(initializer, "MemberExpression")) return false;
 		return getDownstreamRefs(analysis, initializer).some((initializerRef) => getUpstreamRefs(analysis, initializerRef).some((upstreamRef) => isProp(analysis, upstreamRef)));
@@ -45929,7 +44489,7 @@ const getDeclarationKind = (declarator) => {
 	const declaration = declarator.parent;
 	return declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : null;
 };
-const hasMutableBindingWrite$1 = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
+const hasMutableBindingWrite = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
 const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @__PURE__ */ new Set()) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	if (isNodeOfType(unwrappedExpression, "Identifier")) {
@@ -45941,7 +44501,7 @@ const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @
 			const bindingIdentifier = callbackVariable.defs.find((definition) => definition.type === "Parameter")?.name;
 			return (bindingIdentifier && getDestructuredBindingPropertyName(bindingIdentifier)) ?? unwrappedExpression.name;
 		}
-		if (hasMutableBindingWrite$1(callbackReference)) return null;
+		if (hasMutableBindingWrite(callbackReference)) return null;
 		const definitions = callbackVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
 		if (definitions.length !== 1) return null;
 		const declarator = definitions[0];
@@ -46007,7 +44567,7 @@ const getRefAliasDeclarator = (identifier) => {
 const getRefBindingProvenance = (analysis, receiver, isReactUseRefCall) => {
 	if (!isNodeOfType(receiver, "Identifier")) return null;
 	const receiverReference = getRef(analysis, receiver);
-	if (!receiverReference?.resolved || hasMutableBindingWrite$1(receiverReference)) return null;
+	if (!receiverReference?.resolved || hasMutableBindingWrite(receiverReference)) return null;
 	const variables = /* @__PURE__ */ new Set();
 	let currentVariable = receiverReference.resolved;
 	let refCall = null;
@@ -46023,7 +44583,7 @@ const getRefBindingProvenance = (analysis, receiver, isReactUseRefCall) => {
 		}
 		if (getDeclarationKind(declarator) !== "const" || !isNodeOfType(stripParenExpression(declarator.init), "Identifier")) return null;
 		const upstreamReference = getRef(analysis, stripParenExpression(declarator.init));
-		if (!upstreamReference?.resolved || hasMutableBindingWrite$1(upstreamReference)) return null;
+		if (!upstreamReference?.resolved || hasMutableBindingWrite(upstreamReference)) return null;
 		currentVariable = upstreamReference.resolved;
 	}
 	if (!refCall) return null;
@@ -46098,7 +44658,7 @@ const isParentPropsContextMerge = (analysis, expression) => {
 	while (isNodeOfType(currentExpression, "Identifier")) {
 		const currentReference = getRef(analysis, currentExpression);
 		const currentVariable = currentReference?.resolved;
-		if (!currentReference || !currentVariable || visitedVariables.has(currentVariable) || hasMutableBindingWrite$1(currentReference)) return false;
+		if (!currentReference || !currentVariable || visitedVariables.has(currentVariable) || hasMutableBindingWrite(currentReference)) return false;
 		visitedVariables.add(currentVariable);
 		const definitions = currentVariable.defs.filter((definition) => isNodeOfType(definition.node, "VariableDeclarator"));
 		if (definitions.length !== 1) return false;
@@ -46112,11 +44672,11 @@ const isParentPropsContextMerge = (analysis, expression) => {
 	const propsExpression = stripParenExpression(propsSpread.argument);
 	if (!isNodeOfType(propsExpression, "Identifier")) return false;
 	const propsReference = getRef(analysis, propsExpression);
-	if (!propsReference?.resolved || !isWholePropsObjectReference(analysis, propsReference) || hasMutableBindingWrite$1(propsReference) || propsReference.resolved.references.some((candidateReference) => candidateReference !== propsReference)) return false;
+	if (!propsReference?.resolved || !isWholePropsObjectReference(analysis, propsReference) || hasMutableBindingWrite(propsReference) || propsReference.resolved.references.some((candidateReference) => candidateReference !== propsReference)) return false;
 	const contextExpression = stripParenExpression(contextSpread.argument);
 	if (!isNodeOfType(contextExpression, "Identifier")) return false;
 	const contextReference = getRef(analysis, contextExpression);
-	if (!contextReference?.resolved || hasMutableBindingWrite$1(contextReference) || contextReference.resolved.references.some((candidateReference) => !candidateReference.init && candidateReference !== contextReference)) return false;
+	if (!contextReference?.resolved || hasMutableBindingWrite(contextReference) || contextReference.resolved.references.some((candidateReference) => !candidateReference.init && candidateReference !== contextReference)) return false;
 	const contextInitializer = contextReference.resolved?.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
 	if (!contextInitializer || !isNodeOfType(contextInitializer, "VariableDeclarator") || getDeclarationKind(contextInitializer) !== "const" || !contextInitializer.init || !isNodeOfType(contextInitializer.init, "CallExpression")) return false;
 	const contextHook = stripParenExpression(contextInitializer.init.callee);
@@ -46130,7 +44690,7 @@ const getImmutableParentCallbackPropName = (analysis, expression) => {
 	while (isNodeOfType(currentExpression, "Identifier")) {
 		const currentReference = getRef(analysis, currentExpression);
 		const currentVariable = currentReference?.resolved;
-		if (!currentReference || !currentVariable || visitedVariables.has(currentVariable) || hasMutableBindingWrite$1(currentReference)) return null;
+		if (!currentReference || !currentVariable || visitedVariables.has(currentVariable) || hasMutableBindingWrite(currentReference)) return null;
 		visitedVariables.add(currentVariable);
 		const definition = currentVariable.defs.length === 1 ? currentVariable.defs[0] : null;
 		const bindingIdentifier = definition?.name;
@@ -46199,7 +44759,7 @@ const getCommandCallbackPropName = (analysis, expression, isReactUseRefCall) =>
 	while (isNodeOfType(currentExpression, "Identifier")) {
 		const callbackReference = getRef(analysis, currentExpression);
 		const callbackVariable = callbackReference?.resolved;
-		if (!callbackReference || !callbackVariable || visitedVariables.has(callbackVariable) || hasMutableBindingWrite$1(callbackReference)) return null;
+		if (!callbackReference || !callbackVariable || visitedVariables.has(callbackVariable) || hasMutableBindingWrite(callbackReference)) return null;
 		visitedVariables.add(callbackVariable);
 		const definition = callbackVariable.defs.length === 1 ? callbackVariable.defs[0] : null;
 		const declarator = definition?.node;
@@ -46219,11 +44779,10 @@ const getCommandCallbackPropName = (analysis, expression, isReactUseRefCall) =>
 	if (!propertyName || !COMMAND_PROP_NAME_PATTERN.test(propertyName)) return null;
 	return refCurrentObjectPreservesCallbackProperty(analysis, currentExpression.object, propertyName, isReactUseRefCall) ? propertyName : null;
 };
-const isWrapperHookCallbackRef = (analysis, ref, scopes) => Boolean(ref.resolved?.defs.some((def) => {
+const isWrapperHookCallbackRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-	const resultSymbol = isNodeOfType(node.id, "Identifier") ? scopes.symbolFor(node.id) ?? null : null;
-	return getWrapperHookWrappedFunction(unwrapChainExpression(node.init), resultSymbol, scopes) !== null;
+	return getWrapperHookWrappedFunction(unwrapChainExpression(node.init)) !== null;
 }));
 const isHandlerBagArgument = (analysis, argument) => {
 	if (!isNodeOfType(argument, "ObjectExpression")) return false;
@@ -46242,26 +44801,14 @@ const isHandlerBagArgument = (analysis, argument) => {
 };
 const getFunctionalUpdaterDataRefs = (analysis, updater) => getDownstreamRefs(analysis, updater).filter((updaterRef) => !updaterRef.resolved?.defs.some((def) => def.type === "Parameter" && def.node === updater));
 const HOOK_NAME_PATTERN$1 = /^use[A-Z0-9]/;
-const EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1 = new Set([
+const EXTERNAL_SUBSCRIPTION_HOOK_NAMES = new Set([
 	"useIntersectionObserver",
 	"useMatchMedia",
-	"useMediaJobProgress",
 	"useMediaQuery",
-	"useMediaQueryState",
 	"useResizeObserver",
 	"useVisibility",
 	"useWindowSize"
 ]);
-const isCallbackPropReference = (analysis, ref) => {
-	if (!isProp(analysis, ref)) return false;
-	const identifier = ref.identifier;
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	if (!isWholePropsObjectReference(analysis, ref)) return HANDLER_NAMED_PROP_PATTERN.test(identifier.name);
-	const member = identifier.parent;
-	if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== identifier) return false;
-	const propertyName = getStaticMemberPropertyName(member);
-	return Boolean(propertyName && HANDLER_NAMED_PROP_PATTERN.test(propertyName));
-};
 const isParentWiredHookResultRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
@@ -46269,7 +44816,7 @@ const isParentWiredHookResultRef = (analysis, ref) => Boolean(ref.resolved?.defs
 	if (!isNodeOfType(init, "CallExpression")) return false;
 	const callee = init.callee;
 	if (!isNodeOfType(callee, "Identifier") || !HOOK_NAME_PATTERN$1.test(callee.name)) return false;
-	return (init.arguments ?? []).some((hookArgument) => getDownstreamRefs(analysis, hookArgument).some((downstreamRef) => isCallbackPropReference(analysis, downstreamRef)));
+	return (init.arguments ?? []).some((hookArgument) => getDownstreamRefs(analysis, hookArgument).some((downstreamRef) => isProp(analysis, downstreamRef)));
 }));
 const isParentWiredHookResultArgument = (analysis, argument) => {
 	if (!isNodeOfType(argument, "Identifier")) return false;
@@ -46282,40 +44829,19 @@ const isParentWiredHookCalleeRef = (analysis, ref) => {
 	if (!isNodeOfType(identifier, "Identifier") || !HOOK_NAME_PATTERN$1.test(identifier.name)) return false;
 	const parent = identifier.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier) return false;
-	return (parent.arguments ?? []).some((hookArgument) => getDownstreamRefs(analysis, hookArgument).some((downstreamRef) => isCallbackPropReference(analysis, downstreamRef)));
+	return (parent.arguments ?? []).some((hookArgument) => getDownstreamRefs(analysis, hookArgument).some((downstreamRef) => isProp(analysis, downstreamRef)));
 };
-const getLocalHookExternalStateProof = (analysis, ref) => {
-	let hookFunction = resolveToFunction(ref);
-	if (!hookFunction) for (const definition of ref.resolved?.defs ?? []) {
-		const definitionNode = definition.node;
-		if (!isNodeOfType(definitionNode, "VariableDeclarator") || !definitionNode.init) continue;
-		const initializer = stripParenExpression(definitionNode.init);
-		if (!isNodeOfType(initializer, "CallExpression")) continue;
-		const callee = stripParenExpression(initializer.callee);
-		if (!isNodeOfType(callee, "Identifier")) continue;
-		const calleeReference = getRef(analysis, callee);
-		if (!calleeReference) continue;
-		hookFunction = resolveToFunction(calleeReference);
-		if (hookFunction) break;
-	}
-	if (!hookFunction) return null;
-	const returnedReferences = collectFunctionReturnStatements(hookFunction).flatMap((returnStatement) => returnStatement.argument ? getDownstreamRefs(analysis, returnStatement.argument) : []);
-	if (returnedReferences.length === 0) return null;
-	return returnedReferences.every((returnedReference) => isState(analysis, returnedReference) && isExternallyDrivenState(analysis, returnedReference));
-};
-const isExternalSubscriptionHookRef = (analysis, ref) => {
+const isExternalSubscriptionHookRef = (ref) => {
 	const identifier = ref.identifier;
 	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const localHookProof = getLocalHookExternalStateProof(analysis, ref);
-	if (localHookProof !== null) return localHookProof;
-	if (EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(identifier.name) && isCalleePosition(identifier)) return true;
+	if (EXTERNAL_SUBSCRIPTION_HOOK_NAMES.has(identifier.name) && isCalleePosition(identifier)) return true;
 	return Boolean(ref.resolved?.defs.some((def) => {
 		const node = def.node;
 		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
 		const initializer = stripParenExpression(node.init);
 		if (!isNodeOfType(initializer, "CallExpression")) return false;
 		const callee = stripParenExpression(initializer.callee);
-		return isNodeOfType(callee, "Identifier") && EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(callee.name);
+		return isNodeOfType(callee, "Identifier") && EXTERNAL_SUBSCRIPTION_HOOK_NAMES.has(callee.name);
 	}));
 };
 const isImportBindingRef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "ImportBinding"));
@@ -46351,22 +44877,16 @@ const noPassDataToParent = defineRule({
 				const callExpr = getCallExpr(ref);
 				if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
 				const callbackRefProvenance = getCallbackRefProvenance(analysis, node, callExpr, isReactUseRefCall, isReactUseEffectCall);
+				if (isRefCall(analysis, ref) && !callbackRefProvenance) continue;
 				if (!isSynchronous(ref.identifier, effectFn)) continue;
 				const calleeNode = unwrapChainExpression(callExpr.callee);
 				const identifier = ref.identifier;
-				const resolvedCallbackPropNames = isNodeOfType(calleeNode, "MemberExpression") && getStaticMemberPropertyName(calleeNode) === "current" ? null : getParentCallbackPropNames({
-					analysis,
-					expression: calleeNode,
-					scopes: context.scopes
-				});
-				const callbackPropNames = callbackRefProvenance?.callbackPropNames ?? resolvedCallbackPropNames;
-				if (isRefCall(analysis, ref) && !callbackPropNames) continue;
-				if (callbackPropNames) {
-					if ([...callbackPropNames].some((callbackPropName) => COMMAND_PROP_NAME_PATTERN.test(callbackPropName))) continue;
+				if (callbackRefProvenance) {
+					if ([...callbackRefProvenance.callbackPropNames].some((callbackPropName) => COMMAND_PROP_NAME_PATTERN.test(callbackPropName))) continue;
 				} else if (calleeNode === identifier) {
 					const callbackPropName = getCommandCallbackPropName(analysis, identifier, isReactUseRefCall);
 					if (callbackPropName && COMMAND_PROP_NAME_PATTERN.test(callbackPropName)) continue;
-					if (!isDirectParentCallbackRef(analysis, ref, context.scopes)) continue;
+					if (!isDirectParentCallbackRef(analysis, ref)) continue;
 					if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
 				} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
 					if (!isWholePropsObjectReference(analysis, ref)) continue;
@@ -46374,10 +44894,10 @@ const noPassDataToParent = defineRule({
 				} else continue;
 				const methodName = getCallMethodName(calleeNode);
 				const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
-				if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead && !callbackPropNames) continue;
+				if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
 				if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
-				if (!callbackPropNames && isNamespacedApiCallee(calleeNode)) continue;
-				const isSetterNamedCallee = callbackPropNames ? [...callbackPropNames].every((callbackPropName) => SETTER_NAMED_PROP_PATTERN.test(callbackPropName)) : Boolean((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) && SETTER_NAMED_PROP_PATTERN.test((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) ?? ""));
+				if (!callbackRefProvenance && isNamespacedApiCallee(calleeNode)) continue;
+				const isSetterNamedCallee = callbackRefProvenance ? [...callbackRefProvenance.callbackPropNames].every((callbackPropName) => SETTER_NAMED_PROP_PATTERN.test(callbackPropName)) : Boolean((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) && SETTER_NAMED_PROP_PATTERN.test((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) ?? ""));
 				const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
 				const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
 					if (isFunctionLike$1(argument)) {
@@ -46391,11 +44911,11 @@ const noPassDataToParent = defineRule({
 						if (argumentRef && resolveToFunction(argumentRef)) return [];
 					}
 					return getDownstreamRefs(analysis, argument);
-				}).flatMap((argumentRef) => isExternallyDrivenState(analysis, argumentRef) || isExternalSubscriptionHookRef(analysis, argumentRef) ? [] : getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
-				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref, context.scopes)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
+				}).flatMap((argumentRef) => isExternallyDrivenState(analysis, argumentRef) ? [] : getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
+				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
 				if (!argsUpstreamRefs.some((argRef) => {
 					if (isUseStateIdentifier(argRef.identifier)) return false;
-					if (isExternalSubscriptionHookRef(analysis, argRef)) return false;
+					if (isExternalSubscriptionHookRef(argRef)) return false;
 					if (isProp(analysis, argRef)) return false;
 					if (isUseRefIdentifier(argRef.identifier)) return false;
 					if (isRefCurrent(argRef)) return false;
@@ -46430,47 +44950,9 @@ const isCallResultConsumedAsArgument = (callExpression) => {
 	return false;
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/is-custom-hook-state-result-reference.ts
-const NON_STATE_CUSTOM_HOOK_NAMES = new Set([
-	"useCallbackRef",
-	"useEffectEvent",
-	"useEvent",
-	"useEventCallback",
-	"useLatest",
-	"useMemoizedFn",
-	"useStableCallback"
-]);
-const EXTERNAL_SUBSCRIPTION_HOOK_NAMES = new Set([
-	"useIntersectionObserver",
-	"useMatchMedia",
-	"useMediaJobProgress",
-	"useMediaQuery",
-	"useResizeObserver",
-	"useVisibility",
-	"useWindowSize"
-]);
-const getHookCalleeName = (initializer) => {
-	const unwrappedInitializer = stripParenExpression(initializer);
-	if (!isNodeOfType(unwrappedInitializer, "CallExpression")) return null;
-	const callee = stripParenExpression(unwrappedInitializer.callee);
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
-	return null;
-};
-const isCustomHookStateResultReference = (analysis, reference) => Boolean(reference.resolved?.defs.some((definition) => {
-	const declarator = definition.node;
-	if (!isNodeOfType(declarator, "VariableDeclarator") || !declarator.init) return false;
-	const calleeName = getHookCalleeName(declarator.init);
-	if (!calleeName || !HOOK_NAME_PATTERN$3.test(calleeName) || BUILTIN_HOOK_NAMES.has(calleeName) || NON_STATE_CUSTOM_HOOK_NAMES.has(calleeName) || EXTERNAL_SUBSCRIPTION_HOOK_NAMES.has(calleeName)) return false;
-	const initializer = stripParenExpression(declarator.init);
-	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	return initializer.arguments.some((argument) => getDownstreamRefs(analysis, argument).some((argumentReference) => isProp(analysis, argumentReference)));
-}));
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-pass-live-state-to-parent.ts
 const SETTER_NAMED_CALLBACK_PATTERN = /^set[A-Z]/;
 const DATA_FETCHING_CALLBACK_PATTERN = /^(fetch|refetch|load|query|request)([A-Z_]|$)/;
-const hasMutableBindingWrite = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
 const getCallCalleeName = (callExpr) => {
 	if (!isNodeOfType(callExpr, "CallExpression")) return null;
 	const callee = callExpr.callee;
@@ -46515,10 +44997,6 @@ const collectUpstreamStateRefs = (analysis, ref, stateRefs, visited) => {
 		stateRefs.push(ref);
 		return;
 	}
-	if (isCustomHookStateResultReference(analysis, ref)) {
-		stateRefs.push(ref);
-		return;
-	}
 	for (const def of ref.resolved?.defs ?? []) {
 		if (def.type === "ImportBinding" || def.type === "Parameter") continue;
 		const defNode = def.node;
@@ -46548,32 +45026,6 @@ const collectPropCallbackBoundStateRefs = (analysis, ref, isPropCallbackRef) =>
 	}
 	return stateRefs;
 };
-const collectDirectCallStateRefs = (analysis, callExpression) => {
-	const stateReferences = [];
-	for (const argument of callExpression.arguments) {
-		if (isFunctionLike$1(argument)) continue;
-		for (const argumentReference of getDownstreamRefs(analysis, argument)) {
-			if (resolveToFunction(argumentReference)) continue;
-			collectUpstreamStateRefs(analysis, argumentReference, stateReferences, /* @__PURE__ */ new Set());
-		}
-	}
-	return stateReferences;
-};
-const getTransparentWrapperPropReference = (analysis, reference, context) => {
-	for (const definition of reference.resolved?.defs ?? []) {
-		const declarator = definition.node;
-		if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.id, "Identifier") || !declarator.init) continue;
-		const resultSymbol = context.scopes.symbolFor(declarator.id);
-		const callbackArgument = getTransparentReactCallbackWrapperArgument(declarator.init, resultSymbol, context.scopes);
-		if (!callbackArgument) continue;
-		const callbackReferences = getDownstreamRefs(analysis, callbackArgument);
-		const callbackReference = callbackReferences.find((candidateReference) => isPropCallbackInvocationRef(analysis, candidateReference));
-		if (callbackReference) return callbackReference;
-		const propReference = callbackReferences.find((candidateReference) => isProp(analysis, candidateReference) && !candidateReference.resolved?.references.some((candidateUsage) => candidateUsage.isWrite() && !candidateUsage.init));
-		if (propReference) return propReference;
-	}
-	return null;
-};
 const isSetterNamedCallbackReceivingData = (callbackRef) => {
 	const callExpr = getCallExpr(callbackRef);
 	if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) return false;
@@ -46609,16 +45061,6 @@ const resolvesToLocalHookReturnBinding = (ref) => Boolean(ref?.resolved?.defs?.s
 	const calleeName = getInitializerCalleeName(node.init);
 	return calleeName !== null && isReactHookName(calleeName) && !FUNCTION_WRAPPER_HOOK_NAMES.has(calleeName);
 }));
-const getDirectLocalEffectHelper = (callExpression, effectFunction, context) => {
-	const helperFunction = resolveExactLocalFunction(callExpression.callee, context.scopes);
-	if (!helperFunction) return null;
-	let ancestor = callExpression.parent;
-	while (ancestor && ancestor !== effectFunction) {
-		if (isFunctionLike$1(ancestor)) return null;
-		ancestor = ancestor.parent;
-	}
-	return ancestor === effectFunction ? helperFunction : null;
-};
 const noPassLiveStateToParent = defineRule({
 	id: "no-pass-live-state-to-parent",
 	title: "Live state pushed to parent via effect",
@@ -46633,32 +45075,20 @@ const noPassLiveStateToParent = defineRule({
 		if (!effectFnRefs) return;
 		const effectFn = getEffectFn(analysis, node);
 		if (!effectFn) return;
-		const effectFunctionBody = isNodeOfType(effectFn, "ArrowFunctionExpression") || isNodeOfType(effectFn, "FunctionExpression") || isNodeOfType(effectFn, "FunctionDeclaration") ? effectFn.body : null;
 		for (const ref of effectFnRefs) {
+			const propCallbackRefs = getEventualCallRefsTo(analysis, ref, (innerRef) => isParentNotificationCallbackRef(analysis, innerRef));
+			if (propCallbackRefs.length === 0) continue;
+			if (resolvesToLocalHookReturnBinding(ref)) continue;
+			if (!isSynchronous(ref.identifier, effectFn)) continue;
 			const callExpr = getCallExpr(ref);
-			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
-			const directLocalEffectHelper = getDirectLocalEffectHelper(callExpr, effectFn, context);
-			const callGraphReferences = directLocalEffectHelper ? [ref, ...getDownstreamRefs(analysis, directLocalEffectHelper)] : [ref];
-			const resolvedCallbackPropNames = getParentCallbackPropNames({
-				analysis,
-				expression: callExpr.callee,
-				scopes: context.scopes
-			});
-			const callExpressionRoot = findTransparentExpressionRoot(callExpr);
-			const notificationCallbackPropNames = Boolean(resolvedCallbackPropNames && callExpr.arguments.length > 0 && (!isCallResultCapturedToLocal(callExpr) || isNodeOfType(callExpressionRoot.parent, "ReturnStatement") && callExpressionRoot.parent.parent === effectFunctionBody) && [...resolvedCallbackPropNames].every((callbackPropName) => !DATA_FETCHING_CALLBACK_PATTERN.test(callbackPropName))) ? resolvedCallbackPropNames : null;
-			if (!notificationCallbackPropNames && hasMutableBindingWrite(ref)) continue;
-			const propCallbackRefs = callGraphReferences.flatMap((callGraphReference) => getEventualCallRefsTo(analysis, callGraphReference, (innerRef) => isParentNotificationCallbackRef(analysis, innerRef)));
-			const transparentPropReference = propCallbackRefs.length === 0 ? getTransparentWrapperPropReference(analysis, ref, context) : null;
-			if (propCallbackRefs.length === 0 && !transparentPropReference && !notificationCallbackPropNames) continue;
-			if (!notificationCallbackPropNames && resolvesToLocalHookReturnBinding(ref)) continue;
-			if (!isSynchronous(ref.identifier, effectFn) && !directLocalEffectHelper) continue;
+			if (!callExpr) continue;
 			if (isCallResultConsumedAsArgument(callExpr)) continue;
 			const calleeNode = callExpr.callee;
 			const methodName = calleeNode ? getCallMethodName(calleeNode) : null;
 			const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && calleeNode && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
-			if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead && !notificationCallbackPropNames) continue;
-			if (!notificationCallbackPropNames && calleeNode && isNamespacedApiCallee(calleeNode)) continue;
-			const stateArgRefs = transparentPropReference || notificationCallbackPropNames ? collectDirectCallStateRefs(analysis, callExpr) : callGraphReferences.flatMap((callGraphReference) => collectPropCallbackBoundStateRefs(analysis, callGraphReference, (innerRef) => isParentNotificationCallbackRef(analysis, innerRef)));
+			if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
+			if (calleeNode && isNamespacedApiCallee(calleeNode)) continue;
+			const stateArgRefs = collectPropCallbackBoundStateRefs(analysis, ref, (innerRef) => isParentNotificationCallbackRef(analysis, innerRef));
 			const handsSetterNamedCallbackData = propCallbackRefs.some(isSetterNamedCallbackReceivingData);
 			if (stateArgRefs.length === 0 && !handsSetterNamedCallbackData) continue;
 			context.report({
@@ -47051,7 +45481,6 @@ const isStateLikeDependency = (analysis, element, isPropName) => {
 	if (!analysis) return true;
 	const reference = getRef(analysis, element);
 	if (!reference) return true;
-	if (isCustomHookStateResultReference(analysis, reference)) return true;
 	const upstreamReferences = getUpstreamRefs(analysis, reference);
 	if (upstreamReferences.some((upstreamReference) => isState(analysis, upstreamReference))) return true;
 	return !upstreamReferences.some((upstreamReference) => isProp(analysis, upstreamReference));
@@ -47068,22 +45497,6 @@ const getRefHeldPropCallbackName = (callExpression, isPropName) => {
 	if (!callbackArgument || !isNodeOfType(callbackArgument, "Identifier")) return null;
 	return isPropName(callbackArgument.name) ? callbackArgument.name : null;
 };
-const getTransparentWrappedPropCallbackName = (callExpression, context, isPropName) => {
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "Identifier")) return null;
-	const binding = findVariableInitializer(callExpression, callee.name);
-	if (!binding?.initializer) return null;
-	const resultSymbol = context.scopes.symbolFor(callee);
-	const callbackArgument = getTransparentReactCallbackWrapperArgument(binding.initializer, resultSymbol, context.scopes);
-	if (!callbackArgument) return null;
-	const callbackSource = stripParenExpression(callbackArgument);
-	if (isNodeOfType(callbackSource, "Identifier")) return isPropName(callbackSource.name, callbackSource) ? callbackSource.name : null;
-	if (!isNodeOfType(callbackSource, "MemberExpression")) return null;
-	const receiver = stripParenExpression(callbackSource.object);
-	const propertyName = getStaticPropertyName(callbackSource);
-	if (!isNodeOfType(receiver, "Identifier") || !propertyName) return null;
-	return isPropName(receiver.name, receiver) ? propertyName : null;
-};
 const noPropCallbackInEffect = defineRule({
 	id: "no-prop-callback-in-effect",
 	title: "Parent kept in sync with a callback effect",
@@ -47117,16 +45530,9 @@ const noPropCallbackInEffect = defineRule({
 				walkInsideStatementBlocks(callback.body, (child) => {
 					if (!isNodeOfType(child, "CallExpression")) return;
 					const directCallee = stripParenExpression(child.callee);
-					const resolvedCallbackPropNames = analysis && propStackTracker.getCurrentPropNames().size > 0 ? getParentCallbackPropNames({
-						analysis,
-						expression: directCallee,
-						scopes: context.scopes
-					}) : null;
-					const calleeName = resolvedCallbackPropNames && [...resolvedCallbackPropNames][0] || isNodeOfType(directCallee, "Identifier") && propStackTracker.isPropName(directCallee.name) && directCallee.name || getRefHeldPropCallbackName(child, propStackTracker.isPropName) || getTransparentWrappedPropCallbackName(child, context, propStackTracker.isPropName);
+					const calleeName = isNodeOfType(directCallee, "Identifier") && propStackTracker.isPropName(directCallee.name) && directCallee.name || getRefHeldPropCallbackName(child, propStackTracker.isPropName);
 					if (!calleeName) return;
-					const callExpressionRoot = findTransparentExpressionRoot(child);
-					const isDirectEffectReturn = isNodeOfType(callExpressionRoot.parent, "ReturnStatement") && callExpressionRoot.parent.parent === callback.body;
-					if (!isResultDiscardedCall(child) && !isDirectEffectReturn) return;
+					if (!isResultDiscardedCall(child)) return;
 					if (reportedNodes.has(child)) return;
 					reportedNodes.add(child);
 					context.report({
@@ -47959,69 +46365,6 @@ const noRedundantShouldComponentUpdate = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/correctness/no-ref-callback-cleanup-before-react-19.ts
-const resolveFunctionExpressions = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isFunctionLike$1(expression)) return expression.async || expression.generator ? [] : [expression];
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		if (isNodeOfType(expression.test, "Literal")) return resolveFunctionExpressions(expression.test.value ? expression.consequent : expression.alternate, scopes, visitedSymbolIds);
-		return [...resolveFunctionExpressions(expression.consequent, scopes, visitedSymbolIds), ...resolveFunctionExpressions(expression.alternate, scopes, visitedSymbolIds)];
-	}
-	if (isNodeOfType(expression, "LogicalExpression")) {
-		if (isNodeOfType(expression.left, "Literal")) {
-			const isLeftTruthy = Boolean(expression.left.value);
-			if (expression.operator === "&&" && !isLeftTruthy) return [];
-			if (expression.operator === "||" && isLeftTruthy) return [];
-			if (expression.operator === "??" && expression.left.value !== null) return [];
-		}
-		if (expression.operator === "&&") return resolveFunctionExpressions(expression.right, scopes, visitedSymbolIds);
-		return [...resolveFunctionExpressions(expression.left, scopes, visitedSymbolIds), ...resolveFunctionExpressions(expression.right, scopes, visitedSymbolIds)];
-	}
-	if (isNodeOfType(expression, "SequenceExpression")) {
-		const finalExpression = expression.expressions.at(-1);
-		return finalExpression ? resolveFunctionExpressions(finalExpression, scopes, visitedSymbolIds) : [];
-	}
-	if (isNodeOfType(expression, "CallExpression")) {
-		if (!isReactApiCall(expression, "useCallback", scopes)) return [];
-		const callback = expression.arguments[0];
-		return callback && !isNodeOfType(callback, "SpreadElement") ? resolveFunctionExpressions(callback, scopes, visitedSymbolIds) : [];
-	}
-	if (!isNodeOfType(expression, "Identifier")) return [];
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return [];
-	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration") && symbol.references.every((reference) => reference.flag === "read")) return resolveFunctionExpressions(symbol.declarationNode, scopes, new Set([...visitedSymbolIds, symbol.id]));
-	const initializer = getDirectConstInitializer(symbol);
-	if (!initializer) return [];
-	return resolveFunctionExpressions(initializer, scopes, new Set([...visitedSymbolIds, symbol.id]));
-};
-const functionReturnsCleanupFunction = (functionExpression, scopes) => {
-	if (!isFunctionLike$1(functionExpression)) return false;
-	if (!isNodeOfType(functionExpression.body, "BlockStatement")) return resolveFunctionExpressions(functionExpression.body, scopes).length > 0;
-	return collectFunctionReturnStatements(functionExpression).some((returnStatement) => Boolean(returnStatement.argument && resolveFunctionExpressions(returnStatement.argument, scopes).length > 0));
-};
-const callbackReturnsCleanupFunction = (callback, scopes) => {
-	return resolveFunctionExpressions(callback, scopes).some((functionExpression) => functionReturnsCleanupFunction(functionExpression, scopes));
-};
-const noRefCallbackCleanupBeforeReact19 = defineRule({
-	id: "no-ref-callback-cleanup-before-react-19",
-	title: "Ref cleanup requires React 19",
-	requires: ["react:18"],
-	disabledWhen: ["react:19"],
-	severity: "warn",
-	recommendation: "React 18 ignores functions returned from ref callbacks. Handle cleanup when React calls the ref with `null`, or require React 19 before returning a cleanup function.",
-	create: (context) => ({ JSXAttribute(node) {
-		if (getJsxAttributeName(node.name) !== "ref") return;
-		if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
-		const callback = node.value.expression;
-		if (!callback || isNodeOfType(callback, "JSXEmptyExpression")) return;
-		if (!callbackReturnsCleanupFunction(callback, context.scopes)) return;
-		context.report({
-			node,
-			message: "This ref callback returns a cleanup function, but React 18 ignores ref cleanup returns, so the cleanup never runs. Handle detachment when React calls the ref with `null`, or require React 19."
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
 const REPEATED_ANCESTOR_TYPES = new Set([
 	"DoWhileStatement",
@@ -54782,6 +53125,12 @@ const isInsideEs6Component$1 = (methodDefinition) => {
 	if (!owningClass) return false;
 	return isPreactOrReactComponentClass(owningClass);
 };
+const stripThisParameter = (params) => {
+	const first = params[0];
+	if (!first) return params;
+	if (isNodeOfType(first, "Identifier") && first.name === "this") return params.slice(1);
+	return params;
+};
 const preactNoRenderArguments = defineRule({
 	id: "preact-no-render-arguments",
 	title: "render() reads props from arguments",
@@ -57983,39 +56332,8 @@ const isUseStateSetterInScope = (node, setterName) => isHookBindingInScope(node,
 	destructureIndex: 1
 });
 //#endregion
-//#region src/plugin/utils/unwrap-return-expression.ts
-const unwrapReturnExpression = (node) => isNodeOfType(node, "ReturnStatement") && node.argument ? node.argument : node;
-//#endregion
 //#region src/plugin/rules/performance/rendering-hydration-no-flicker.ts
 const USE_EFFECT_ONLY = new Set(["useEffect"]);
-const USE_CALLBACK_ONLY = new Set(["useCallback"]);
-const USE_STATE_ONLY = new Set(["useState"]);
-const REACT_API_CALL_OPTIONS = {
-	allowGlobalReactNamespace: true,
-	allowUnboundBareCalls: true,
-	resolveNamedAliases: true
-};
-const expressionReadsDerivedSymbol = (context, expression, stateDerivedSymbolIds) => {
-	let readsDerivedSymbol = false;
-	walkAst(expression, (node) => {
-		if (readsDerivedSymbol) return false;
-		if (node !== expression && isFunctionLike$1(node)) return false;
-		if (isNodeOfType(node, "Identifier") && stateDerivedSymbolIds.has(context.scopes.symbolFor(node)?.id ?? -1)) readsDerivedSymbol = true;
-	});
-	return readsDerivedSymbol;
-};
-const getStaticObjectPropertyName = (property) => {
-	if (!isNodeOfType(property, "Property") || property.computed || property.method || property.kind !== "init") return null;
-	if (isNodeOfType(property.key, "Identifier")) return property.key.name;
-	if (isNodeOfType(property.key, "Literal") && (typeof property.key.value === "string" || typeof property.key.value === "number")) return String(property.key.value);
-	return null;
-};
-const isNonVisibleJsxSpreadProperty = (propertyName) => propertyName === "id" || propertyName.startsWith("aria-") || /^on[A-Z]/.test(propertyName);
-const isTransparentAssignmentTarget = (identifier) => {
-	const expressionRoot = findTransparentExpressionRoot(identifier);
-	const parent = expressionRoot.parent;
-	return Boolean(isNodeOfType(parent, "AssignmentExpression") && parent.left === expressionRoot || isNodeOfType(parent, "UpdateExpression") && parent.argument === expressionRoot || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === expressionRoot);
-};
 const argumentsReadRefCurrent = (callArguments) => callArguments.some((argument) => {
 	let readsCurrent = false;
 	walkAst(argument, (child) => {
@@ -58067,166 +56385,6 @@ const isStateUsedOnlyInIdOrAriaAttributes = (setterCall, setterName) => {
 	});
 	return referenceCount > 0 && !nonAriaReferenceFound;
 };
-const isGlobalWindowMember = (context, node, propertyName) => {
-	const member = stripParenExpression(node);
-	if (!isNodeOfType(member, "MemberExpression") || member.computed) return false;
-	const receiver = stripParenExpression(member.object);
-	return isNodeOfType(receiver, "Identifier") && receiver.name === "window" && context.scopes.isGlobalReference(receiver) && isNodeOfType(member.property, "Identifier") && member.property.name === propertyName;
-};
-const getDirectWindowWidthSetter = (context, statement) => {
-	const call = unwrapDiscardedExpression(statement);
-	if (!isNodeOfType(call, "CallExpression") || call.arguments?.length !== 1) return null;
-	if (!isNodeOfType(call.callee, "Identifier") || !isSetterCall(call)) return null;
-	const argument = call.arguments[0];
-	return isGlobalWindowMember(context, argument, "innerWidth") ? call : null;
-};
-const getResizeListenerHandler = (context, statement, methodName) => {
-	const call = unwrapDiscardedExpression(statement);
-	if (!isNodeOfType(call, "CallExpression") || call.arguments?.length !== 2) return null;
-	if (!isGlobalWindowMember(context, call.callee, methodName)) return null;
-	const eventName = call.arguments[0];
-	const handler = call.arguments[1];
-	if (!isNodeOfType(eventName, "Literal") || eventName.value !== "resize") return null;
-	return isNodeOfType(handler, "Identifier") ? handler : null;
-};
-const getCleanupResizeHandler = (context, statement) => {
-	if (!isNodeOfType(statement, "ReturnStatement") || !isFunctionLike$1(statement.argument)) return null;
-	const cleanupStatements = getCallbackStatements(statement.argument);
-	if (cleanupStatements.length !== 1) return null;
-	return getResizeListenerHandler(context, unwrapReturnExpression(cleanupStatements[0]), "removeEventListener");
-};
-const findExactViewportState = (context, componentFunction, setterCall) => {
-	if (!isFunctionLike$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
-	const componentBody = componentFunction.body;
-	if (!isNodeOfType(setterCall.callee, "Identifier")) return null;
-	const setterSymbol = context.scopes.symbolFor(setterCall.callee);
-	if (!setterSymbol || setterSymbol.kind !== "const" || !isNodeOfType(setterSymbol.declarationNode, "VariableDeclarator")) return null;
-	const declarator = setterSymbol.declarationNode;
-	if (!isNodeOfType(declarator.id, "ArrayPattern")) return null;
-	const stateIdentifier = declarator.id.elements?.[0];
-	const setterIdentifier = declarator.id.elements?.[1];
-	if (!isNodeOfType(stateIdentifier, "Identifier") || !isNodeOfType(setterIdentifier, "Identifier") || setterIdentifier !== setterSymbol.bindingIdentifier || !isNodeOfType(declarator.init, "CallExpression") || !isReactApiCall(declarator.init, USE_STATE_ONLY, context.scopes, REACT_API_CALL_OPTIONS)) return null;
-	const initializer = declarator.init.arguments?.[0];
-	if (!isNodeOfType(initializer, "Literal") || initializer.value !== 0) return null;
-	const stateSymbol = context.scopes.symbolFor(stateIdentifier);
-	if (!stateSymbol) return null;
-	const stateDerivedSymbolIds = new Set([stateSymbol.id]);
-	let didAddDerivedSymbol = true;
-	while (didAddDerivedSymbol) {
-		didAddDerivedSymbol = false;
-		for (const statement of componentBody.body ?? []) {
-			if (!isNodeOfType(statement, "VariableDeclaration")) continue;
-			for (const candidateDeclarator of statement.declarations ?? []) {
-				if (!isNodeOfType(candidateDeclarator.id, "Identifier") || !candidateDeclarator.init) continue;
-				const candidateInitializer = stripParenExpression(candidateDeclarator.init);
-				if (isFunctionLike$1(candidateInitializer) || isNodeOfType(candidateInitializer, "CallExpression") && isReactApiCall(candidateInitializer, USE_CALLBACK_ONLY, context.scopes, REACT_API_CALL_OPTIONS)) continue;
-				if (!expressionReadsDerivedSymbol(context, candidateInitializer, stateDerivedSymbolIds)) continue;
-				const candidateSymbol = context.scopes.symbolFor(candidateDeclarator.id);
-				if (candidateSymbol?.kind === "const" && candidateSymbol.references.every((reference) => reference.flag === "read" && !isTransparentAssignmentTarget(reference.identifier)) && !stateDerivedSymbolIds.has(candidateSymbol.id)) {
-					stateDerivedSymbolIds.add(candidateSymbol.id);
-					didAddDerivedSymbol = true;
-				}
-			}
-		}
-	}
-	const staticSpreadVisibilityBySymbolId = /* @__PURE__ */ new Map();
-	const hasOnlyStaticObjectReferences = (identifier, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-		const symbol = context.scopes.symbolFor(identifier);
-		if (!symbol) return false;
-		if (visitedSymbolIds.has(symbol.id)) return true;
-		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-		nextVisitedSymbolIds.add(symbol.id);
-		let hasUnknownReference = false;
-		walkAst(componentBody, (node) => {
-			if (hasUnknownReference || !isNodeOfType(node, "Identifier") || context.scopes.symbolFor(node)?.id !== symbol.id || node === symbol.bindingIdentifier) return;
-			const referenceRoot = findTransparentExpressionRoot(node);
-			const parent = referenceRoot.parent;
-			if (isNodeOfType(parent, "JSXSpreadAttribute") && parent.argument === referenceRoot) return;
-			if (isNodeOfType(parent, "VariableDeclarator") && parent.init === referenceRoot && isNodeOfType(parent.id, "Identifier") && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const" && hasOnlyStaticObjectReferences(parent.id, nextVisitedSymbolIds)) return;
-			hasUnknownReference = true;
-			return false;
-		});
-		return !hasUnknownReference;
-	};
-	const classifyStaticSpreadObject = (identifier, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-		const symbol = context.scopes.symbolFor(identifier);
-		if (!symbol || visitedSymbolIds.has(symbol.id)) return "unknown";
-		const cachedVisibility = staticSpreadVisibilityBySymbolId.get(symbol.id);
-		if (cachedVisibility) return cachedVisibility;
-		if (symbol.kind !== "const" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier") || symbol.declarationNode.id !== symbol.bindingIdentifier || !symbol.declarationNode.init) return "unknown";
-		if (!hasOnlyStaticObjectReferences(identifier)) return "unknown";
-		const initializer = stripParenExpression(symbol.declarationNode.init);
-		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-		nextVisitedSymbolIds.add(symbol.id);
-		if (isNodeOfType(initializer, "Identifier")) {
-			const visibility = classifyStaticSpreadObject(initializer, nextVisitedSymbolIds);
-			staticSpreadVisibilityBySymbolId.set(symbol.id, visibility);
-			return visibility;
-		}
-		if (!isNodeOfType(initializer, "ObjectExpression")) return "unknown";
-		let visibility = "non-visible";
-		for (const property of initializer.properties ?? []) {
-			const propertyName = getStaticObjectPropertyName(property);
-			if (!isNodeOfType(property, "Property") || !propertyName) {
-				visibility = "unknown";
-				break;
-			}
-			if (expressionReadsDerivedSymbol(context, property.value, stateDerivedSymbolIds) && !isNonVisibleJsxSpreadProperty(propertyName)) visibility = "visible";
-		}
-		staticSpreadVisibilityBySymbolId.set(symbol.id, visibility);
-		return visibility;
-	};
-	let hasNonAriaReference = false;
-	walkAst(componentBody, (node) => {
-		if (hasNonAriaReference) return false;
-		if (!isNodeOfType(node, "Identifier") || !stateDerivedSymbolIds.has(context.scopes.symbolFor(node)?.id ?? -1)) return;
-		if (findEnclosingFunction$1(node) !== componentFunction) return;
-		const parent = node.parent;
-		if (parent && (isNodeOfType(parent, "MemberExpression") && parent.property === node && !parent.computed || isNodeOfType(parent, "Property") && parent.key === node && !parent.computed)) return;
-		let cursor = parent;
-		while (cursor && cursor !== componentBody) {
-			if (isFunctionLike$1(cursor)) return;
-			if (isNodeOfType(cursor, "JSXSpreadAttribute")) {
-				if (isNodeOfType(node, "Identifier") && classifyStaticSpreadObject(node) === "visible") hasNonAriaReference = true;
-				return;
-			}
-			if (isNodeOfType(cursor, "JSXAttribute")) {
-				if (isEventHandlerAttribute(cursor)) return;
-				if (!isInsideIdOrAriaAttribute(node)) hasNonAriaReference = true;
-				return;
-			}
-			if (isNodeOfType(cursor, "ReturnStatement")) {
-				hasNonAriaReference = true;
-				return;
-			}
-			cursor = cursor.parent;
-		}
-	});
-	return hasNonAriaReference ? stateIdentifier.name : null;
-};
-const isExactViewportSubscriptionEffect = (context, effectCall, callback) => {
-	if (!isReactApiCall(effectCall, USE_EFFECT_ONLY, context.scopes, REACT_API_CALL_OPTIONS)) return false;
-	if (!isFunctionLike$1(callback) || callback.async || !isNodeOfType(callback.body, "BlockStatement")) return false;
-	const statements = getCallbackStatements(callback);
-	if (statements.length !== 4) return false;
-	const handlerDeclaration = statements[0];
-	if (!isNodeOfType(handlerDeclaration, "VariableDeclaration") || handlerDeclaration.kind !== "const" || handlerDeclaration.declarations?.length !== 1) return false;
-	const handlerDeclarator = handlerDeclaration.declarations[0];
-	if (!isNodeOfType(handlerDeclarator.id, "Identifier") || !isFunctionLike$1(handlerDeclarator.init)) return false;
-	const handlerStatements = getCallbackStatements(handlerDeclarator.init);
-	if (handlerStatements.length !== 1) return false;
-	const handlerSetter = getDirectWindowWidthSetter(context, unwrapReturnExpression(handlerStatements[0]));
-	const subscribedHandler = getResizeListenerHandler(context, statements[1], "addEventListener");
-	const immediateSetter = getDirectWindowWidthSetter(context, statements[2]);
-	const cleanupHandler = getCleanupResizeHandler(context, statements[3]);
-	if (!handlerSetter || !subscribedHandler || !immediateSetter || !cleanupHandler) return false;
-	const handlerSymbol = context.scopes.symbolFor(handlerDeclarator.id);
-	if (!handlerSymbol || context.scopes.symbolFor(subscribedHandler) !== handlerSymbol || context.scopes.symbolFor(cleanupHandler) !== handlerSymbol) return false;
-	if (!isNodeOfType(handlerSetter.callee, "Identifier") || !isNodeOfType(immediateSetter.callee, "Identifier") || context.scopes.symbolFor(handlerSetter.callee) !== context.scopes.symbolFor(immediateSetter.callee)) return false;
-	const componentFunction = findEnclosingFunction$1(effectCall);
-	if (!isFunctionLike$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return false;
-	return findExactViewportState(context, componentFunction, immediateSetter) !== null;
-};
 const renderingHydrationNoFlicker = defineRule({
 	id: "rendering-hydration-no-flicker",
 	title: "useEffect setState flashes on mount",
@@ -58239,14 +56397,7 @@ const renderingHydrationNoFlicker = defineRule({
 		if (!isNodeOfType(depsNode, "ArrayExpression") || depsNode.elements?.length !== 0) return;
 		const callback = getEffectCallback(node);
 		if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
-		if (isExactViewportSubscriptionEffect(context, node, callback)) {
-			context.report({
-				node,
-				message: "This flashes for your users because useEffect(setState, []) runs after the first paint, so use useSyncExternalStore, or add suppressHydrationWarning"
-			});
-			return;
-		}
-		const bodyStatements = getCallbackStatements(callback);
+		const bodyStatements = (isNodeOfType(callback.body, "BlockStatement") ? callback.body.body ?? [] : [callback.body]).filter((statement) => !isNoOpStatement(statement));
 		if (bodyStatements.length !== 1) return;
 		const soleStatement = bodyStatements[0];
 		if (!isNodeOfType(soleStatement, "ExpressionStatement")) return;
@@ -58409,125 +56560,6 @@ const ASYNC_DATA_CALLEE_NAMES = new Set([
 const RESOURCE_LOAD_EVENT_ATTRIBUTE_PATTERN = /^on(?:Load|Error|Abort|Progress|CanPlay|Stalled|Suspend|Waiting|Ended)/;
 const JSX_EVENT_HANDLER_ATTRIBUTE_PATTERN = /^on[A-Z]/;
 const REDUX_DISPATCH_HOOK_PATTERN = /^use\w*Dispatch$/;
-const FILE_READER_READ_METHOD_NAMES = new Set([
-	"readAsArrayBuffer",
-	"readAsBinaryString",
-	"readAsDataURL",
-	"readAsText"
-]);
-const isGlobalFileReaderConstruction = (expression, context) => {
-	if (!expression) return false;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "NewExpression") || !isNodeOfType(unwrappedExpression.callee, "Identifier")) return false;
-	return unwrappedExpression.callee.name === "FileReader" && context.scopes.isGlobalReference(unwrappedExpression.callee);
-};
-const getFileReaderOriginStartBefore = (readerSymbol, readCall, context) => {
-	const readFunction = findEnclosingFunction$1(readCall);
-	let latestValue = null;
-	let latestStart = null;
-	if (readerSymbol.initializer && findEnclosingFunction$1(readerSymbol.declarationNode) === readFunction && readerSymbol.declarationNode.range[0] < readCall.range[0]) {
-		latestValue = readerSymbol.initializer;
-		latestStart = readerSymbol.declarationNode.range[0];
-	}
-	for (const reference of readerSymbol.references) {
-		if (reference.flag === "read" || reference.identifier.range[0] >= readCall.range[0] || latestStart !== null && reference.identifier.range[0] <= latestStart || findEnclosingFunction$1(reference.identifier) !== readFunction) continue;
-		const assignment = reference.identifier.parent;
-		if (!assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== reference.identifier) continue;
-		latestValue = assignment.right;
-		latestStart = reference.identifier.range[0];
-	}
-	return isGlobalFileReaderConstruction(latestValue, context) ? latestStart : null;
-};
-const resolveLoadingCompletionFunction = (expression, context) => {
-	const directFunction = resolveExactLocalFunction(expression, context.scopes);
-	if (directFunction) return directFunction;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	const initializer = symbol ? getDirectUnreassignedInitializer(symbol) : null;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression") || !isReactApiCall(initializer, "useCallback", context.scopes)) return null;
-	const callback = initializer.arguments?.[0];
-	return callback && isFunctionLike$1(callback) ? callback : null;
-};
-const isSetterBooleanCall = (node, setterSymbol, value, context) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	const argument = node.arguments?.[0];
-	const unwrappedArgument = argument ? stripParenExpression(argument) : null;
-	return Boolean(isNodeOfType(callee, "Identifier") && context.scopes.symbolFor(callee) === setterSymbol && unwrappedArgument && isNodeOfType(unwrappedArgument, "Literal") && unwrappedArgument.value === value);
-};
-const functionClearsLoadingState = (functionNode, setterSymbol, context, visitedFunctions) => {
-	if (visitedFunctions.has(functionNode) || !isFunctionLike$1(functionNode)) return false;
-	visitedFunctions.add(functionNode);
-	let didClearLoadingState = false;
-	walkAst(functionNode.body, (child) => {
-		if (didClearLoadingState) return false;
-		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isSetterBooleanCall(child, setterSymbol, false, context)) {
-			didClearLoadingState = true;
-			return false;
-		}
-		const helperFunction = resolveLoadingCompletionFunction(child.callee, context);
-		if (helperFunction && functionClearsLoadingState(helperFunction, setterSymbol, context, visitedFunctions)) {
-			didClearLoadingState = true;
-			return false;
-		}
-	});
-	return didClearLoadingState;
-};
-const getLatestFileReaderCallbackBefore = (readCall, readerSymbol, propertyName, originStart, context) => {
-	const readFunction = findEnclosingFunction$1(readCall);
-	if (!readFunction || !isFunctionLike$1(readFunction)) return null;
-	let callback = null;
-	let callbackStart = originStart;
-	walkAst(readFunction.body, (child) => {
-		if (child !== readFunction.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "AssignmentExpression") || child.operator !== "=" || child.range[0] >= readCall.range[0] || child.range[0] <= callbackStart || !isNodeOfType(child.left, "MemberExpression") || getStaticPropertyName(child.left) !== propertyName) return;
-		const receiver = stripParenExpression(child.left.object);
-		if (!isNodeOfType(receiver, "Identifier") || context.scopes.symbolFor(receiver) !== readerSymbol) return;
-		callback = child.right;
-		callbackStart = child.range[0];
-	});
-	return callback;
-};
-const setterStartsLoadingBefore = (readCall, setterSymbol, context) => {
-	const readFunction = findEnclosingFunction$1(readCall);
-	if (!readFunction || !isFunctionLike$1(readFunction)) return false;
-	let didStartLoading = false;
-	walkAst(readFunction.body, (child) => {
-		if (didStartLoading) return false;
-		if (child !== readFunction.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "CallExpression") || child.range[0] >= readCall.range[0]) return;
-		if (isSetterBooleanCall(child, setterSymbol, true, context)) {
-			didStartLoading = true;
-			return false;
-		}
-	});
-	return didStartLoading;
-};
-const setterTracksFileReader = (functionBody, setterSymbol, context) => {
-	let didFindFileReaderLifecycle = false;
-	walkAst(functionBody, (child) => {
-		if (didFindFileReaderLifecycle) return false;
-		if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "MemberExpression") || !FILE_READER_READ_METHOD_NAMES.has(getStaticPropertyName(child.callee) ?? "")) return;
-		const receiver = stripParenExpression(child.callee.object);
-		if (!isNodeOfType(receiver, "Identifier")) return;
-		const readerSymbol = context.scopes.symbolFor(receiver);
-		if (!readerSymbol) return;
-		const originStart = getFileReaderOriginStartBefore(readerSymbol, child, context);
-		if (originStart === null || !setterStartsLoadingBefore(child, setterSymbol, context)) return;
-		const loadCallback = getLatestFileReaderCallbackBefore(child, readerSymbol, "onload", originStart, context);
-		const errorCallback = getLatestFileReaderCallbackBefore(child, readerSymbol, "onerror", originStart, context);
-		const loadFunction = loadCallback ? resolveLoadingCompletionFunction(loadCallback, context) : null;
-		const errorFunction = errorCallback ? resolveLoadingCompletionFunction(errorCallback, context) : null;
-		if (loadFunction && errorFunction && functionClearsLoadingState(loadFunction, setterSymbol, context, /* @__PURE__ */ new Set()) && functionClearsLoadingState(errorFunction, setterSymbol, context, /* @__PURE__ */ new Set())) {
-			didFindFileReaderLifecycle = true;
-			return false;
-		}
-	});
-	return didFindFileReaderLifecycle;
-};
 const hasAsyncLoadingWork = (fnBody, setterName) => {
 	let found = false;
 	walkAst(fnBody, (child) => {
@@ -58701,8 +56733,6 @@ const renderingUsetransitionLoading = defineRule({
 		const fnBody = enclosingFunctionBody(node);
 		if (fnBody && hasAsyncLoadingWork(fnBody, setterName)) return;
 		if (fnBody && setterName) {
-			const setterSymbol = isNodeOfType(secondBinding, "Identifier") ? context.scopes.symbolFor(secondBinding) : null;
-			if (setterSymbol && setterTracksFileReader(fnBody, setterSymbol, context)) return;
 			if (setterEscapes(fnBody, setterName, node)) return;
 			if (setterCalledAlongsideAsyncSignal(fnBody, setterName)) return;
 			if (setterCalledInEventListenerHandler(fnBody, setterName)) return;
@@ -68199,6 +66229,14 @@ const isStateKey = (key) => {
 	if (isNodeOfType(key, "Literal") && typeof key.value === "string") return key.value === "state";
 	return false;
 };
+const findEnclosingClass = (node) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "ClassDeclaration") || isNodeOfType(ancestor, "ClassExpression")) return ancestor;
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
 const isInConstructor = (node) => {
 	let ancestor = node.parent;
 	while (ancestor) {
@@ -72910,17 +70948,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noRedundantShouldComponentUpdate.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-ref-callback-cleanup-before-react-19",
-		id: "no-ref-callback-cleanup-before-react-19",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noRefCallbackCleanupBeforeReact19,
-			framework: "global",
-			category: "Bugs"
-		}
-	},
 	{
 		key: "react-doctor/no-ref-current-in-render",
 		id: "no-ref-current-in-render",