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

package/dist/index.js

@@ -1915,10 +1915,7 @@ const isGeneratedImageRenderContext = (context, node) => {
 	if (!node) return false;
 	const programRoot = findProgramRoot(node);
 	if (!programRoot) return false;
-	const generatedImageJsxNodes = collectGeneratedImageJsxNodes(programRoot);
-	if (generatedImageJsxNodes.has(node)) return true;
-	if (isNodeOfType(node, "JSXElement")) return generatedImageJsxNodes.has(node.openingElement);
-	return false;
+	return collectGeneratedImageJsxNodes(programRoot).has(node);
 };
 //#endregion
 //#region src/plugin/utils/object-has-accessible-child.ts
@@ -7675,21 +7672,6 @@ const readStaticBoolean = (node) => {
 	return unwrappedNode.value;
 };
 //#endregion
-//#region src/plugin/utils/resolve-const-identifier-alias.ts
-const resolveConstIdentifierAlias = (identifier, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) 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") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
-		visitedSymbolIds.add(symbol.id);
-		const initializer = stripParenExpression(symbol.initializer);
-		if (!isNodeOfType(initializer, "Identifier")) return symbol;
-		symbol = scopes.symbolFor(initializer);
-	}
-	return symbol;
-};
-//#endregion
 //#region src/plugin/utils/is-react-api-call.ts
 const includesApiName = (apiNames, apiName) => typeof apiNames === "string" ? apiNames === apiName : apiNames.has(apiName);
 const isImportedFromReact = (symbol) => {
@@ -7705,7 +7687,8 @@ const isNamedReactApiImport = (identifier, apiNames, scopes) => {
 	return Boolean(importedName && includesApiName(apiNames, importedName));
 };
 const isReactNamespaceImport = (identifier, scopes) => {
-	const symbol = resolveConstIdentifierAlias(identifier, scopes);
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const symbol = scopes.symbolFor(identifier);
 	if (!symbol || !isImportedFromReact(symbol)) return false;
 	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier");
 };
@@ -7716,11 +7699,9 @@ const isReactApiCall = (node, apiNames, scopes, options = {}) => {
 		if (isNamedReactApiImport(callee, apiNames, scopes)) return true;
 		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
 	}
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || !includesApiName(apiNames, callee.property.name)) return false;
-	const receiver = stripParenExpression(callee.object);
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (isReactNamespaceImport(receiver, scopes)) return true;
-	return Boolean(options.allowGlobalReactNamespace && receiver.name === "React" && scopes.isGlobalReference(receiver));
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || !includesApiName(apiNames, callee.property.name)) return false;
+	if (isReactNamespaceImport(callee.object, scopes)) return true;
+	return Boolean(options.allowGlobalReactNamespace && callee.object.name === "React" && scopes.isGlobalReference(callee.object));
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/build-listener-cleanup-mismatch-message.ts
@@ -8406,54 +8387,6 @@ const effectListenerCleanupMismatch = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/collect-effect-invoked-functions.ts
-const PROMISE_CHAIN_METHOD_NAMES$1 = new Set([
-	"then",
-	"catch",
-	"finally"
-]);
-const collectEffectInvokedFunctions = (effectCallback) => {
-	const invokedFunctions = new Set([effectCallback]);
-	const localFunctionBindings = /* @__PURE__ */ new Map();
-	const calledBindingNames = /* @__PURE__ */ new Set();
-	const pendingFunctions = [effectCallback];
-	const enqueue = (candidate) => {
-		const strippedCandidate = candidate ? stripParenExpression(candidate) : candidate;
-		if (!isFunctionLike$1(strippedCandidate) || invokedFunctions.has(strippedCandidate)) return;
-		invokedFunctions.add(strippedCandidate);
-		pendingFunctions.push(strippedCandidate);
-	};
-	const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
-	while (pendingFunctions.length > 0) {
-		const currentFunction = pendingFunctions.pop();
-		if (!currentFunction) break;
-		walkAst(currentFunction, (child) => {
-			if (child !== currentFunction && isFunctionLike$1(child)) {
-				if (isNodeOfType(child, "FunctionDeclaration") && isNodeOfType(child.id, "Identifier")) localFunctionBindings.set(child.id.name, child);
-				return false;
-			}
-			if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
-				const initializer = child.init ? stripParenExpression(child.init) : null;
-				if (isFunctionLike$1(initializer)) localFunctionBindings.set(child.id.name, initializer);
-				return;
-			}
-			if (!isNodeOfType(child, "CallExpression")) return;
-			const callee = stripParenExpression(child.callee);
-			if (isFunctionLike$1(callee)) {
-				enqueue(callee);
-				return;
-			}
-			if (isNodeOfType(callee, "Identifier")) {
-				calledBindingNames.add(callee.name);
-				return;
-			}
-			if (isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
-		});
-		for (const calledName of calledBindingNames) enqueue(localFunctionBindings.get(calledName));
-	}
-	return invokedFunctions;
-};
-//#endregion
 //#region src/plugin/utils/is-react-hook-name.ts
 const isReactHookName = (name) => {
 	if (!name.startsWith("use")) return false;
@@ -8509,90 +8442,46 @@ const enclosingComponentOrHookName = (node) => {
 	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
 };
 //#endregion
-//#region src/plugin/utils/find-declarator-for-binding.ts
-const findDeclaratorForBinding = (bindingIdentifier) => {
-	let ancestor = bindingIdentifier.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "VariableDeclarator")) return ancestor;
-		if (isNodeOfType(ancestor, "FunctionDeclaration") || isNodeOfType(ancestor, "FunctionExpression") || isNodeOfType(ancestor, "ArrowFunctionExpression") || isNodeOfType(ancestor, "Program")) return null;
-		ancestor = ancestor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/executes-during-render.ts
-const SYNCHRONOUS_ITERATION_METHOD_NAMES$1 = new Set([
-	"map",
-	"filter",
-	"forEach",
-	"flatMap",
-	"reduce",
-	"reduceRight",
-	"some",
-	"every",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"sort",
-	"toSorted"
-]);
-const REACT_RENDER_PHASE_HOOK_NAMES = new Set(["useMemo", "useState"]);
-const isGlobalArrayFromMember = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "MemberExpression") || unwrappedNode.computed || !isNodeOfType(unwrappedNode.object, "Identifier") || unwrappedNode.object.name !== "Array" || !scopes.isGlobalReference(unwrappedNode.object) || !isNodeOfType(unwrappedNode.property, "Identifier")) return false;
-	return unwrappedNode.property.name === "from";
-};
-const isConstAliasOfGlobalArrayFrom = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "Identifier")) return false;
-	const binding = findVariableInitializer(unwrappedNode, unwrappedNode.name);
-	if (!binding?.initializer) return false;
-	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
-	return Boolean(declarator && scopes.symbolFor(unwrappedNode)?.declarationNode === declarator && declarator.init && declarator.parent && isNodeOfType(declarator.parent, "VariableDeclaration") && declarator.parent.kind === "const" && isGlobalArrayFromMember(declarator.init, scopes));
-};
-const executesDuringRender = (functionNode, scopes) => {
-	const parent = functionNode.parent;
-	if (!isNodeOfType(parent, "CallExpression")) return false;
-	if (parent.callee === functionNode) return true;
-	if ((scopes ? isReactApiCall(parent, REACT_RENDER_PHASE_HOOK_NAMES, scopes, { allowGlobalReactNamespace: true }) : isHookCall$2(parent, REACT_RENDER_PHASE_HOOK_NAMES)) && parent.arguments?.[0] === functionNode) return true;
-	if (scopes && parent.arguments?.[1] === functionNode && (isGlobalArrayFromMember(parent.callee, scopes) || isConstAliasOfGlobalArrayFrom(parent.callee, scopes))) return true;
-	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES$1.has(parent.callee.property.name) && parent.arguments?.[0] === functionNode;
-};
-//#endregion
-//#region src/plugin/utils/find-render-phase-component-or-hook.ts
-const findRenderPhaseComponentOrHook = (node, scopes) => {
-	let functionNode = findEnclosingFunction(node);
-	while (functionNode) {
-		if (componentOrHookDisplayNameForFunction(functionNode)) return functionNode;
-		if (!executesDuringRender(functionNode, scopes)) return null;
-		functionNode = findEnclosingFunction(functionNode);
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/get-function-binding-name.ts
-const getFunctionBindingIdentifier = (functionNode) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
-	const parent = functionNode.parent;
-	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
-	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === functionNode && isNodeOfType(parent.left, "Identifier")) return parent.left;
-	if (isNodeOfType(parent, "CallExpression")) {
-		const callParent = parent.parent;
-		if (isNodeOfType(callParent, "VariableDeclarator") && isNodeOfType(callParent.id, "Identifier")) return callParent.id;
-	}
-	return null;
-};
-const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(functionNode)?.name ?? null;
-//#endregion
 //#region src/plugin/utils/get-range-start.ts
 const getRangeStart = (node) => {
 	const rangeStart = node.range?.[0];
 	return typeof rangeStart === "number" ? rangeStart : null;
 };
 //#endregion
-//#region src/plugin/utils/is-event-handler-attribute.ts
-const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
+//#region src/plugin/utils/is-result-discarded-call.ts
+const isResultDiscardedCall = (callExpression) => {
+	let node = callExpression;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "ExpressionStatement")) return true;
+		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void") return true;
+		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
+		if (isNodeOfType(parent, "ChainExpression")) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "SequenceExpression")) {
+			const expressions = parent.expressions ?? [];
+			if (expressions[expressions.length - 1] !== node) return true;
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
 //#endregion
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
@@ -8627,9 +8516,125 @@ const isCleanupReturningSubscribeLikeCallExpression = (node) => {
 	return true;
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/is-cleanup-return.ts
+const ITERATOR_CALLBACK_METHOD_NAMES$1 = new Set([
+	"each",
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flatMap",
+	"forEach",
+	"map",
+	"reduce",
+	"reduceRight",
+	"some",
+	"sort",
+	"toSorted"
+]);
+const STATIC_ITERATOR_CALLBACK_METHOD_NAMES = new Set([
+	"from",
+	"fromAsync",
+	"groupBy"
+]);
+const unwrapChainExpression$3 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const isNullLiteral = (node) => isNodeOfType(node, "Literal") && node.value === null;
+const isListenerRemovalViaNullHandler = (callNode) => {
+	if (!isNodeOfType(callNode, "CallExpression")) return false;
+	const callee = unwrapChainExpression$3(callNode.callee);
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "on" && isNullLiteral(callNode.arguments?.[1]);
+};
+const REFERENCE_BASED_REMOVAL_METHOD_NAMES = new Set([
+	"off",
+	"removeEventListener",
+	"removeListener"
+]);
+const isNoOpInlineHandlerRemoval = (callNode, methodName) => {
+	if (!REFERENCE_BASED_REMOVAL_METHOD_NAMES.has(methodName)) return false;
+	const handlerArgument = callNode.arguments?.[1];
+	return isNodeOfType(handlerArgument, "ArrowFunctionExpression") || isNodeOfType(handlerArgument, "FunctionExpression");
+};
+const isReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
+	const callNode = unwrapChainExpression$3(node);
+	if (!isNodeOfType(callNode, "CallExpression")) return false;
+	if (isListenerRemovalViaNullHandler(callNode)) return true;
+	const callee = unwrapChainExpression$3(callNode.callee);
+	if (isNodeOfType(callee, "Identifier")) {
+		if (TIMER_CLEANUP_CALLEE_NAMES.has(callee.name)) return true;
+		if (CLEANUP_LIKE_RELEASE_CALLEE_NAMES.has(callee.name)) return true;
+		if (knownCleanupFunctionNames.has(callee.name)) return true;
+		return false;
+	}
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
+		if (isNoOpInlineHandlerRemoval(callNode, callee.property.name)) return false;
+		if (BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier") && knownBoundSubscriptionNames.has(callee.object.name)) return true;
+		return GLOBAL_RELEASE_METHOD_NAMES.has(callee.property.name);
+	}
+	return false;
+};
+const isStaticIteratorCallbackCallee = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && (callee.object.name === "Array" || callee.object.name === "Map" || callee.object.name === "Object") && STATIC_ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
+const isIteratorCallbackArgument = (node) => {
+	const parentNode = node.parent;
+	if (!isNodeOfType(parentNode, "CallExpression")) return false;
+	if (!parentNode.arguments?.some((argument) => argument === node)) return false;
+	const callee = unwrapChainExpression$3(parentNode.callee);
+	if (parentNode.arguments[1] === node && isStaticIteratorCallbackCallee(callee)) return true;
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES$1.has(callee.property.name);
+};
+const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
+	let didFindRelease = false;
+	walkAst(node, (child) => {
+		if (didFindRelease) return false;
+		if (child !== node && isFunctionLike$1(child) && !isIteratorCallbackArgument(child)) return false;
+		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
+			didFindRelease = true;
+			return false;
+		}
+	});
+	return didFindRelease;
+};
+const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
+	if (!isFunctionLike$1(node)) return false;
+	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
+};
+const isProvablyNoOpCleanupFunction = (node) => {
+	if (!isFunctionLike$1(node)) return false;
+	let sawNoOpRemoval = false;
+	let sawOtherCall = false;
+	walkAst(node.body, (child) => {
+		if (sawOtherCall) return false;
+		if (isFunctionLike$1(child)) return false;
+		const callNode = unwrapChainExpression$3(child);
+		if (!isNodeOfType(callNode, "CallExpression")) return;
+		const callee = unwrapChainExpression$3(callNode.callee);
+		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && isNoOpInlineHandlerRemoval(callNode, callee.property.name)) {
+			sawNoOpRemoval = true;
+			return;
+		}
+		sawOtherCall = true;
+	});
+	return sawNoOpRemoval && !sawOtherCall;
+};
+const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames, options = {}) => {
+	if (!returnedValue) return false;
+	const unwrappedValue = unwrapChainExpression$3(returnedValue);
+	if (isNodeOfType(unwrappedValue, "Literal") && unwrappedValue.value === null) return false;
+	if (isNodeOfType(unwrappedValue, "Identifier")) {
+		if (unwrappedValue.name === "undefined") return false;
+		if (knownCleanupFunctionNames.has(unwrappedValue.name)) return true;
+		return options.allowOpaqueReturn === true && !knownBoundSubscriptionNames.has(unwrappedValue.name);
+	}
+	if (isCleanupReturningSubscribeLikeCallExpression(unwrappedValue)) return true;
+	if (isProvablyNoOpCleanupFunction(unwrappedValue)) return false;
+	if (options.allowOpaqueReturn === true && !isSubscribeLikeCallExpression(unwrappedValue)) return true;
+	if (isCleanupFunctionLike(unwrappedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames)) return true;
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
 const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
-const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
 const RESOURCE_NOUN_BY_KIND = {
 	subscribe: "subscription",
 	timer: "timer",
@@ -8640,66 +8645,7 @@ const isSubscribeOrObserveCall = (node) => {
 	if (isSubscribeLikeCallExpression(node)) return true;
 	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME;
 };
-const resolveExpressionKey$1 = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const symbol = context.scopes.symbolFor(unwrappedExpression);
-		if (!symbol) return context.scopes.isGlobalReference(unwrappedExpression) ? `global:${unwrappedExpression.name}` : null;
-		if (visitedSymbolIds.has(symbol.id)) return `symbol:${symbol.id}`;
-		visitedSymbolIds.add(symbol.id);
-		const bindingProperty = symbol.bindingIdentifier.parent;
-		const bindingPattern = bindingProperty?.parent;
-		const variableDeclarator = bindingPattern?.parent;
-		const bindingPropertyName = isNodeOfType(bindingProperty, "Property") ? getStaticPropertyKeyName(bindingProperty) : null;
-		if (bindingPropertyName && isNodeOfType(bindingPattern, "ObjectPattern") && isNodeOfType(variableDeclarator, "VariableDeclarator") && variableDeclarator.id === bindingPattern) {
-			const objectKey = resolveExpressionKey$1(variableDeclarator.init, context, visitedSymbolIds);
-			return objectKey ? `${objectKey}.${bindingPropertyName}` : `symbol:${symbol.id}`;
-		}
-		const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
-		if (symbol.kind === "const" && initializer && (isNodeOfType(initializer, "Identifier") || isNodeOfType(initializer, "MemberExpression"))) return resolveExpressionKey$1(initializer, context, visitedSymbolIds) ?? `symbol:${symbol.id}`;
-		return `symbol:${symbol.id}`;
-	}
-	if (isNodeOfType(unwrappedExpression, "MemberExpression") && !unwrappedExpression.computed) {
-		if (!isNodeOfType(unwrappedExpression.property, "Identifier")) return null;
-		const objectKey = resolveExpressionKey$1(unwrappedExpression.object, context, visitedSymbolIds);
-		return objectKey ? `${objectKey}.${unwrappedExpression.property.name}` : null;
-	}
-	if (isNodeOfType(unwrappedExpression, "ThisExpression")) return "this";
-	if (isNodeOfType(unwrappedExpression, "Literal") && (typeof unwrappedExpression.value === "string" || typeof unwrappedExpression.value === "number")) return `literal:${String(unwrappedExpression.value)}`;
-	if (isFunctionLike$1(unwrappedExpression)) {
-		const rangeStart = getRangeStart(unwrappedExpression);
-		return rangeStart === null ? null : `function:${rangeStart}`;
-	}
-	return null;
-};
-const findAssignedResourceKey = (resourceNode, context) => {
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (isNodeOfType(parentNode, "ChainExpression")) {
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	if (isNodeOfType(parentNode, "VariableDeclarator") && parentNode.init === currentNode) return resolveExpressionKey$1(parentNode.id, context);
-	if (isNodeOfType(parentNode, "AssignmentExpression") && parentNode.right === currentNode) return resolveExpressionKey$1(parentNode.left, context);
-	return null;
-};
-const getCallRegistrationDetails = (callNode, context) => {
-	const callee = stripParenExpression(callNode.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return {
-		receiverKey: null,
-		registrationVerbName: null,
-		eventKey: null,
-		handlerKey: null
-	};
-	return {
-		receiverKey: resolveExpressionKey$1(callee.object, context),
-		registrationVerbName: callee.property.name,
-		eventKey: resolveExpressionKey$1(callNode.arguments?.[0], context),
-		handlerKey: resolveExpressionKey$1(callNode.arguments?.[1], context)
-	};
-};
-const findSubscribeLikeUsages = (callback, context) => {
+const findSubscribeLikeUsages = (callback) => {
 	const usages = [];
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	let cleanupArgument = null;
@@ -8708,22 +8654,13 @@ const findSubscribeLikeUsages = (callback, context) => {
 		const lastCallbackStatement = callbackStatements[callbackStatements.length - 1];
 		if (isNodeOfType(lastCallbackStatement, "ReturnStatement") && lastCallbackStatement.argument) cleanupArgument = lastCallbackStatement.argument;
 	}
-	const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
 	walkAst(callback, (child) => {
-		if (child !== callback && isFunctionLike$1(child)) {
-			if (child === cleanupArgument) return false;
-			if (!effectInvokedFunctions.has(child) && !isSynchronousIteratorCallback(child)) return false;
-		}
+		if (child === cleanupArgument && !isSubscribeLikeCallExpression(child)) return false;
 		if (isSocketConstruction(child)) {
 			usages.push({
 				kind: "socket",
 				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: null,
-				eventKey: null,
-				handlerKey: null
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
 			});
 			return;
 		}
@@ -8732,348 +8669,118 @@ const findSubscribeLikeUsages = (callback, context) => {
 			usages.push({
 				kind: "timer",
 				node: child,
-				resourceName: child.callee.name,
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: child.callee.name,
-				eventKey: null,
-				handlerKey: null
+				resourceName: child.callee.name
 			});
 			return;
 		}
-		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) {
-			const registrationDetails = getCallRegistrationDetails(child, context);
-			usages.push({
-				kind: "subscribe",
-				node: child,
-				resourceName: child.callee.property.name,
-				handleKey: findAssignedResourceKey(child, context),
-				...registrationDetails
-			});
+		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) usages.push({
+			kind: "subscribe",
+			node: child,
+			resourceName: child.callee.property.name
+		});
+	});
+	return usages;
+};
+const collectCleanupBindings = (effectCallback) => {
+	const bindings = {
+		cleanupFunctionNames: /* @__PURE__ */ new Set(),
+		subscriptionNames: /* @__PURE__ */ new Set(),
+		effectScopeVariableNames: /* @__PURE__ */ new Set()
+	};
+	if (!isNodeOfType(effectCallback, "ArrowFunctionExpression") && !isNodeOfType(effectCallback, "FunctionExpression")) return bindings;
+	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return bindings;
+	walkAst(effectCallback.body, (child) => {
+		if (!isSubscribeOrObserveCall(child)) return;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!isNodeOfType(child.callee, "MemberExpression")) return;
+		if (!isNodeOfType(child.callee.object, "Identifier")) return;
+		bindings.subscriptionNames.add(child.callee.object.name);
+	});
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (!isNodeOfType(child, "VariableDeclaration")) return;
+		for (const declarator of child.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			const bindingName = declarator.id.name;
+			bindings.effectScopeVariableNames.add(bindingName);
+			const init = declarator.init;
+			if (!init) continue;
+			if (isSocketConstruction(init)) {
+				bindings.subscriptionNames.add(bindingName);
+				continue;
+			}
+			if (!isNodeOfType(init, "CallExpression")) continue;
+			if (isSubscribeLikeCallExpression(init)) {
+				bindings.subscriptionNames.add(bindingName);
+				if (isCleanupReturningSubscribeLikeCallExpression(init)) bindings.cleanupFunctionNames.add(bindingName);
+			}
 		}
 	});
-	return usages.filter((usage) => isNodeReachableWithinFunction(usage.node, context));
-};
-const isNodeReachableWithinFunction = (node, context) => {
-	const owner = context.cfg.enclosingFunction(node);
-	if (!owner) return true;
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return true;
-	const targetBlock = functionCfg.blockOf(node);
-	if (!targetBlock) return true;
-	const visitedBlocks = new Set([functionCfg.entry]);
-	const pendingBlocks = [functionCfg.entry];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		if (currentBlock === targetBlock) return true;
-		for (const edge of currentBlock.successors) {
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return false;
-};
-const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, context) => {
-	let pathAnchor = usageNode;
-	let pathOwner = findEnclosingFunction(pathAnchor);
-	while (pathOwner && isSynchronousIteratorCallback(pathOwner)) {
-		if (matchingNodes.length > 0 && matchingNodes.every((matchingNode) => context.cfg.enclosingFunction(matchingNode) === pathOwner)) break;
-		const iteratorCall = pathOwner.parent;
-		if (!isNodeOfType(iteratorCall, "CallExpression")) break;
-		pathAnchor = iteratorCall;
-		pathOwner = findEnclosingFunction(pathAnchor);
-	}
-	const owner = context.cfg.enclosingFunction(pathAnchor);
-	if (!owner) return false;
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return false;
-	const usageBlock = functionCfg.blockOf(pathAnchor);
-	if (!usageBlock) return false;
-	const usageStart = getRangeStart(usageNode);
-	const matchingBlocks = new Set(matchingNodes.flatMap((matchingNode) => {
-		if (context.cfg.enclosingFunction(matchingNode) !== owner) return [];
-		const matchingBlock = functionCfg.blockOf(matchingNode);
-		if (!matchingBlock) return [];
-		const matchingStart = getRangeStart(matchingNode);
-		if (matchingBlock === usageBlock && usageStart !== null && matchingStart !== null && matchingStart < usageStart) return [];
-		return [matchingBlock];
-	}));
-	if (matchingBlocks.has(usageBlock)) return true;
-	const visitedBlocks = new Set([usageBlock]);
-	const pendingBlocks = [usageBlock];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		for (const edge of currentBlock.successors) {
-			if (matchingBlocks.has(edge.to)) continue;
-			if (edge.to === functionCfg.exit) return false;
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return matchingBlocks.size > 0;
-};
-const removeSynchronouslyReleasedUsages = (callback, usages, context) => {
+	walkAst(effectCallback.body, (child) => {
+		if (child !== effectCallback.body && (isNodeOfType(child, "ArrowFunctionExpression") || isNodeOfType(child, "FunctionExpression"))) return false;
+		if (isNodeOfType(child, "FunctionDeclaration") && child.id && isCleanupFunctionLike(child, bindings.cleanupFunctionNames, bindings.subscriptionNames)) {
+			bindings.cleanupFunctionNames.add(child.id.name);
+			return false;
+		}
+	});
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (!isNodeOfType(child, "VariableDeclaration")) return;
+		for (const declarator of child.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier") || !declarator.init) continue;
+			if (isCleanupFunctionLike(declarator.init, bindings.cleanupFunctionNames, bindings.subscriptionNames)) bindings.cleanupFunctionNames.add(declarator.id.name);
+		}
+	});
+	walkAst(effectCallback.body, (child) => {
+		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.left, "Identifier") && bindings.effectScopeVariableNames.has(child.left.name) && isCleanupFunctionLike(child.right, bindings.cleanupFunctionNames, bindings.subscriptionNames)) bindings.cleanupFunctionNames.add(child.left.name);
+	});
+	return bindings;
+};
+const removeSynchronouslyReleasedUsages = (callback, usages) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
-	const releaseCalls = [];
+	const releaseStarts = [];
 	walkInsideStatementBlocks(callback.body, (child) => {
-		if (!isNodeOfType(isNodeOfType(child, "ChainExpression") ? child.expression : child, "CallExpression")) return;
-		releaseCalls.push(child);
+		if (!isReleaseLikeCall(child, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return;
+		const releaseStart = getRangeStart(child);
+		if (releaseStart !== null) releaseStarts.push(releaseStart);
 	});
-	if (releaseCalls.length === 0) return usages;
+	if (releaseStarts.length === 0) return usages;
 	return usages.filter((usage) => {
 		const usageStart = getRangeStart(usage.node);
 		if (usageStart === null) return true;
-		const matchingReleaseCalls = releaseCalls.filter((releaseCall) => {
-			const releaseStart = getRangeStart(releaseCall);
-			return releaseStart !== null && releaseStart > usageStart && doesReleaseCallMatchUsage(releaseCall, usage, context);
-		});
-		return !doMatchingNodesCoverEveryPathAfterUsage(usage.node, matchingReleaseCalls, context);
+		return !releaseStarts.some((releaseStart) => releaseStart > usageStart);
 	});
 };
-const resolveIteratorCollectionKey = (expression, context) => {
-	if (!expression || !isNodeOfType(expression, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(expression);
-	if (!symbol || symbol.kind !== "parameter") return null;
-	let callbackNode = symbol.bindingIdentifier.parent;
-	while (callbackNode && !isFunctionLike$1(callbackNode)) callbackNode = callbackNode.parent;
-	if (!callbackNode || !isFunctionLike$1(callbackNode)) return null;
-	const callNode = callbackNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression")) return null;
-	const callee = stripParenExpression(callNode.callee);
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) {
-		if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from" && callNode.arguments?.[1] === callbackNode) return resolveExpressionKey$1(callNode.arguments[0], context);
-		if (callNode.arguments?.[0] === callbackNode) return resolveExpressionKey$1(callee.object, context);
-	}
-	return null;
-};
-const findCollectionMappingCall = (callbackNode) => {
-	if (!isNodeOfType(callbackNode, "ArrowFunctionExpression") && !isNodeOfType(callbackNode, "FunctionExpression") || callbackNode.async || callbackNode.generator) return null;
-	const callNode = callbackNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression")) return null;
-	const callee = stripParenExpression(callNode.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return null;
-	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from" && callNode.arguments?.[1] === callbackNode) return callNode;
-	return callee.property.name === "map" && callNode.arguments?.[0] === callbackNode ? callNode : null;
-};
-const findMappedResourceCollectionKey = (resourceNode, context) => {
-	const callbackNode = findEnclosingFunction(resourceNode);
-	if (!callbackNode || !isNodeOfType(callbackNode, "ArrowFunctionExpression") && !isNodeOfType(callbackNode, "FunctionExpression")) return null;
-	const mappingCall = findCollectionMappingCall(callbackNode);
-	if (!mappingCall) return null;
-	if (isNodeOfType(callbackNode.body, "BlockStatement")) {
-		const resourceRoot = findTransparentExpressionRoot(resourceNode);
-		const resourceDeclarator = resourceRoot.parent;
-		const resourceDeclaration = resourceDeclarator?.parent;
-		if (!isNodeOfType(resourceDeclarator, "VariableDeclarator") || resourceDeclarator.init !== resourceRoot || !isNodeOfType(resourceDeclarator.id, "Identifier") || !isNodeOfType(resourceDeclaration, "VariableDeclaration") || resourceDeclaration.kind !== "const" || resourceDeclaration.parent !== callbackNode.body) return null;
-		const returnStatements = [];
-		walkAst(callbackNode.body, (child) => {
-			if (child !== callbackNode.body && isFunctionLike$1(child)) return false;
-			if (isNodeOfType(child, "ReturnStatement")) returnStatements.push(child);
-		});
-		const returnStatement = returnStatements[0];
-		const callbackStatements = callbackNode.body.body ?? [];
-		const returnedIdentifier = isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument ? stripParenExpression(returnStatement.argument) : null;
-		const resourceSymbol = context.scopes.symbolFor(resourceDeclarator.id);
-		if (returnStatements.length !== 1 || callbackStatements[callbackStatements.length - 1] !== returnStatement || !isNodeOfType(returnedIdentifier, "Identifier") || !resourceSymbol || context.scopes.symbolFor(returnedIdentifier)?.id !== resourceSymbol.id || !doMatchingNodesCoverEveryPathAfterUsage(resourceNode, [returnStatement], context)) return null;
-	} else if (findTransparentExpressionRoot(resourceNode) !== callbackNode.body) return null;
-	const mappingRoot = findTransparentExpressionRoot(mappingCall);
-	const collectionDeclarator = mappingRoot.parent;
-	return isNodeOfType(collectionDeclarator, "VariableDeclarator") && collectionDeclarator.init === mappingRoot ? resolveExpressionKey$1(collectionDeclarator.id, context) : null;
-};
-const findContainingCollectionKey = (resourceNode, context) => {
-	const mappedCollectionKey = findMappedResourceCollectionKey(resourceNode, context);
-	if (mappedCollectionKey !== null) return mappedCollectionKey;
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isFunctionLike$1(parentNode)) return null;
-		if (isNodeOfType(parentNode, "VariableDeclarator") && parentNode.init === currentNode) return resolveExpressionKey$1(parentNode.id, context);
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return null;
-};
-const isWithinAssignmentTarget = (identifier) => {
-	let currentNode = identifier;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "AssignmentExpression")) return parentNode.left === currentNode;
-		if (isNodeOfType(parentNode, "UpdateExpression") || isNodeOfType(parentNode, "UnaryExpression") && parentNode.operator === "delete") return parentNode.argument === currentNode;
-		if (isNodeOfType(parentNode, "ForInStatement") || isNodeOfType(parentNode, "ForOfStatement")) return parentNode.left === currentNode;
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const resolveStableValue = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return unwrappedExpression;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	const isUnreassignedMutableBinding = (symbol?.kind === "let" || symbol?.kind === "var") && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && symbol.declarationNode.id === symbol.bindingIdentifier && symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier)) && symbol.scope.symbols.filter((candidate) => candidate.name === symbol.name).length === 1;
-	const recursiveFunctionSymbol = symbol?.kind === "function" && isFunctionLike$1(symbol.declarationNode) ? context.scopes.ownScopeFor(symbol.declarationNode)?.symbols.find((candidate) => candidate.name === symbol.name && candidate.declarationNode === symbol.declarationNode) : null;
-	const isUnreassignedFunctionBinding = symbol?.kind === "function" && symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier)) && (!recursiveFunctionSymbol || recursiveFunctionSymbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier))) && symbol.scope.symbols.filter((candidate) => candidate.name === symbol.name).length === 1;
-	if (!symbol || symbol.kind !== "const" && !isUnreassignedMutableBinding && !isUnreassignedFunctionBinding || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return unwrappedExpression;
-	visitedSymbolIds.add(symbol.id);
-	return resolveStableValue(symbol.initializer, context, visitedSymbolIds);
-};
-const resolveObjectExpression = (expression, context) => {
-	const resolvedExpression = resolveStableValue(expression, context);
-	return isNodeOfType(resolvedExpression, "ObjectExpression") ? resolvedExpression : null;
-};
-const getListenerAbortControllerKey = (usage, context) => {
-	if (usage.registrationVerbName !== "addEventListener" || !isNodeOfType(usage.node, "CallExpression")) return null;
-	const optionsArgument = usage.node.arguments?.[2];
-	const optionsObject = resolveObjectExpression(optionsArgument, context);
-	if (!optionsObject) return null;
-	for (const property of optionsObject.properties ?? []) {
-		if (!isNodeOfType(property, "Property") || getStaticPropertyKeyName(property) !== "signal") continue;
-		const signalKey = resolveExpressionKey$1(property.value, context);
-		return signalKey?.endsWith(".signal") ? signalKey.slice(0, -7) : null;
-	}
-	return null;
-};
-const SYNCHRONOUS_ITERATOR_METHOD_NAMES$1 = new Set([
-	"every",
-	"filter",
-	"flatMap",
-	"forEach",
-	"map",
-	"reduce",
-	"reduceRight",
-	"some"
-]);
-const isSynchronousIteratorCallback = (functionNode) => {
-	const callNode = functionNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	const callee = stripParenExpression(callNode.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
-	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && callee.property.name === "from") return callNode.arguments?.[1] === functionNode;
-	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$1.has(callee.property.name) && callNode.arguments?.[0] === functionNode;
-};
-const findDirectCallForReference = (identifier) => {
-	const expressionRoot = findTransparentExpressionRoot(identifier);
-	const callNode = expressionRoot.parent;
-	return isNodeOfType(callNode, "CallExpression") && callNode.callee === expressionRoot ? callNode : null;
-};
-const findSingleDirectInvocation = (functionNode, caller, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
-	if (!bindingIdentifier || resolveStableValue(bindingIdentifier, context) !== functionNode) return null;
-	const symbol = context.scopes.symbolFor(bindingIdentifier);
-	if (!symbol) return null;
-	const invocationCalls = symbol.references.flatMap((reference) => {
-		const callNode = findDirectCallForReference(reference.identifier);
-		return callNode ? [callNode] : [];
-	});
-	if (invocationCalls.length !== 1) return null;
-	const invocationCall = invocationCalls[0];
-	return findEnclosingFunction(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
-};
-const resolveCleanupPathAnchor = (usageNode, effectCallback, context) => {
-	const usageFunction = findEnclosingFunction(usageNode);
-	if (!usageFunction || usageFunction === effectCallback) return usageNode;
-	return findSingleDirectInvocation(usageFunction, effectCallback, context) ?? usageNode;
-};
-const resolveSingleAssignedCleanupFunction = (expression, usage, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	const initializer = symbol?.initializer ? stripParenExpression(symbol.initializer) : null;
-	if (!symbol || symbol.kind !== "let" && symbol.kind !== "var" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier || !isNodeOfType(initializer, "Literal") || initializer.value !== null || symbol.scope.symbols.filter((candidate) => candidate.name === symbol.name).length !== 1) return null;
-	const assignmentReferences = symbol.references.filter((reference) => isWithinAssignmentTarget(reference.identifier));
-	if (assignmentReferences.length !== 1) return null;
-	const assignmentReference = assignmentReferences[0];
-	const assignmentTarget = findTransparentExpressionRoot(assignmentReference.identifier);
-	const assignmentNode = assignmentTarget.parent;
-	if (!isNodeOfType(assignmentNode, "AssignmentExpression") || assignmentNode.operator !== "=" || assignmentNode.left !== assignmentTarget || findEnclosingFunction(assignmentNode) !== findEnclosingFunction(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [assignmentNode], context)) return null;
-	const assignedValue = stripParenExpression(assignmentNode.right);
-	return isFunctionLike$1(assignedValue) ? assignedValue : null;
-};
-const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visitedFunctions = /* @__PURE__ */ new Set()) => {
-	if (!isFunctionLike$1(cleanupFunction) || visitedFunctions.has(cleanupFunction)) return false;
-	visitedFunctions.add(cleanupFunction);
-	let didCleanupFunctionMatch = false;
-	walkAst(cleanupFunction.body, (cleanupChild) => {
-		if (didCleanupFunctionMatch) return false;
-		if (cleanupChild !== cleanupFunction.body && isFunctionLike$1(cleanupChild) && !isSynchronousIteratorCallback(cleanupChild)) return false;
-		if (doesReleaseCallMatchUsage(cleanupChild, usage, context)) {
-			didCleanupFunctionMatch = true;
-			return false;
-		}
-		const helperCall = isNodeOfType(cleanupChild, "ChainExpression") ? cleanupChild.expression : cleanupChild;
-		if (!isNodeOfType(helperCall, "CallExpression")) return;
-		const stableHelperFunction = resolveStableValue(helperCall.callee, context);
-		const helperFunction = isNodeOfType(stableHelperFunction, "Identifier") ? resolveSingleAssignedCleanupFunction(stableHelperFunction, usage, context) : stableHelperFunction;
-		if (helperFunction && isFunctionLike$1(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context, visitedFunctions)) {
-			didCleanupFunctionMatch = true;
-			return false;
-		}
+const cleanupReturnRunsAfterUsage = (returnStatement, usages) => {
+	if (returnStatement.argument && isCleanupReturningSubscribeLikeCallExpression(returnStatement.argument)) return true;
+	const returnStart = getRangeStart(returnStatement);
+	if (returnStart === null) return true;
+	return usages.some((usage) => {
+		const usageStart = getRangeStart(usage.node);
+		return usageStart === null || usageStart < returnStart;
 	});
-	return didCleanupFunctionMatch;
 };
-const effectHasCleanupForUsage = (callback, usage, context) => {
+const effectHasCleanupReturn = (callback, usages) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	if (usage.kind === "subscribe" && findEnclosingFunction(usage.node) === callback && doesResourceResultEscape(usage.node, true) && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
-	if (!isNodeOfType(callback.body, "BlockStatement")) return callback.body === usage.node && isCleanupReturningSubscribeLikeCallExpression(callback.body);
-	const matchingCleanupReturns = [];
+	if (!isNodeOfType(callback.body, "BlockStatement")) return isCleanupReturningSubscribeLikeCallExpression(callback.body);
+	const cleanupBindings = collectCleanupBindings(callback);
+	let didFindCleanupReturn = false;
 	walkInsideStatementBlocks(callback.body, (child) => {
+		if (didFindCleanupReturn) return;
 		if (!isNodeOfType(child, "ReturnStatement")) return;
-		const returnStart = getRangeStart(child);
-		const usageStart = getRangeStart(usage.node);
-		if (returnStart !== null && usageStart !== null && returnStart < usageStart) return;
-		const returnedValue = child.argument ? stripParenExpression(child.argument) : null;
-		if (!returnedValue) return;
-		if (usage.kind === "subscribe" && (returnedValue === usage.node || getRangeStart(returnedValue) !== null && getRangeStart(returnedValue) === getRangeStart(usage.node)) && isCleanupReturningSubscribeLikeCallExpression(returnedValue)) {
-			matchingCleanupReturns.push(child);
-			return;
-		}
-		if (usage.kind === "subscribe" && isNodeOfType(returnedValue, "Identifier") && usage.handleKey !== null && resolveExpressionKey$1(returnedValue, context) === usage.handleKey && isCleanupReturningSubscribeLikeCallExpression(usage.node)) {
-			matchingCleanupReturns.push(child);
-			return;
-		}
-		if (isNodeOfType(returnedValue, "Identifier")) {
-			if (returnedValue.name === "undefined" && context.scopes.isGlobalReference(returnedValue)) return;
-			const returnedKey = resolveExpressionKey$1(returnedValue, context);
-			if (usage.handleKey !== null && returnedKey === usage.handleKey) return;
-			if (!context.scopes.symbolFor(returnedValue)?.initializer) return;
-		}
-		const cleanupFunction = resolveStableValue(returnedValue, context);
-		if (!cleanupFunction || !isFunctionLike$1(cleanupFunction)) return;
-		if (doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context)) matchingCleanupReturns.push(child);
+		if (!cleanupReturnRunsAfterUsage(child, usages)) return;
+		if (isCleanupReturn(child.argument, cleanupBindings.cleanupFunctionNames, cleanupBindings.subscriptionNames, { allowOpaqueReturn: true })) didFindCleanupReturn = true;
 	});
-	return doMatchingNodesCoverEveryPathAfterUsage(resolveCleanupPathAnchor(usage.node, callback, context), matchingCleanupReturns, context);
-};
-const findFirstUsageWithoutCleanup = (callback, usages, context) => {
-	for (const usage of usages) if (!effectHasCleanupForUsage(callback, usage, context)) return usage;
-	return null;
-};
-const isLocalAbortControllerExpression = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "NewExpression") && isNodeOfType(unwrappedExpression.callee, "Identifier") && unwrappedExpression.callee.name === "AbortController") return true;
-	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return isLocalAbortControllerExpression(unwrappedExpression.object, context, visitedSymbolIds);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return false;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	if (symbol.initializer) return isLocalAbortControllerExpression(symbol.initializer, context, visitedSymbolIds);
-	const bindingProperty = symbol.bindingIdentifier.parent;
-	const bindingPattern = bindingProperty?.parent;
-	const variableDeclarator = bindingPattern?.parent;
-	return Boolean(isNodeOfType(bindingProperty, "Property") && isNodeOfType(bindingPattern, "ObjectPattern") && isNodeOfType(variableDeclarator, "VariableDeclarator") && variableDeclarator.init && isLocalAbortControllerExpression(variableDeclarator.init, context, visitedSymbolIds));
+	return didFindCleanupReturn;
 };
-const isSelfReleasingListenerOptionProperty = (property, context) => {
+const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
+const isSelfReleasingListenerOptionProperty = (property) => {
 	if (!isNodeOfType(property, "Property")) return false;
 	const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : isNodeOfType(property.key, "Literal") ? property.key.value : null;
-	if (keyName === "signal") return !isLocalAbortControllerExpression(property.value, context);
+	if (keyName === "signal") return true;
 	if (keyName !== "once") return false;
 	return isNodeOfType(property.value, "Literal") && property.value.value === true;
 };
-const hasSelfReleasingListenerOptions = (node, context) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some((property) => isSelfReleasingListenerOptionProperty(property, context)));
+const hasSelfReleasingListenerOptions = (node) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some(isSelfReleasingListenerOptionProperty));
 const PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB = new Map([
 	["addEventListener", new Set(["removeEventListener", "abort"])],
 	["addListener", new Set([
@@ -9099,185 +8806,85 @@ const UNIVERSAL_RELEASE_VERB_NAMES = new Set([
 	"teardown"
 ]);
 const SOCKET_RELEASE_VERB_NAMES = new Set(["close"]);
+const INTERVAL_RELEASE_VERB_NAMES = new Set(["clearInterval"]);
 const getReleaseVerbName = (node) => {
+	if (!isReleaseLikeCall(node, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return null;
 	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
 	if (!isNodeOfType(callNode, "CallExpression")) return null;
 	const callee = isNodeOfType(callNode.callee, "ChainExpression") ? callNode.callee.expression : callNode.callee;
-	if (isNodeOfType(callee, "Identifier")) return TIMER_CLEANUP_CALLEE_NAMES.has(callee.name) || GLOBAL_RELEASE_METHOD_NAMES.has(callee.name) || UNIVERSAL_RELEASE_VERB_NAMES.has(callee.name) ? callee.name : null;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-		const methodName = callee.property.name;
-		return GLOBAL_RELEASE_METHOD_NAMES.has(methodName) || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(methodName) || methodName === "on" ? methodName : null;
-	}
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
 	return null;
 };
-const doesReleaseCallMatchUsage = (node, usage, context) => {
-	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	const callee = isNodeOfType(callNode.callee, "ChainExpression") ? callNode.callee.expression : callNode.callee;
-	if (usage.kind === "timer") {
-		const expectedCleanupName = usage.registrationVerbName === "setInterval" ? "clearInterval" : "clearTimeout";
-		if (!isNodeOfType(callee, "Identifier") || !TIMER_CLEANUP_CALLEE_NAMES.has(callee.name) || callee.name !== expectedCleanupName) return false;
-		if (usage.handleKey !== null && resolveExpressionKey$1(callNode.arguments?.[0], context) === usage.handleKey) return true;
-		const collectionKey = findContainingCollectionKey(usage.node, context);
-		return collectionKey !== null && collectionKey === resolveIteratorCollectionKey(callNode.arguments?.[0], context);
-	}
-	if (isNodeOfType(callee, "Identifier") && usage.kind === "subscribe" && usage.handleKey !== null && resolveExpressionKey$1(callee, context) === usage.handleKey && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
-	const releaseVerbName = getReleaseVerbName(callNode);
-	if (!releaseVerbName) return false;
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
-	const releaseReceiverKey = resolveExpressionKey$1(callee.object, context);
-	if (usage.kind === "socket") return usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (SOCKET_RELEASE_VERB_NAMES.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName));
-	if (usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub" || releaseVerbName === "close" || releaseVerbName === "unwatch" || releaseVerbName === "unlisten" || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(releaseVerbName))) return true;
-	if (releaseVerbName === "abort" && releaseReceiverKey === getListenerAbortControllerKey(usage, context)) return true;
-	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) return false;
-	const pairedVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
-	if (!pairedVerbNames || !matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return false;
-	const releaseEventKey = resolveExpressionKey$1(callNode.arguments?.[0], context);
-	if (usage.eventKey !== null && releaseEventKey !== null && usage.eventKey !== releaseEventKey) {
-		const usageIteratorCollectionKey = isNodeOfType(usage.node, "CallExpression") ? resolveIteratorCollectionKey(usage.node.arguments?.[0], context) : null;
-		const releaseIteratorCollectionKey = resolveIteratorCollectionKey(callNode.arguments?.[0], context);
-		if (usageIteratorCollectionKey === null || usageIteratorCollectionKey !== releaseIteratorCollectionKey) return false;
-	}
-	if (releaseVerbName === "on") {
-		const handlerArgument = callNode.arguments?.[1];
-		return isNodeOfType(handlerArgument, "Literal") && handlerArgument.value === null;
-	}
-	if (releaseVerbName === "removeEventListener" || releaseVerbName === "removeListener" || releaseVerbName === "off") {
-		const releaseHandler = callNode.arguments?.[1];
-		if (!releaseHandler) return releaseVerbName === "off";
-		return usage.handlerKey !== null && resolveExpressionKey$1(releaseHandler, context) === usage.handlerKey;
-	}
-	if (releaseVerbName === "unobserve" && usage.eventKey !== null) return releaseEventKey === usage.eventKey;
-	return true;
-};
 const matchesPairedReleaseVerb = (releaseVerbName, pairedVerbNames) => pairedVerbNames.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName);
-const isReturnedEffectCleanupFunction = (functionNode) => {
-	let currentNode = functionNode;
-	let parentNode = currentNode.parent;
-	while (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	if (!isNodeOfType(parentNode, "ReturnStatement") || parentNode.argument !== currentNode) return false;
-	const effectCallback = findEnclosingFunction(parentNode);
-	const effectCall = effectCallback?.parent;
-	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isHookCall$2(effectCall, CLEANUP_EFFECT_HOOK_NAMES));
-};
-const isPotentiallyReachableFunction = (functionNode, context) => {
-	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode)) return true;
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
-	if (!bindingIdentifier) return false;
-	const symbol = context.scopes.symbolFor(bindingIdentifier);
-	if (!symbol) return false;
-	return symbol.references.some((reference) => findEnclosingFunction(reference.identifier) !== functionNode);
-};
-const isReleaseReachableForUsage = (releaseNode, usage, context) => {
-	if (!isNodeReachableWithinFunction(releaseNode, context)) return false;
-	const releaseFunction = findEnclosingFunction(releaseNode);
-	if (!releaseFunction) return true;
-	if (releaseFunction === findEnclosingFunction(usage.node)) return true;
-	return isPotentiallyReachableFunction(releaseFunction, context);
-};
-const fileContainsReleaseForUsage = (usage, context) => {
-	let programNode = usage.node;
-	while (programNode.parent) programNode = programNode.parent;
-	let didFindRelease = false;
-	walkAst(programNode, (child) => {
-		if (didFindRelease) return false;
-		if (doesReleaseCallMatchUsage(child, usage, context) && isReleaseReachableForUsage(child, usage, context)) {
-			didFindRelease = true;
+const bodyContainsPairedReleaseCall = (body, pairedVerbNames) => {
+	let didFindPairedRelease = false;
+	walkAst(body, (child) => {
+		if (didFindPairedRelease) return false;
+		if (child !== body && isFunctionLike$1(child)) return false;
+		const releaseVerbName = getReleaseVerbName(child);
+		if (releaseVerbName !== null && matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) {
+			didFindPairedRelease = true;
 			return false;
 		}
 	});
-	return didFindRelease;
+	return didFindPairedRelease;
 };
-const isUseSyncExternalStoreSubscribeFunction = (functionNode, context) => {
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
-	if (!bindingIdentifier) return false;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	const isSubscribeBinding = (candidateBinding) => {
-		const symbol = context.scopes.symbolFor(candidateBinding);
-		if (!symbol || visitedSymbolIds.has(symbol.id) || symbol.references.length === 0) return false;
-		visitedSymbolIds.add(symbol.id);
-		return symbol.references.every((reference) => {
-			const referenceRoot = findTransparentExpressionRoot(reference.identifier);
-			const referenceParent = referenceRoot.parent;
-			if (isNodeOfType(referenceParent, "CallExpression") && referenceParent.arguments?.[0] === referenceRoot) return isReactApiCall(referenceParent, "useSyncExternalStore", context.scopes);
-			const aliasDeclaration = referenceParent?.parent;
-			return Boolean(isNodeOfType(referenceParent, "VariableDeclarator") && referenceParent.init === referenceRoot && isNodeOfType(referenceParent.id, "Identifier") && isNodeOfType(aliasDeclaration, "VariableDeclaration") && aliasDeclaration.kind === "const" && isSubscribeBinding(referenceParent.id));
-		});
-	};
-	return isSubscribeBinding(bindingIdentifier);
+const fileReleaseVerbNamesCache = /* @__PURE__ */ new WeakMap();
+const collectFileReleaseVerbNames = (anyNode) => {
+	let programNode = anyNode;
+	while (programNode.parent) programNode = programNode.parent;
+	const cached = fileReleaseVerbNamesCache.get(programNode);
+	if (cached) return cached;
+	const releaseVerbNames = /* @__PURE__ */ new Set();
+	walkAst(programNode, (child) => {
+		const releaseVerbName = getReleaseVerbName(child);
+		if (releaseVerbName !== null) releaseVerbNames.add(releaseVerbName);
+	});
+	fileReleaseVerbNamesCache.set(programNode, releaseVerbNames);
+	return releaseVerbNames;
 };
-const doesResourceResultEscape = (resourceNode, allowConciseReturnEscape) => {
-	let currentNode = resourceNode;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode) return true;
-		if (isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode && allowConciseReturnEscape) return true;
-		if (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
-			currentNode = parentNode;
-			parentNode = currentNode.parent;
-			continue;
-		}
-		return false;
-	}
+const fileContainsPairedReleaseCall = (registrationCall, registrationVerbName) => {
+	const fileReleaseVerbNames = collectFileReleaseVerbNames(registrationCall);
+	const pairedVerbNames = PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(registrationVerbName);
+	if (!pairedVerbNames) return fileReleaseVerbNames.size > 0;
+	for (const releaseVerbName of fileReleaseVerbNames) if (matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return true;
 	return false;
 };
-const findRetainedFunctionLeak = (retainedFunction, context) => {
+const findRetainedFunctionLeak = (retainedFunction) => {
 	if (!isFunctionLike$1(retainedFunction)) return null;
 	const body = retainedFunction.body;
 	if (!body) return null;
+	const conciseReturnValue = isNodeOfType(body, "BlockStatement") ? null : body;
 	let leak = null;
-	const allowConciseReturnEscape = !isInlineRetainedHandlerFunction(retainedFunction, context);
-	const isExternalStoreSubscribeFunction = isUseSyncExternalStoreSubscribeFunction(retainedFunction, context);
-	const hasReleaseForUsage = (usage) => isExternalStoreSubscribeFunction ? effectHasCleanupForUsage(retainedFunction, usage, context) : fileContainsReleaseForUsage(usage, context);
 	walkAst(body, (child) => {
 		if (leak !== null) return false;
 		if (isFunctionLike$1(child)) return false;
-		if (isSocketConstruction(child) && !doesResourceResultEscape(child, false)) {
-			const socketUsage = {
+		if (child === conciseReturnValue && isNodeOfType(child, "CallExpression")) return;
+		if (isSocketConstruction(child) && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, SOCKET_RELEASE_VERB_NAMES)) {
+			leak = {
 				kind: "socket",
 				node: child,
-				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: null,
-				eventKey: null,
-				handlerKey: null
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
 			};
-			if (!hasReleaseForUsage(socketUsage)) {
-				leak = socketUsage;
-				return false;
-			}
+			return false;
 		}
 		if (!isNodeOfType(child, "CallExpression")) return;
-		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
-			const timerUsage = {
+		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, INTERVAL_RELEASE_VERB_NAMES)) {
+			leak = {
 				kind: "timer",
 				node: child,
-				resourceName: "setInterval",
-				handleKey: findAssignedResourceKey(child, context),
-				receiverKey: null,
-				registrationVerbName: "setInterval",
-				eventKey: null,
-				handlerKey: null
+				resourceName: "setInterval"
 			};
-			if (!hasReleaseForUsage(timerUsage)) {
-				leak = timerUsage;
-				return false;
-			}
+			return false;
 		}
-		if (isSubscribeOrObserveCall(child) && !doesResourceResultEscape(child, allowConciseReturnEscape)) {
-			const registrationDetails = getCallRegistrationDetails(child, context);
-			const subscriptionUsage = {
+		if (isSubscribeOrObserveCall(child) && isResultDiscardedCall(child)) {
+			const registrationVerbName = isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") ? child.callee.property.name : "subscribe";
+			if (!hasSelfReleasingListenerOptions(child) && !fileContainsPairedReleaseCall(child, registrationVerbName)) leak = {
 				kind: "subscribe",
 				node: child,
-				resourceName: registrationDetails.registrationVerbName ?? "subscribe",
-				handleKey: findAssignedResourceKey(child, context),
-				...registrationDetails
+				resourceName: registrationVerbName
 			};
-			if (!hasSelfReleasingListenerOptions(child, context) && !hasReleaseForUsage(subscriptionUsage)) leak = subscriptionUsage;
 			return false;
 		}
 	});
@@ -9289,26 +8896,6 @@ const isRetainedComponentScopeFunction = (functionNode) => {
 	if (!isNodeOfType(functionNode.parent, "VariableDeclarator")) return false;
 	return enclosingComponentOrHookName(functionNode) !== null;
 };
-const isDirectJsxEventHandlerValue = (expression) => {
-	const expressionRoot = findTransparentExpressionRoot(expression);
-	const expressionContainer = expressionRoot.parent;
-	return isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === expressionRoot && isEventHandlerAttribute(expressionContainer.parent);
-};
-const isInlineRetainedHandlerFunction = (functionNode, context) => {
-	if (!isFunctionLike$1(functionNode)) return false;
-	const functionRoot = findTransparentExpressionRoot(functionNode);
-	const callbackCall = functionRoot.parent;
-	if (isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments?.[0] === functionRoot && isHookCall$2(callbackCall, "useCallback") && isDirectJsxEventHandlerValue(callbackCall)) return true;
-	const parentNode = functionNode.parent;
-	if (isDirectJsxEventHandlerValue(functionNode)) return true;
-	if (!isNodeOfType(parentNode, "Property") || parentNode.value !== functionNode || parentNode.computed) return false;
-	const propertyName = getStaticPropertyKeyName(parentNode);
-	if (!propertyName || !/^on[A-Z]/.test(propertyName)) return false;
-	const objectExpression = parentNode.parent;
-	if (!isNodeOfType(objectExpression, "ObjectExpression")) return false;
-	const objectParent = objectExpression.parent;
-	return (isNodeOfType(objectParent, "CallExpression") && objectParent.arguments.some((argument) => argument === objectExpression) || isNodeOfType(objectParent, "JSXExpressionContainer")) && findRenderPhaseComponentOrHook(parentNode, context.scopes) !== null;
-};
 const effectNeedsCleanup = defineRule({
 	id: "effect-needs-cleanup",
 	title: "Effect subscription or timer never cleaned up",
@@ -9317,8 +8904,7 @@ const effectNeedsCleanup = defineRule({
 	recommendation: "Return a cleanup function that stops the subscription or timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` or `clearTimeout(id)` for timers, `return () => observer.disconnect()` for observers, `return () => socket.close()` for connections, or `return unsubscribe` if the subscribe call already gave you one.",
 	create: (context) => {
 		const reportRetainedLeak = (retainedFunction) => {
-			if (!isPotentiallyReachableFunction(retainedFunction, context)) return;
-			const leak = findRetainedFunctionLeak(retainedFunction, context);
+			const leak = findRetainedFunctionLeak(retainedFunction);
 			if (!leak) return;
 			const resourceNoun = RESOURCE_NOUN_BY_KIND[leak.kind];
 			context.report({
@@ -9330,31 +8916,30 @@ const effectNeedsCleanup = defineRule({
 			CallExpression(node) {
 				if (isHookCall$2(node, "useCallback")) {
 					const retainedCallback = getEffectCallback(node);
-					if (retainedCallback && !isInlineRetainedHandlerFunction(retainedCallback, context)) reportRetainedLeak(retainedCallback);
+					if (retainedCallback) reportRetainedLeak(retainedCallback);
 					return;
 				}
-				if (!isHookCall$2(node, CLEANUP_EFFECT_HOOK_NAMES)) return;
+				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 				const callback = getEffectCallback(node);
 				if (!callback) return;
-				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback, context), context);
+				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback));
 				if (usages.length === 0) return;
-				const firstUsage = findFirstUsageWithoutCleanup(callback, usages, context);
-				if (!firstUsage) return;
+				if (effectHasCleanupReturn(callback, usages)) return;
+				const firstUsage = usages[0];
 				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
-				const hookName = getCalleeName$2(node) ?? "effect";
 				context.report({
 					node,
-					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without returning cleanup. Return a cleanup function so it does not leak after unmount.`
+					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in useEffect without returning cleanup. Return a cleanup function so it does not leak after unmount.`
 				});
 			},
 			FunctionDeclaration(node) {
 				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
 			},
 			ArrowFunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
 			},
 			FunctionExpression(node) {
-				if (isRetainedComponentScopeFunction(node) || isInlineRetainedHandlerFunction(node, context)) reportRetainedLeak(node);
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
 			}
 		};
 	}
@@ -10271,14 +9856,35 @@ const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 };
 const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
 //#endregion
+//#region src/plugin/utils/is-imported-from-non-react-module.ts
+const isImportedFromNonReactModule = (contextNode, localIdentifierName) => {
+	const importSource = getImportSourceForName(contextNode, localIdentifierName);
+	if (importSource === null) return false;
+	return !REACT_RUNTIME_MODULE_SOURCES.has(importSource);
+};
+//#endregion
+//#region src/plugin/utils/is-non-react-effect-event-callee.ts
+const resolvesToLocalNonImportBinding = (identifier, scopes) => {
+	const symbol = scopes.referenceFor(identifier)?.resolvedSymbol;
+	return Boolean(symbol && symbol.kind !== "import");
+};
+const isNonReactEffectEventCallee = (callee, contextNode, scopes) => {
+	if (isNodeOfType(callee, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.name) || resolvesToLocalNonImportBinding(callee, scopes);
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.object.name);
+	return false;
+};
+//#endregion
 //#region src/plugin/utils/symbol-has-react-use-effect-event-origin.ts
+const getUseEffectEventCalleeName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
 const symbolHasReactUseEffectEventOrigin = (symbol, scopes) => {
 	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	return isReactApiCall(initializer, "useEffectEvent", scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true
-	});
+	if (getUseEffectEventCalleeName(initializer.callee) !== "useEffectEvent") return false;
+	return !isNonReactEffectEventCallee(initializer.callee, initializer, scopes);
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps.ts
@@ -12738,6 +12344,20 @@ const collectHandlerReferencedNames = (root) => {
 	return names;
 };
 //#endregion
+//#region src/plugin/utils/get-function-binding-name.ts
+const getFunctionBindingIdentifier = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
+	const parent = functionNode.parent;
+	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === functionNode && isNodeOfType(parent.left, "Identifier")) return parent.left;
+	if (isNodeOfType(parent, "CallExpression")) {
+		const callParent = parent.parent;
+		if (isNodeOfType(callParent, "VariableDeclarator") && isNodeOfType(callParent.id, "Identifier")) return callParent.id;
+	}
+	return null;
+};
+const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(functionNode)?.name ?? null;
+//#endregion
 //#region src/plugin/rules/jotai/jotai-select-atom-in-render-body.ts
 const JOTAI_SELECT_ATOM_SOURCES = ["jotai/utils", "jotai"];
 const COMPONENT_NAME_PATTERN = /^[A-Z]/;
@@ -13882,7 +13502,7 @@ const jsHoistIntl = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/create-loop-aware-visitors.ts
-const ITERATOR_CALLBACK_METHOD_NAMES$1 = new Set([
+const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
 	"map",
 	"flatMap",
 	"forEach",
@@ -13901,7 +13521,7 @@ const isIteratorCallback = (node) => {
 	const parent = node.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
 	if (!parent.arguments.includes(node)) return false;
-	return isNodeOfType(parent.callee, "MemberExpression") && isNodeOfType(parent.callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES$1.has(parent.callee.property.name);
+	return isNodeOfType(parent.callee, "MemberExpression") && isNodeOfType(parent.callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES.has(parent.callee.property.name);
 };
 const createLoopAwareVisitors = (innerVisitors, options = {}) => {
 	let loopDepth = 0;
@@ -14130,7 +13750,7 @@ const findIndexedArrayObject = (callbackBody, indexParameterName) => {
 	});
 	return indexedArrayObject;
 };
-const unwrapChainExpression$3 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const unwrapChainExpression$2 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
 const LENGTH_EQUALITY_OPERATORS = new Set(["===", "=="]);
 const LENGTH_MISMATCH_OPERATORS = new Set([
 	"!==",
@@ -14142,17 +13762,17 @@ const LENGTH_MISMATCH_OPERATORS = new Set([
 ]);
 const LENGTH_ANY_COMPARISON_OPERATORS = new Set([...LENGTH_EQUALITY_OPERATORS, ...LENGTH_MISMATCH_OPERATORS]);
 const isLengthComparison = (candidate, receiverArray, indexedArray, operators) => {
-	const binaryGuard = unwrapChainExpression$3(candidate);
+	const binaryGuard = unwrapChainExpression$2(candidate);
 	if (!isNodeOfType(binaryGuard, "BinaryExpression")) return false;
 	if (!operators.has(binaryGuard.operator)) return false;
-	const leftSide = unwrapChainExpression$3(binaryGuard.left);
-	const rightSide = unwrapChainExpression$3(binaryGuard.right);
+	const leftSide = unwrapChainExpression$2(binaryGuard.left);
+	const rightSide = unwrapChainExpression$2(binaryGuard.right);
 	if (!isMemberProperty(leftSide, "length")) return false;
 	if (!isMemberProperty(rightSide, "length")) return false;
-	const leftLengthObject = unwrapChainExpression$3(leftSide.object);
-	const rightLengthObject = unwrapChainExpression$3(rightSide.object);
-	const normalizedReceiver = unwrapChainExpression$3(receiverArray);
-	const normalizedIndexed = unwrapChainExpression$3(indexedArray);
+	const leftLengthObject = unwrapChainExpression$2(leftSide.object);
+	const rightLengthObject = unwrapChainExpression$2(rightSide.object);
+	const normalizedReceiver = unwrapChainExpression$2(receiverArray);
+	const normalizedIndexed = unwrapChainExpression$2(indexedArray);
 	const matchesReceiverThenIndexed = areExpressionsStructurallyEqual(leftLengthObject, normalizedReceiver) && areExpressionsStructurallyEqual(rightLengthObject, normalizedIndexed);
 	const matchesIndexedThenReceiver = areExpressionsStructurallyEqual(leftLengthObject, normalizedIndexed) && areExpressionsStructurallyEqual(rightLengthObject, normalizedReceiver);
 	return matchesReceiverThenIndexed || matchesIndexedThenReceiver;
@@ -14239,18 +13859,18 @@ const LENGTH_PRESERVING_METHOD_NAMES = new Set([
 	"toReversed"
 ]);
 const peelLengthPreservingDerivation = (expression) => {
-	let current = unwrapChainExpression$3(expression);
+	let current = unwrapChainExpression$2(expression);
 	for (;;) {
 		if (isNodeOfType(current, "ArrayExpression") && current.elements?.length === 1 && isNodeOfType(current.elements[0], "SpreadElement")) {
-			current = unwrapChainExpression$3(current.elements[0].argument);
+			current = unwrapChainExpression$2(current.elements[0].argument);
 			continue;
 		}
 		if (isNodeOfType(current, "CallExpression")) {
-			const callee = unwrapChainExpression$3(current.callee);
+			const callee = unwrapChainExpression$2(current.callee);
 			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-				const calleeObject = unwrapChainExpression$3(callee.object);
+				const calleeObject = unwrapChainExpression$2(callee.object);
 				if (isNodeOfType(calleeObject, "Identifier") && calleeObject.name === "Array" && callee.property.name === "from" && current.arguments?.length === 1) {
-					current = unwrapChainExpression$3(current.arguments[0]);
+					current = unwrapChainExpression$2(current.arguments[0]);
 					continue;
 				}
 				if (LENGTH_PRESERVING_METHOD_NAMES.has(callee.property.name)) {
@@ -14295,7 +13915,7 @@ const resolveComparedArraySource = (expression, scopeNode) => {
 		const initializer = findConstInitializer(current.name, scopeNode);
 		if (!initializer) return current;
 		const peeledInitializer = peelLengthPreservingDerivation(initializer);
-		if (peeledInitializer === unwrapChainExpression$3(initializer)) return current;
+		if (peeledInitializer === unwrapChainExpression$2(initializer)) return current;
 		current = peeledInitializer;
 	}
 	return current;
@@ -16311,190 +15931,6 @@ const memoStatusForJsxOpeningName = (registry, openingName) => {
 	return registry.get(openingName.name) ?? "unknown";
 };
 //#endregion
-//#region src/plugin/utils/unwrap-react-hoc-function.ts
-/**
-* Resolves a `VariableDeclarator.init` (or any expression) to the inline
-* function expression it binds, seeing through chains of `memo` /
-* `forwardRef` / `React.memo` / `React.forwardRef` wrappers:
-*
-*   `() => {}`                          → the arrow
-*   `memo(function Foo() {})`           → the named function expression
-*   `React.memo(forwardRef(() => {}))`  → the inner arrow
-*   `memo(SomeIdentifier)`              → the identifier's same-file function when scopes are provided
-*
-* Component-shaped rules that previously gated on a direct function init
-* (via `isComponentAssignment`) use this so memo-wrapped components are
-* not silently skipped.
-*/
-const resolveReactHocFunction = (node, scopes, visitedSymbolIds) => {
-	if (!node) return null;
-	const current = stripParenExpression(node);
-	if (isInlineFunctionExpression(current)) return current;
-	if (isNodeOfType(current, "Identifier") && scopes) {
-		const symbol = scopes.symbolFor(current);
-		if (!symbol || visitedSymbolIds.has(symbol.id) || !symbol.initializer || symbol.kind !== "const" && symbol.kind !== "function") return null;
-		if (symbol.kind === "const" && (!isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier)) return null;
-		visitedSymbolIds.add(symbol.id);
-		return resolveReactHocFunction(symbol.initializer, scopes, visitedSymbolIds);
-	}
-	if (isNodeOfType(current, "CallExpression")) {
-		const calleeName = flattenCalleeName(current.callee);
-		if (!calleeName || !REACT_HOC_NAMES.has(calleeName)) return null;
-		const firstArgument = current.arguments[0];
-		if (!firstArgument || isNodeOfType(firstArgument, "SpreadElement")) return null;
-		return resolveReactHocFunction(firstArgument, scopes, visitedSymbolIds);
-	}
-	return null;
-};
-const unwrapReactHocFunction = (node, scopes) => resolveReactHocFunction(node, scopes, /* @__PURE__ */ new Set());
-//#endregion
-//#region src/plugin/utils/build-same-file-jsx-slot-prop-registry.ts
-const REACT_SLOT_TYPE_NAMES = new Set(["ReactNode", "ReactElement"]);
-const unwrapTopLevelDeclaration = (statement) => {
-	if (isNodeOfType(statement, "ExportNamedDeclaration")) return statement.declaration;
-	if (isNodeOfType(statement, "ExportDefaultDeclaration")) return statement.declaration;
-	return statement;
-};
-const buildReactSlotTypeEnvironment = (program) => {
-	const reactSlotTypeBindings = /* @__PURE__ */ new Set();
-	const reactNamespaceBindings = /* @__PURE__ */ new Set();
-	const reactJsxNamespaceBindings = /* @__PURE__ */ new Set();
-	const nonReactJsxNamespaceBindings = /* @__PURE__ */ new Set();
-	const sameFileTypeDeclarations = /* @__PURE__ */ new Map();
-	let hasLocalJsxNamespace = false;
-	if (!isNodeOfType(program, "Program")) return {
-		reactSlotTypeBindings,
-		reactNamespaceBindings,
-		reactJsxNamespaceBindings,
-		nonReactJsxNamespaceBindings,
-		sameFileTypeDeclarations,
-		hasLocalJsxNamespace
-	};
-	for (const statement of program.body) {
-		if (isNodeOfType(statement, "ImportDeclaration")) {
-			const isReactImport = statement.source.value === "react";
-			for (const specifier of statement.specifiers) {
-				if (isReactImport && (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier"))) {
-					reactNamespaceBindings.add(specifier.local.name);
-					continue;
-				}
-				if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-				const importedName = getImportedName(specifier);
-				if (!importedName) continue;
-				if (isReactImport && REACT_SLOT_TYPE_NAMES.has(importedName)) reactSlotTypeBindings.add(specifier.local.name);
-				if (importedName === "JSX") if (isReactImport) reactJsxNamespaceBindings.add(specifier.local.name);
-				else nonReactJsxNamespaceBindings.add(specifier.local.name);
-			}
-			continue;
-		}
-		const declaration = unwrapTopLevelDeclaration(statement);
-		if (!declaration) continue;
-		if ((isNodeOfType(declaration, "TSInterfaceDeclaration") || isNodeOfType(declaration, "TSTypeAliasDeclaration")) && isNodeOfType(declaration.id, "Identifier")) sameFileTypeDeclarations.set(declaration.id.name, declaration);
-		if (isNodeOfType(declaration, "TSModuleDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === "JSX") hasLocalJsxNamespace = true;
-	}
-	return {
-		reactSlotTypeBindings,
-		reactNamespaceBindings,
-		reactJsxNamespaceBindings,
-		nonReactJsxNamespaceBindings,
-		sameFileTypeDeclarations,
-		hasLocalJsxNamespace
-	};
-};
-const isJsxElementTypeName = (typeName, environment) => {
-	if (!isNodeOfType(typeName, "TSQualifiedName")) return false;
-	if (!isNodeOfType(typeName.right, "Identifier") || typeName.right.name !== "Element") return false;
-	if (isNodeOfType(typeName.left, "Identifier")) {
-		const namespaceName = typeName.left.name;
-		if (environment.reactNamespaceBindings.has(namespaceName)) return true;
-		if (environment.reactJsxNamespaceBindings.has(namespaceName)) return true;
-		if (environment.nonReactJsxNamespaceBindings.has(namespaceName)) return false;
-		return namespaceName === "JSX" && !environment.hasLocalJsxNamespace;
-	}
-	return isNodeOfType(typeName.left, "TSQualifiedName") && isNodeOfType(typeName.left.left, "Identifier") && environment.reactNamespaceBindings.has(typeName.left.left.name) && isNodeOfType(typeName.left.right, "Identifier") && typeName.left.right.name === "JSX";
-};
-const isReactSlotType = (typeNode, environment, activeDeclarations) => {
-	if (isNodeOfType(typeNode, "TSUnionType")) return typeNode.types.some((unionMember) => isReactSlotType(unionMember, environment, activeDeclarations));
-	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
-	if (isJsxElementTypeName(typeNode.typeName, environment)) return true;
-	if (isNodeOfType(typeNode.typeName, "TSQualifiedName") && isNodeOfType(typeNode.typeName.left, "Identifier") && environment.reactNamespaceBindings.has(typeNode.typeName.left.name) && isNodeOfType(typeNode.typeName.right, "Identifier") && REACT_SLOT_TYPE_NAMES.has(typeNode.typeName.right.name)) return true;
-	if (!isNodeOfType(typeNode.typeName, "Identifier")) return false;
-	const typeName = typeNode.typeName.name;
-	const sameFileDeclaration = environment.sameFileTypeDeclarations.get(typeName);
-	if (sameFileDeclaration) {
-		if (!isNodeOfType(sameFileDeclaration, "TSTypeAliasDeclaration") || activeDeclarations.has(sameFileDeclaration)) return false;
-		activeDeclarations.add(sameFileDeclaration);
-		const isSlot = isReactSlotType(sameFileDeclaration.typeAnnotation, environment, activeDeclarations);
-		activeDeclarations.delete(sameFileDeclaration);
-		return isSlot;
-	}
-	return environment.reactSlotTypeBindings.has(typeName);
-};
-const getPropertyName = (property) => {
-	if (!isNodeOfType(property, "TSPropertySignature") || property.computed) return null;
-	if (isNodeOfType(property.key, "Identifier")) return property.key.name;
-	if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") return property.key.value;
-	return null;
-};
-const collectSlotPropertyNames = (propsType, environment, slotPropertyNames, activeDeclarations) => {
-	let members = null;
-	if (isNodeOfType(propsType, "TSTypeLiteral")) members = propsType.members;
-	if (isNodeOfType(propsType, "TSInterfaceDeclaration")) members = propsType.body.body;
-	if (members) {
-		for (const member of members) {
-			const propertyName = getPropertyName(member);
-			if (!propertyName || !isNodeOfType(member, "TSPropertySignature")) continue;
-			const annotation = member.typeAnnotation;
-			if (annotation && isNodeOfType(annotation, "TSTypeAnnotation") && isReactSlotType(annotation.typeAnnotation, environment, /* @__PURE__ */ new Set())) slotPropertyNames.add(propertyName);
-		}
-		return;
-	}
-	if (isNodeOfType(propsType, "TSIntersectionType")) {
-		for (const intersectionMember of propsType.types) collectSlotPropertyNames(intersectionMember, environment, slotPropertyNames, activeDeclarations);
-		return;
-	}
-	if (isNodeOfType(propsType, "TSTypeAliasDeclaration")) {
-		collectSlotPropertyNames(propsType.typeAnnotation, environment, slotPropertyNames, activeDeclarations);
-		return;
-	}
-	if (!isNodeOfType(propsType, "TSTypeReference") || !isNodeOfType(propsType.typeName, "Identifier")) return;
-	const declaration = environment.sameFileTypeDeclarations.get(propsType.typeName.name);
-	if (!declaration || activeDeclarations.has(declaration)) return;
-	activeDeclarations.add(declaration);
-	collectSlotPropertyNames(declaration, environment, slotPropertyNames, activeDeclarations);
-	activeDeclarations.delete(declaration);
-};
-const getMemoizedComponentPropsType = (initializer, scopes) => {
-	const componentFunction = unwrapReactHocFunction(initializer, scopes);
-	if (componentFunction) {
-		const firstParameter = componentFunction.params[0];
-		const annotation = firstParameter && "typeAnnotation" in firstParameter ? firstParameter.typeAnnotation : null;
-		if (annotation && isNodeOfType(annotation, "TSTypeAnnotation")) return annotation.typeAnnotation;
-	}
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return initializer.typeArguments?.params[0] ?? null;
-};
-const buildSameFileJsxSlotPropRegistry = (program, memoRegistry, scopes) => {
-	const registry = /* @__PURE__ */ new Map();
-	if (!isNodeOfType(program, "Program")) return registry;
-	const environment = buildReactSlotTypeEnvironment(program);
-	for (const statement of program.body) {
-		const declaration = unwrapTopLevelDeclaration(statement);
-		if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) continue;
-		for (const declarator of declaration.declarations) {
-			if (!isNodeOfType(declarator.id, "Identifier") || memoRegistry.get(declarator.id.name) !== "memoised" || !declarator.init) continue;
-			const componentSymbol = scopes.symbolFor(declarator.id);
-			if (!componentSymbol) continue;
-			const propsType = getMemoizedComponentPropsType(declarator.init, scopes);
-			if (!propsType) continue;
-			const slotPropertyNames = /* @__PURE__ */ new Set();
-			collectSlotPropertyNames(propsType, environment, slotPropertyNames, /* @__PURE__ */ new Set());
-			if (slotPropertyNames.size > 0) registry.set(componentSymbol.id, slotPropertyNames);
-		}
-	}
-	return registry;
-};
-//#endregion
 //#region src/plugin/utils/is-on-intrinsic-html-element.ts
 const isJsxAttributeOnIntrinsicHtmlElement = (attribute) => {
 	const openingElement = attribute.parent;
@@ -16768,11 +16204,9 @@ const jsxNoJsxAsProp = defineRule({
 	create: (context) => {
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		let memoRegistry = null;
-		let jsxSlotPropRegistry = null;
 		return {
 			Program(node) {
 				memoRegistry = buildSameFileMemoRegistry(node);
-				jsxSlotPropRegistry = buildSameFileJsxSlotPropRegistry(node, memoRegistry, context.scopes);
 			},
 			JSXAttribute(node) {
 				if (isTestlikeFile) return;
@@ -16780,8 +16214,6 @@ const jsxNoJsxAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
-				const openingSymbol = openingName && isNodeOfType(openingName, "JSXIdentifier") ? context.scopes.symbolFor(openingName) : null;
-				if (openingSymbol && isNodeOfType(node.name, "JSXIdentifier") && jsxSlotPropRegistry?.get(openingSymbol.id)?.has(node.name.name)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier") && isSlotPropName(node.name.name)) return;
 				if (!isInsideFunctionScope(node)) return;
 				const value = node.value;
@@ -20025,6 +19457,54 @@ const nextjsNoAElement = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/collect-effect-invoked-functions.ts
+const PROMISE_CHAIN_METHOD_NAMES$1 = new Set([
+	"then",
+	"catch",
+	"finally"
+]);
+const collectEffectInvokedFunctions = (effectCallback) => {
+	const invokedFunctions = new Set([effectCallback]);
+	const localFunctionBindings = /* @__PURE__ */ new Map();
+	const calledBindingNames = /* @__PURE__ */ new Set();
+	const pendingFunctions = [effectCallback];
+	const enqueue = (candidate) => {
+		const strippedCandidate = candidate ? stripParenExpression(candidate) : candidate;
+		if (!isFunctionLike$1(strippedCandidate) || invokedFunctions.has(strippedCandidate)) return;
+		invokedFunctions.add(strippedCandidate);
+		pendingFunctions.push(strippedCandidate);
+	};
+	const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
+	while (pendingFunctions.length > 0) {
+		const currentFunction = pendingFunctions.pop();
+		if (!currentFunction) break;
+		walkAst(currentFunction, (child) => {
+			if (child !== currentFunction && isFunctionLike$1(child)) {
+				if (isNodeOfType(child, "FunctionDeclaration") && isNodeOfType(child.id, "Identifier")) localFunctionBindings.set(child.id.name, child);
+				return false;
+			}
+			if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
+				const initializer = child.init ? stripParenExpression(child.init) : null;
+				if (isFunctionLike$1(initializer)) localFunctionBindings.set(child.id.name, initializer);
+				return;
+			}
+			if (!isNodeOfType(child, "CallExpression")) return;
+			const callee = stripParenExpression(child.callee);
+			if (isFunctionLike$1(callee)) {
+				enqueue(callee);
+				return;
+			}
+			if (isNodeOfType(callee, "Identifier")) {
+				calledBindingNames.add(callee.name);
+				return;
+			}
+			if (isPromiseChainCall(callee)) for (const callArgument of child.arguments ?? []) enqueue(callArgument);
+		});
+		for (const calledName of calledBindingNames) enqueue(localFunctionBindings.get(calledName));
+	}
+	return invokedFunctions;
+};
+//#endregion
 //#region src/plugin/utils/contains-fetch-call.ts
 const isFetchCall$1 = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
@@ -25151,7 +24631,7 @@ const isAsyncFunctionLike = (node) => {
 	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) return Boolean(node.async);
 	return false;
 };
-const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
+const SYNCHRONOUS_ITERATION_METHOD_NAMES$1 = new Set([
 	"forEach",
 	"map",
 	"filter",
@@ -25172,7 +24652,7 @@ const runsOnEffectDispatch = (functionNode) => {
 	if (parent.callee === functionNode) return true;
 	if (!(parent.arguments ?? []).some((argument) => argument === functionNode)) return false;
 	const callee = parent.callee;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.has(callee.property.name);
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES$1.has(callee.property.name);
 };
 const isTerminatingStatement = (statement) => isNodeOfType(statement, "BreakStatement") || isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "ContinueStatement");
 const analyzeBranchStatements = (branch, context) => analyzeStatementSequence(isNodeOfType(branch, "BlockStatement") ? branch.body ?? [] : [branch], context);
@@ -27805,14 +27285,14 @@ const hasDocumentClassListMutation = (node) => {
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-effect-event-handler.ts
 const hasEventLikeNode = (node) => findTriggeredSideEffectCalleeName(node) !== null || hasDocumentClassListMutation(node);
-const unwrapChainExpression$2 = (node) => {
+const unwrapChainExpression$1 = (node) => {
 	if (!node) return null;
 	if (isNodeOfType(node, "ChainExpression")) return node.expression;
 	return node;
 };
 const collectGuardExpressions = (node, into) => {
 	if (!node) return;
-	const unwrappedNode = unwrapChainExpression$2(node);
+	const unwrappedNode = unwrapChainExpression$1(node);
 	if (!unwrappedNode) return;
 	const rootIdentifierName = getRootIdentifierName(unwrappedNode);
 	if (rootIdentifierName) {
@@ -27843,7 +27323,7 @@ const isReturnOnlyStatement = (node) => {
 };
 const hasEventLikeRemainingStatements = (statements) => statements.some((statement) => !isNodeOfType(statement, "ReturnStatement") && hasEventLikeNode(statement));
 const doesGuardMatchDependency = (guardExpression, dependencyExpression) => {
-	const unwrappedDependencyExpression = unwrapChainExpression$2(dependencyExpression);
+	const unwrappedDependencyExpression = unwrapChainExpression$1(dependencyExpression);
 	if (!unwrappedDependencyExpression) return false;
 	if (areExpressionsStructurallyEqual(guardExpression.expression, unwrappedDependencyExpression)) return true;
 	return isNodeOfType(unwrappedDependencyExpression, "Identifier") && unwrappedDependencyExpression.name === guardExpression.rootIdentifierName;
@@ -27934,24 +27414,6 @@ const noEffectEventHandler = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-imported-from-non-react-module.ts
-const isImportedFromNonReactModule = (contextNode, localIdentifierName) => {
-	const importSource = getImportSourceForName(contextNode, localIdentifierName);
-	if (importSource === null) return false;
-	return !REACT_RUNTIME_MODULE_SOURCES.has(importSource);
-};
-//#endregion
-//#region src/plugin/utils/is-non-react-effect-event-callee.ts
-const resolvesToLocalNonImportBinding = (identifier, scopes) => {
-	const symbol = scopes.referenceFor(identifier)?.resolvedSymbol;
-	return Boolean(symbol && symbol.kind !== "import");
-};
-const isNonReactEffectEventCallee = (callee, contextNode, scopes) => {
-	if (isNodeOfType(callee, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.name) || resolvesToLocalNonImportBinding(callee, scopes);
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.object.name);
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-effect-event-in-deps.ts
 const createComponentBindingStackTracker = (callbacks) => {
 	const componentBindingStack = [];
@@ -29033,61 +28495,13 @@ const noEventTriggerState = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/resolve-expression-key.ts
-const resolveExpressionKey = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const symbol = context.scopes.symbolFor(unwrappedExpression);
-		if (!symbol) return context.scopes.isGlobalReference(unwrappedExpression) ? `global:${unwrappedExpression.name}` : null;
-		if (visitedSymbolIds.has(symbol.id)) return `symbol:${symbol.id}`;
-		visitedSymbolIds.add(symbol.id);
-		const bindingProperty = symbol.bindingIdentifier.parent;
-		const bindingPattern = bindingProperty?.parent;
-		const variableDeclarator = bindingPattern?.parent;
-		const bindingPropertyName = isNodeOfType(bindingProperty, "Property") ? getStaticPropertyKeyName(bindingProperty) : null;
-		if (bindingPropertyName && isNodeOfType(bindingPattern, "ObjectPattern") && isNodeOfType(variableDeclarator, "VariableDeclarator") && variableDeclarator.id === bindingPattern) {
-			const objectKey = resolveExpressionKey(variableDeclarator.init, context, visitedSymbolIds);
-			return objectKey ? `${objectKey}.${bindingPropertyName}` : `symbol:${symbol.id}`;
-		}
-		const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
-		if (symbol.kind === "const" && initializer && (isNodeOfType(initializer, "Identifier") || isNodeOfType(initializer, "MemberExpression"))) return resolveExpressionKey(initializer, context, visitedSymbolIds) ?? `symbol:${symbol.id}`;
-		return `symbol:${symbol.id}`;
-	}
-	if (isNodeOfType(unwrappedExpression, "MemberExpression") && !unwrappedExpression.computed) {
-		if (!isNodeOfType(unwrappedExpression.property, "Identifier")) return null;
-		const objectKey = resolveExpressionKey(unwrappedExpression.object, context, visitedSymbolIds);
-		return objectKey ? `${objectKey}.${unwrappedExpression.property.name}` : null;
-	}
-	if (isNodeOfType(unwrappedExpression, "ThisExpression")) return "this";
-	if (isNodeOfType(unwrappedExpression, "Literal") && (typeof unwrappedExpression.value === "string" || typeof unwrappedExpression.value === "number")) return `literal:${String(unwrappedExpression.value)}`;
-	if (isFunctionLike$1(unwrappedExpression)) {
-		const rangeStart = getRangeStart(unwrappedExpression);
-		return rangeStart === null ? null : `function:${rangeStart}`;
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/statement-always-exits.ts
-const statementAlwaysExits = (statement) => {
-	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement")) return true;
-	if (isNodeOfType(statement, "IfStatement")) return Boolean(statement.alternate && statementAlwaysExits(statement.consequent) && statementAlwaysExits(statement.alternate));
-	if (!isNodeOfType(statement, "BlockStatement")) return false;
-	return statement.body.some((childStatement) => statementAlwaysExits(childStatement));
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-fetch-in-effect.ts
 const IMPORT_INITIALIZER_TYPES = new Set([
 	"ImportSpecifier",
 	"ImportDefaultSpecifier",
 	"ImportNamespaceSpecifier"
 ]);
-const CANCELLATION_FLAG_NAME_PATTERN = /cancel|ignore/i;
-const PROMISE_CONTINUATION_METHOD_NAMES = new Set([
-	"then",
-	"catch",
-	"finally"
-]);
+const CANCELLATION_FLAG_NAME_PATTERN = /cancel/i;
 const isShadowedByLocalBinding = (identifier) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
 	const binding = findVariableInitializer(identifier, identifier.name);
@@ -29103,54 +28517,49 @@ const isRealFetchCall = (node) => {
 };
 const isXmlHttpRequestConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "XMLHttpRequest";
 const isNetworkRequest = (node) => isRealFetchCall(node) || isXmlHttpRequestConstruction(node);
-const resolveLocalFunction = (expression, context) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isFunctionLike$1(unwrappedExpression)) return unwrappedExpression;
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
-	const initializer = context.scopes.symbolFor(unwrappedExpression)?.initializer;
-	if (!initializer) return null;
-	const unwrappedInitializer = stripParenExpression(initializer);
-	return isFunctionLike$1(unwrappedInitializer) ? unwrappedInitializer : null;
+const containsNetworkRequest = (root) => {
+	let found = false;
+	walkAst(root, (child) => {
+		if (found) return false;
+		if (isNetworkRequest(child)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
 };
-const collectEffectAnalysisFunctions = (effectCallback, context) => {
-	const analysisFunctions = /* @__PURE__ */ new Set();
-	const pendingFunctions = [];
-	const enqueueFunction = (functionNode) => {
-		for (const invokedFunction of collectEffectInvokedFunctions(functionNode)) {
-			if (analysisFunctions.has(invokedFunction)) continue;
-			analysisFunctions.add(invokedFunction);
-			pendingFunctions.push(invokedFunction);
+const collectComponentScopeFunctionBindings = (componentScope, effectCallback) => {
+	const bindings = /* @__PURE__ */ new Map();
+	walkAst(componentScope, (child) => {
+		if (child === effectCallback) return false;
+		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
+			const initializer = child.init ? stripParenExpression(child.init) : null;
+			if (isFunctionLike$1(initializer)) bindings.set(child.id.name, initializer);
+			return;
 		}
-	};
-	enqueueFunction(effectCallback);
-	while (pendingFunctions.length > 0) {
-		const currentFunction = pendingFunctions.pop();
-		if (!currentFunction) break;
-		walkAst(currentFunction, (child) => {
-			if (child !== currentFunction && isFunctionLike$1(child)) return false;
-			if (!isNodeOfType(child, "CallExpression")) return;
-			const calledFunction = resolveLocalFunction(child.callee, context);
-			if (calledFunction) enqueueFunction(calledFunction);
-			for (const callArgument of child.arguments ?? []) {
-				const callbackFunction = resolveLocalFunction(callArgument, context);
-				if (callbackFunction) enqueueFunction(callbackFunction);
-			}
-		});
-	}
-	return analysisFunctions;
+		if (isNodeOfType(child, "FunctionDeclaration") && isNodeOfType(child.id, "Identifier")) bindings.set(child.id.name, child);
+	});
+	return bindings;
 };
-const collectNodesFromAnalysisFunctions = (analysisFunctions, predicate) => {
-	const nodes = [];
-	const seenNodes = /* @__PURE__ */ new Set();
-	for (const analysisFunction of analysisFunctions) walkAst(analysisFunction, (child) => {
-		if (child !== analysisFunction && isFunctionLike$1(child)) return false;
-		if (!seenNodes.has(child) && predicate(child)) {
-			seenNodes.add(child);
-			nodes.push(child);
+const containsNetworkRequestInEffect = (effectCallback) => {
+	const invokedFunctions = collectEffectInvokedFunctions(effectCallback);
+	for (const invokedFunction of invokedFunctions) if (containsNetworkRequest(invokedFunction)) return true;
+	const enclosingComponent = findEnclosingFunction(effectCallback);
+	if (!enclosingComponent) return false;
+	const scopeFunctions = collectComponentScopeFunctionBindings(enclosingComponent, effectCallback);
+	let found = false;
+	walkAst(effectCallback, (child) => {
+		if (found) return false;
+		if (child !== effectCallback && isFunctionLike$1(child) && invokedFunctions.has(child)) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier")) {
+			const scopeFunction = scopeFunctions.get(child.callee.name);
+			if (scopeFunction && containsNetworkRequest(scopeFunction)) {
+				found = true;
+				return false;
+			}
 		}
 	});
-	return nodes;
+	return found;
 };
 const findEffectCleanupFunction = (callback) => {
 	if (!isFunctionLike$1(callback)) return null;
@@ -29163,177 +28572,36 @@ const findEffectCleanupFunction = (callback) => {
 	});
 	return cleanup;
 };
-const collectEffectCancellationFlagKeys = (effectCallback, context) => {
-	const flagKeys = /* @__PURE__ */ new Set();
-	if (!isFunctionLike$1(effectCallback)) return flagKeys;
+const collectEffectCancellationFlagNames = (effectCallback) => {
+	const flagNames = /* @__PURE__ */ new Set();
+	if (!isFunctionLike$1(effectCallback)) return flagNames;
 	const body = effectCallback.body;
-	if (!isNodeOfType(body, "BlockStatement")) return flagKeys;
+	if (!isNodeOfType(body, "BlockStatement")) return flagNames;
 	for (const statement of body.body ?? []) {
 		if (!isNodeOfType(statement, "VariableDeclaration") || statement.kind !== "let") continue;
 		for (const declarator of statement.declarations ?? []) {
 			if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.id, "Identifier")) continue;
 			const initializer = declarator.init;
-			if (isNodeOfType(initializer, "Literal") && initializer.value === false && CANCELLATION_FLAG_NAME_PATTERN.test(declarator.id.name)) {
-				const flagKey = resolveExpressionKey(declarator.id, context);
-				if (flagKey) flagKeys.add(flagKey);
-			}
-		}
-	}
-	return flagKeys;
-};
-const resolveConstValue = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return unwrappedExpression;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return unwrappedExpression;
-	visitedSymbolIds.add(symbol.id);
-	return resolveConstValue(symbol.initializer, context, visitedSymbolIds);
-};
-const resolveRequestAbortControllerKey = (request, context) => {
-	if (isNodeOfType(request, "NewExpression")) {
-		const declarator = request.parent;
-		return isNodeOfType(declarator, "VariableDeclarator") && declarator.init === request ? resolveExpressionKey(declarator.id, context) : null;
-	}
-	if (!isNodeOfType(request, "CallExpression")) return null;
-	for (const requestArgument of request.arguments ?? []) {
-		const options = resolveConstValue(requestArgument, context);
-		if (!isNodeOfType(options, "ObjectExpression")) continue;
-		for (const property of options.properties ?? []) {
-			if (!isNodeOfType(property, "Property") || getStaticPropertyKeyName(property, { allowComputedString: true }) !== "signal") continue;
-			const signalKey = resolveExpressionKey(property.value, context);
-			return signalKey?.endsWith(".signal") ? signalKey.slice(0, -7) : null;
+			if (isNodeOfType(initializer, "Literal") && initializer.value === false && CANCELLATION_FLAG_NAME_PATTERN.test(declarator.id.name)) flagNames.add(declarator.id.name);
 		}
 	}
-	return null;
+	return flagNames;
 };
-const collectCleanupAbortedControllerKeys = (cleanup, context) => {
-	const controllerKeys = /* @__PURE__ */ new Set();
-	walkAst(cleanup, (child) => {
-		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "MemberExpression") && !child.callee.computed && isNodeOfType(child.callee.property, "Identifier") && child.callee.property.name === "abort") {
-			const controllerKey = resolveExpressionKey(child.callee.object, context);
-			if (controllerKey) controllerKeys.add(controllerKey);
-		}
-	});
-	return controllerKeys;
-};
-const collectCleanupAssignedCancellationFlagKeys = (cleanup, cancellationFlagKeys, context) => {
-	const assignedFlagKeys = /* @__PURE__ */ new Set();
+const isCancellationCleanup = (cleanup, effectCallback) => {
+	const cancellationFlagNames = collectEffectCancellationFlagNames(effectCallback);
+	let found = false;
 	walkAst(cleanup, (child) => {
-		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.right, "Literal") && child.right.value === true) {
-			const assignedKey = resolveExpressionKey(child.left, context);
-			if (assignedKey && cancellationFlagKeys.has(assignedKey)) assignedFlagKeys.add(assignedKey);
-		}
-	});
-	return assignedFlagKeys;
-};
-const readCancellationCondition = (expression, cancellationFlagKey, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (resolveExpressionKey(unwrappedExpression, context) === cancellationFlagKey) return true;
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readCancellationCondition(unwrappedExpression.argument, cancellationFlagKey, context);
-		return argumentResult === null ? null : !argumentResult;
-	}
-	if (!isNodeOfType(unwrappedExpression, "BinaryExpression")) return null;
-	const leftResult = readCancellationCondition(unwrappedExpression.left, cancellationFlagKey, context);
-	const rightResult = readCancellationCondition(unwrappedExpression.right, cancellationFlagKey, context);
-	const leftBoolean = isNodeOfType(unwrappedExpression.left, "Literal") && typeof unwrappedExpression.left.value === "boolean" ? unwrappedExpression.left.value : null;
-	const rightBoolean = isNodeOfType(unwrappedExpression.right, "Literal") && typeof unwrappedExpression.right.value === "boolean" ? unwrappedExpression.right.value : null;
-	const comparedCancellationValue = leftResult !== null && rightBoolean !== null ? rightBoolean : rightResult !== null && leftBoolean !== null ? leftBoolean : null;
-	if (comparedCancellationValue === null) return null;
-	if (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==") return comparedCancellationValue;
-	if (unwrappedExpression.operator === "!==" || unwrappedExpression.operator === "!=") return !comparedCancellationValue;
-	return null;
-};
-const isCompletionSinkInsideCancellationGuard = (completionSink, cancellationFlagKey, context) => {
-	let currentNode = completionSink;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isFunctionLike$1(parentNode)) return false;
-		if (isNodeOfType(parentNode, "IfStatement")) {
-			const cancellationResult = readCancellationCondition(parentNode.test, cancellationFlagKey, context);
-			if (currentNode === parentNode.consequent && cancellationResult === false) return true;
-			if (currentNode === parentNode.alternate && cancellationResult === true) return true;
-		}
-		if (isNodeOfType(parentNode, "ConditionalExpression")) {
-			const cancellationResult = readCancellationCondition(parentNode.test, cancellationFlagKey, context);
-			if (currentNode === parentNode.consequent && cancellationResult === false) return true;
-			if (currentNode === parentNode.alternate && cancellationResult === true) return true;
-		}
-		if (isNodeOfType(parentNode, "LogicalExpression") && currentNode === parentNode.right) {
-			const cancellationResult = readCancellationCondition(parentNode.left, cancellationFlagKey, context);
-			if (parentNode.operator === "&&" && cancellationResult === false) return true;
-			if (parentNode.operator === "||" && cancellationResult === true) return true;
+		if (found) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && child.callee.property.name === "abort") {
+			found = true;
+			return false;
 		}
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const isCompletionSinkAfterCancellationEarlyExit = (completionSink, cancellationFlagKey, context) => {
-	let currentNode = completionSink;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isFunctionLike$1(parentNode)) return false;
-		if (isNodeOfType(parentNode, "BlockStatement")) {
-			const statementIndex = parentNode.body.findIndex((statement) => statement === currentNode);
-			if (statementIndex >= 0) for (const statement of parentNode.body.slice(0, statementIndex)) {
-				if (!isNodeOfType(statement, "IfStatement")) continue;
-				const cancellationResult = readCancellationCondition(statement.test, cancellationFlagKey, context);
-				if (cancellationResult === true && statementAlwaysExits(statement.consequent) || cancellationResult === false && statement.alternate && statementAlwaysExits(statement.alternate)) return true;
-			}
+		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.left, "Identifier") && cancellationFlagNames.has(child.left.name) && isNodeOfType(child.right, "Literal") && child.right.value === true) {
+			found = true;
+			return false;
 		}
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const isCompletionSinkGuardedByCancellationFlag = (completionSink, cancellationFlagKey, context) => isCompletionSinkInsideCancellationGuard(completionSink, cancellationFlagKey, context) || isCompletionSinkAfterCancellationEarlyExit(completionSink, cancellationFlagKey, context);
-const isDescendantOf = (node, ancestor) => {
-	let currentNode = node;
-	while (currentNode) {
-		if (currentNode === ancestor) return true;
-		currentNode = currentNode.parent ?? null;
-	}
-	return false;
-};
-const isPromiseContinuationForRequest = (functionNode, request) => {
-	const callNode = functionNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression") || !callNode.arguments?.some((callArgument) => callArgument === functionNode) || !isNodeOfType(callNode.callee, "MemberExpression") || callNode.callee.computed || !isNodeOfType(callNode.callee.property, "Identifier") || !PROMISE_CONTINUATION_METHOD_NAMES.has(callNode.callee.property.name)) return false;
-	return isDescendantOf(request, callNode.callee.object);
-};
-const isAwaitedInFunction = (request, functionNode) => {
-	let currentNode = request.parent;
-	while (currentNode && currentNode !== functionNode) {
-		if (isNodeOfType(currentNode, "AwaitExpression")) return true;
-		currentNode = currentNode.parent ?? null;
-	}
-	return false;
-};
-const isCompletionSinkForRequest = (completionSink, request) => {
-	const requestFunction = findEnclosingFunction(request);
-	const completionSinkFunction = findEnclosingFunction(completionSink);
-	if (!requestFunction || !completionSinkFunction) return false;
-	if (requestFunction === completionSinkFunction) {
-		if (!isAwaitedInFunction(request, requestFunction)) return false;
-		const requestStart = getRangeStart(request);
-		const completionSinkStart = getRangeStart(completionSink);
-		return requestStart === null || completionSinkStart === null || completionSinkStart > requestStart;
-	}
-	return isPromiseContinuationForRequest(completionSinkFunction, request);
-};
-const requestHasGuardedCompletionSinks = (request, completionSinks, assignedCancellationFlagKeys, context) => {
-	const followingCompletionSinks = completionSinks.filter((completionSink) => isCompletionSinkForRequest(completionSink, request));
-	return followingCompletionSinks.length > 0 && followingCompletionSinks.every((completionSink) => [...assignedCancellationFlagKeys].some((cancellationFlagKey) => isCompletionSinkGuardedByCancellationFlag(completionSink, cancellationFlagKey, context)));
-};
-const allRequestsHaveCorrelatedCancellation = (requests, completionSinks, cleanup, effectCallback, context) => {
-	const abortedControllerKeys = collectCleanupAbortedControllerKeys(cleanup, context);
-	const assignedCancellationFlagKeys = collectCleanupAssignedCancellationFlagKeys(cleanup, collectEffectCancellationFlagKeys(effectCallback, context), context);
-	return requests.every((request) => {
-		const requestControllerKey = resolveRequestAbortControllerKey(request, context);
-		if (requestControllerKey && abortedControllerKeys.has(requestControllerKey)) return true;
-		return requestHasGuardedCompletionSinks(request, completionSinks, assignedCancellationFlagKeys, context);
 	});
+	return found;
 };
 const noFetchInEffect = defineRule({
 	id: "no-fetch-in-effect",
@@ -29344,13 +28612,9 @@ const noFetchInEffect = defineRule({
 		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		const callback = getEffectCallback(node);
 		if (!callback) return;
-		const analysisFunctions = collectEffectAnalysisFunctions(callback, context);
-		const requests = collectNodesFromAnalysisFunctions(analysisFunctions, isNetworkRequest);
-		if (requests.length === 0) return;
+		if (!containsNetworkRequestInEffect(callback)) return;
 		const cleanup = findEffectCleanupFunction(callback);
-		if (cleanup) {
-			if (allRequestsHaveCorrelatedCancellation(requests, collectNodesFromAnalysisFunctions(analysisFunctions, isSetterCall), cleanup, callback, context)) return;
-		}
+		if (cleanup && isCancellationCleanup(cleanup, callback)) return;
 		context.report({
 			node,
 			message: "fetch() inside useEffect can race, double-fire, or leak. Use a data-fetching layer or Server Component instead."
@@ -29650,6 +28914,34 @@ const noGenericHandlerNames = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/unwrap-react-hoc-function.ts
+/**
+* Resolves a `VariableDeclarator.init` (or any expression) to the inline
+* function expression it binds, seeing through chains of `memo` /
+* `forwardRef` / `React.memo` / `React.forwardRef` wrappers:
+*
+*   `() => {}`                          → the arrow
+*   `memo(function Foo() {})`           → the named function expression
+*   `React.memo(forwardRef(() => {}))`  → the inner arrow
+*   `memo(SomeIdentifier)`              → `null` (no inline function)
+*
+* Component-shaped rules that previously gated on a direct function init
+* (via `isComponentAssignment`) use this so memo-wrapped components are
+* not silently skipped.
+*/
+const unwrapReactHocFunction = (node) => {
+	if (!node) return null;
+	let current = stripParenExpression(node);
+	while (isNodeOfType(current, "CallExpression")) {
+		const calleeName = flattenCalleeName(current.callee);
+		if (!calleeName || !REACT_HOC_NAMES.has(calleeName)) return null;
+		const firstArgument = current.arguments[0];
+		if (!firstArgument) return null;
+		current = stripParenExpression(firstArgument);
+	}
+	return isInlineFunctionExpression(current) ? current : null;
+};
+//#endregion
 //#region src/plugin/rules/architecture/no-giant-component.ts
 const noGiantComponent = defineRule({
 	id: "no-giant-component",
@@ -29902,405 +29194,6 @@ const noGrayOnColoredBackground = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/find-enclosing-jsx-opening-element.ts
-const findEnclosingJsxOpeningElement = (node) => {
-	let cursor = node.parent;
-	while (cursor) {
-		if (isNodeOfType(cursor, "JSXElement")) return cursor.openingElement;
-		if (isNodeOfType(cursor, "JSXFragment")) return null;
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/has-client-render-evidence.ts
-const hasClientRenderEvidence = (componentOrHookNode, fileHasUseClientDirective) => {
-	if (fileHasUseClientDirective) return true;
-	const displayName = componentOrHookDisplayNameForFunction(componentOrHookNode);
-	if (displayName && isReactHookName(displayName)) return true;
-	let callsHook = false;
-	walkAst((isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null) ?? componentOrHookNode, (child) => {
-		if (callsHook) return false;
-		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && isReactHookName(child.callee.name)) {
-			callsHook = true;
-			return false;
-		}
-	});
-	return callsHook;
-};
-//#endregion
-//#region src/plugin/utils/has-suppress-hydration-warning-attribute.ts
-const hasSuppressHydrationWarningAttribute = (openingElement) => {
-	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
-	for (const attr of openingElement.attributes ?? []) if (isNodeOfType(attr, "JSXAttribute") && isNodeOfType(attr.name, "JSXIdentifier") && attr.name.name === "suppressHydrationWarning") return true;
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/read-initial-state-boolean.ts
-const readLogicalResult = (operator, leftResult, rightResult) => {
-	if (operator === "&&") {
-		if (leftResult === false || rightResult === false) return false;
-		if (leftResult === true && rightResult === true) return true;
-		return null;
-	}
-	if (leftResult === true || rightResult === true) return true;
-	if (leftResult === false && rightResult === false) return false;
-	return null;
-};
-const readIdentifierInitialStateBoolean = (identifier, scopes, visitedBindings, allowLazyInitializer) => {
-	if (!isNodeOfType(identifier, "Identifier")) return null;
-	if (identifier.name === "undefined" && scopes.isGlobalReference(identifier)) return false;
-	const binding = findVariableInitializer(identifier, identifier.name);
-	if (!binding || visitedBindings.has(binding.bindingIdentifier)) return null;
-	visitedBindings.add(binding.bindingIdentifier);
-	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
-	if (!declarator?.init || scopes.symbolFor(identifier)?.declarationNode !== declarator) return null;
-	const initializer = stripParenExpression(declarator.init);
-	if (isNodeOfType(declarator.id, "ArrayPattern") && declarator.id.elements?.[0] === binding.bindingIdentifier && isReactApiCall(initializer, "useState", scopes, { allowGlobalReactNamespace: true }) && isNodeOfType(initializer, "CallExpression")) {
-		const initialState = initializer.arguments?.[0];
-		if (!initialState) return false;
-		if (initialState.type === "SpreadElement") return null;
-		return readInitialStateBooleanInternal(initialState, scopes, visitedBindings, true);
-	}
-	const declaration = declarator.parent;
-	if (!isNodeOfType(declarator.id, "Identifier") || declarator.id !== binding.bindingIdentifier || !isNodeOfType(declaration, "VariableDeclaration") || declaration.kind !== "const") return null;
-	return readInitialStateBooleanInternal(initializer, scopes, visitedBindings, allowLazyInitializer);
-};
-const readInitialStateBooleanInternal = (expression, scopes, visitedBindings, allowLazyInitializer) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Literal")) return Boolean(unwrappedExpression.value);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) return readIdentifierInitialStateBoolean(unwrappedExpression, scopes, visitedBindings, allowLazyInitializer);
-	if (allowLazyInitializer && (isNodeOfType(unwrappedExpression, "ArrowFunctionExpression") || isNodeOfType(unwrappedExpression, "FunctionExpression"))) {
-		if (unwrappedExpression.async || isNodeOfType(unwrappedExpression, "FunctionExpression") && unwrappedExpression.generator) return null;
-		if (!isNodeOfType(unwrappedExpression.body, "BlockStatement")) return readInitialStateBooleanInternal(unwrappedExpression.body, scopes, visitedBindings, false);
-		if (unwrappedExpression.body.body.length !== 1) return null;
-		const returnStatement = unwrappedExpression.body.body[0];
-		if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return null;
-		return readInitialStateBooleanInternal(returnStatement.argument, scopes, visitedBindings, false);
-	}
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readInitialStateBooleanInternal(unwrappedExpression.argument, scopes, visitedBindings, false);
-		return argumentResult === null ? null : !argumentResult;
-	}
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression") && (unwrappedExpression.operator === "&&" || unwrappedExpression.operator === "||")) return readLogicalResult(unwrappedExpression.operator, readInitialStateBooleanInternal(unwrappedExpression.left, scopes, new Set(visitedBindings), false), readInitialStateBooleanInternal(unwrappedExpression.right, scopes, new Set(visitedBindings), false));
-	return null;
-};
-const readInitialStateBoolean = (expression, scopes) => readInitialStateBooleanInternal(expression, scopes, /* @__PURE__ */ new Set(), false);
-//#endregion
-//#region src/plugin/utils/is-after-client-only-early-return.ts
-const isAfterClientOnlyEarlyReturn = (node, componentOrHookNode, scopes) => {
-	const body = isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null;
-	if (!isNodeOfType(body, "BlockStatement")) return false;
-	const ancestors = /* @__PURE__ */ new Set();
-	let currentNode = node;
-	while (currentNode) {
-		ancestors.add(currentNode);
-		currentNode = currentNode.parent ?? null;
-	}
-	for (const statement of body.body ?? []) {
-		if (ancestors.has(statement)) return false;
-		if (!isNodeOfType(statement, "IfStatement")) continue;
-		const initialConditionResult = readInitialStateBoolean(statement.test, scopes);
-		if (initialConditionResult === true && statementAlwaysExits(statement.consequent)) return true;
-		if (initialConditionResult === false && statement.alternate && statementAlwaysExits(statement.alternate)) return true;
-	}
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/is-gated-by-falsy-initial-state.ts
-const isGatedByFalsyInitialState = (node, scopes) => {
-	let cursor = node;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === cursor && (parent.operator === "&&" && readInitialStateBoolean(parent.left, scopes) === false || parent.operator === "||" && readInitialStateBoolean(parent.left, scopes) === true)) return true;
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === cursor && readInitialStateBoolean(parent.test, scopes) === false || parent.alternate === cursor && readInitialStateBoolean(parent.test, scopes) === true)) return true;
-		if (isNodeOfType(parent, "IfStatement") && (parent.consequent === cursor && readInitialStateBoolean(parent.test, scopes) === false || parent.alternate === cursor && readInitialStateBoolean(parent.test, scopes) === true)) return true;
-		cursor = parent;
-		parent = parent.parent ?? null;
-	}
-	return false;
-};
-//#endregion
-//#region src/plugin/rules/performance/no-hydration-branch-on-browser-global.ts
-const evaluateEquality = (operator, left, right) => {
-	if (operator === "===" || operator === "==") return left === right;
-	if (operator === "!==" || operator === "!=") return left !== right;
-	return null;
-};
-const readTypeofBrowserGlobal = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "UnaryExpression") || unwrappedExpression.operator !== "typeof") return null;
-	const argument = stripParenExpression(unwrappedExpression.argument);
-	if (isNodeOfType(argument, "Identifier")) return (argument.name === "window" || argument.name === "document") && context.scopes.isGlobalReference(argument) ? argument.name : null;
-	if (!isNodeOfType(argument, "MemberExpression") || argument.computed || !isNodeOfType(argument.object, "Identifier") || argument.object.name !== "globalThis" || !context.scopes.isGlobalReference(argument.object) || !isNodeOfType(argument.property, "Identifier") || argument.property.name !== "window" && argument.property.name !== "document") return null;
-	return argument.property.name;
-};
-const matchBrowserPredicate = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const innerMatch = matchBrowserPredicate(unwrappedExpression.argument, context);
-		return innerMatch ? {
-			browserGlobalName: innerMatch.browserGlobalName,
-			clientResult: !innerMatch.clientResult,
-			serverResult: !innerMatch.serverResult
-		} : null;
-	}
-	if (!isNodeOfType(unwrappedExpression, "BinaryExpression")) return null;
-	const leftGlobalName = readTypeofBrowserGlobal(unwrappedExpression.left, context);
-	const rightGlobalName = readTypeofBrowserGlobal(unwrappedExpression.right, context);
-	const leftString = isNodeOfType(unwrappedExpression.left, "Literal") ? unwrappedExpression.left.value : null;
-	const rightString = isNodeOfType(unwrappedExpression.right, "Literal") ? unwrappedExpression.right.value : null;
-	const browserGlobalName = leftGlobalName && typeof rightString === "string" ? leftGlobalName : rightGlobalName && typeof leftString === "string" ? rightGlobalName : null;
-	const comparedType = leftGlobalName && typeof rightString === "string" ? rightString : rightGlobalName && typeof leftString === "string" ? leftString : null;
-	if (!browserGlobalName || !comparedType) return null;
-	const clientResult = evaluateEquality(unwrappedExpression.operator, "object", comparedType);
-	const serverResult = evaluateEquality(unwrappedExpression.operator, "undefined", comparedType);
-	if (clientResult === null || serverResult === null || clientResult === serverResult) return null;
-	return {
-		browserGlobalName,
-		clientResult,
-		serverResult
-	};
-};
-const readLogicalConditionResult = (operator, leftResult, rightResult) => {
-	if (operator === "&&") {
-		if (leftResult === false || rightResult === false) return false;
-		if (leftResult === true && rightResult === true) return true;
-		return null;
-	}
-	if (leftResult === true || rightResult === true) return true;
-	if (leftResult === false && rightResult === false) return false;
-	return null;
-};
-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;
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		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), readHydrationConditionResult(unwrappedExpression.right, context, runtime));
-};
-const matchHydrationCondition = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
-	if (predicateMatch) return {
-		predicateMatch,
-		predicateNode: unwrappedExpression
-	};
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationCondition(unwrappedExpression.argument, context);
-	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	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 otherResult = readInitialStateBoolean(leftMatch ? unwrappedExpression.right : unwrappedExpression.left, context.scopes);
-	if (unwrappedExpression.operator === "&&" && otherResult === false || unwrappedExpression.operator === "||" && otherResult === true) return null;
-	return nestedMatch;
-};
-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;
-	const left = stripParenExpression(leftNode);
-	const right = stripParenExpression(rightNode);
-	if (areExpressionsStructurallyEqual(left, right)) return true;
-	if (left.type !== right.type) return false;
-	if (isNodeOfType(left, "JSXText") && isNodeOfType(right, "JSXText")) return left.value === right.value;
-	if (isNodeOfType(left, "JSXExpressionContainer") && isNodeOfType(right, "JSXExpressionContainer")) {
-		if (!isAstNode(left.expression) || !isAstNode(right.expression)) return left.expression.type === right.expression.type;
-		return areRenderedBranchesEquivalent(left.expression, right.expression);
-	}
-	if (isNodeOfType(left, "JSXElement") && isNodeOfType(right, "JSXElement")) {
-		if (flattenJsxName$1(left.openingElement.name) !== flattenJsxName$1(right.openingElement.name)) return false;
-		if (!areNodeArraysEquivalent(left.openingElement.attributes, right.openingElement.attributes)) return false;
-		return areNodeArraysEquivalent(left.children, right.children);
-	}
-	if (isNodeOfType(left, "JSXFragment") && isNodeOfType(right, "JSXFragment")) return areNodeArraysEquivalent(left.children, right.children);
-	if (isNodeOfType(left, "JSXAttribute") && isNodeOfType(right, "JSXAttribute")) {
-		if (flattenJsxName$1(left.name) !== flattenJsxName$1(right.name)) return false;
-		return areRenderedBranchesEquivalent(left.value, right.value);
-	}
-	if (isNodeOfType(left, "JSXSpreadAttribute") && isNodeOfType(right, "JSXSpreadAttribute")) return areRenderedBranchesEquivalent(left.argument, right.argument);
-	if (isNodeOfType(left, "TemplateLiteral") && isNodeOfType(right, "TemplateLiteral")) {
-		if (left.quasis.length !== right.quasis.length) return false;
-		if (!left.quasis.every((quasi, index) => quasi.value.cooked === right.quasis[index]?.value.cooked && quasi.value.raw === right.quasis[index]?.value.raw)) return false;
-		return areNodeArraysEquivalent(left.expressions, right.expressions);
-	}
-	return false;
-};
-const isRenderedValue = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (isNodeOfType(unwrappedNode, "Literal")) return unwrappedNode.value !== null && unwrappedNode.value !== true && unwrappedNode.value !== false && unwrappedNode.value !== "";
-	if (isNodeOfType(unwrappedNode, "TemplateLiteral")) return unwrappedNode.expressions.length > 0 || unwrappedNode.quasis[0]?.value.cooked !== "";
-	return isNodeOfType(unwrappedNode, "JSXElement") || isNodeOfType(unwrappedNode, "JSXFragment");
-};
-const findRenderedValueInAndBranch = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (isRenderedValue(unwrappedNode)) return unwrappedNode;
-	if (!isNodeOfType(unwrappedNode, "LogicalExpression") || unwrappedNode.operator !== "&&") return null;
-	return findRenderedValueInAndBranch(unwrappedNode.right);
-};
-const findEnclosingJsxAttribute = (node) => {
-	let currentNode = node.parent;
-	while (currentNode) {
-		if (isNodeOfType(currentNode, "JSXAttribute")) return currentNode;
-		if (isNodeOfType(currentNode, "JSXElement") || isNodeOfType(currentNode, "JSXFragment") || isFunctionLike$1(currentNode)) return null;
-		currentNode = currentNode.parent;
-	}
-	return null;
-};
-const isInRenderedOutput = (node, componentOrHookNode, scopes) => {
-	let currentNode = node;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "JSXExpressionContainer")) {
-			const attribute = findEnclosingJsxAttribute(parentNode);
-			return attribute ? !isEventHandlerAttribute(attribute) : true;
-		}
-		if (isNodeOfType(parentNode, "ReturnStatement")) {
-			if (findEnclosingFunction(parentNode) === componentOrHookNode) return true;
-		}
-		if (parentNode === componentOrHookNode) return isFunctionLike$1(componentOrHookNode) && !isNodeOfType(componentOrHookNode.body, "BlockStatement") && componentOrHookNode.body === currentNode;
-		if (isFunctionLike$1(parentNode) && !executesDuringRender(parentNode, scopes)) return false;
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const getReturnedValues = (statement) => {
-	if (!statement) return [];
-	if (isNodeOfType(statement, "ReturnStatement")) return statement.argument ? [statement.argument] : [];
-	if (isNodeOfType(statement, "IfStatement")) return [...getReturnedValues(statement.consequent), ...getReturnedValues(statement.alternate)];
-	if (!isNodeOfType(statement, "BlockStatement")) return [];
-	const returnedValues = [];
-	for (const childStatement of statement.body) {
-		returnedValues.push(...getReturnedValues(childStatement));
-		if (statementAlwaysExits(childStatement)) break;
-	}
-	return returnedValues;
-};
-const findFollowingReturnedValues = (ifStatement) => {
-	const parentNode = ifStatement.parent;
-	if (!isNodeOfType(parentNode, "BlockStatement")) return [];
-	const statementIndex = parentNode.body.findIndex((statement) => statement === ifStatement);
-	if (statementIndex < 0) return [];
-	const returnedValues = [];
-	for (const statement of parentNode.body.slice(statementIndex + 1)) {
-		returnedValues.push(...getReturnedValues(statement));
-		if (statementAlwaysExits(statement)) break;
-	}
-	return returnedValues;
-};
-const areConditionExpressionsEquivalent = (leftExpression, rightExpression) => {
-	const left = stripParenExpression(leftExpression);
-	const right = stripParenExpression(rightExpression);
-	if (areExpressionsStructurallyEqual(left, right)) return true;
-	if (left.type !== right.type) return false;
-	if (isNodeOfType(left, "UnaryExpression") && isNodeOfType(right, "UnaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.argument, right.argument);
-	if (isNodeOfType(left, "LogicalExpression") && isNodeOfType(right, "LogicalExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left) && areConditionExpressionsEquivalent(left.right, right.right);
-	if (isNodeOfType(left, "BinaryExpression") && isNodeOfType(right, "BinaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left) && areConditionExpressionsEquivalent(left.right, right.right);
-	return false;
-};
-const areReturnTreesEquivalent = (leftStatement, rightStatement) => {
-	if (!leftStatement || !rightStatement) return leftStatement === rightStatement;
-	if (isNodeOfType(leftStatement, "ReturnStatement") && isNodeOfType(rightStatement, "ReturnStatement")) return areRenderedBranchesEquivalent(leftStatement.argument, rightStatement.argument);
-	if (isNodeOfType(leftStatement, "IfStatement") && isNodeOfType(rightStatement, "IfStatement")) return areConditionExpressionsEquivalent(leftStatement.test, rightStatement.test) && areReturnTreesEquivalent(leftStatement.consequent, rightStatement.consequent) && areReturnTreesEquivalent(leftStatement.alternate, rightStatement.alternate);
-	if (!isNodeOfType(leftStatement, "BlockStatement") || !isNodeOfType(rightStatement, "BlockStatement")) return false;
-	const leftReturningStatements = leftStatement.body.filter((statement) => getReturnedValues(statement).length > 0);
-	const rightReturningStatements = rightStatement.body.filter((statement) => getReturnedValues(statement).length > 0);
-	return leftReturningStatements.length === rightReturningStatements.length && leftReturningStatements.every((statement, index) => areReturnTreesEquivalent(statement, rightReturningStatements[index]));
-};
-const isStructuralRenderedValue = (node) => {
-	if (!node) return false;
-	const unwrappedNode = stripParenExpression(node);
-	return isNodeOfType(unwrappedNode, "JSXElement") || isNodeOfType(unwrappedNode, "JSXFragment");
-};
-const branchRootsSuppressSameElement = (leftBranch, rightBranch) => {
-	if (!rightBranch) return false;
-	const left = stripParenExpression(leftBranch);
-	const right = stripParenExpression(rightBranch);
-	return isNodeOfType(left, "JSXElement") && isNodeOfType(right, "JSXElement") && flattenJsxName$1(left.openingElement.name) === flattenJsxName$1(right.openingElement.name) && hasSuppressHydrationWarningAttribute(left.openingElement) && hasSuppressHydrationWarningAttribute(right.openingElement);
-};
-const noHydrationBranchOnBrowserGlobal = defineRule({
-	id: "no-hydration-branch-on-browser-global",
-	title: "Server and client render different branches",
-	severity: "error",
-	category: "Correctness",
-	requires: ["ssr"],
-	recommendation: "Render the same initial output on the server and client, then switch after mount or use useSyncExternalStore with a stable server snapshot.",
-	create: (context) => {
-		if (isTestlikeFilename(context.filename)) return {};
-		if (classifyReactNativeFileTarget(context) === "react-native") return {};
-		let fileHasUseClientDirective = false;
-		let fileIsEmailTemplate = false;
-		const reportedNodes = /* @__PURE__ */ new Set();
-		const reportHydrationBranch = (conditionNode, leftBranch, rightBranch, requiresRenderedContext) => {
-			const conditionMatch = matchHydrationCondition(conditionNode, context);
-			if (!conditionMatch) return;
-			const { predicateMatch, predicateNode } = conditionMatch;
-			if (reportedNodes.has(predicateNode)) return;
-			if (rightBranch && areRenderedBranchesEquivalent(leftBranch, rightBranch)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(predicateNode, context.scopes);
-			if (!componentOrHookNode) return;
-			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (requiresRenderedContext && !isInRenderedOutput(predicateNode, componentOrHookNode, context.scopes)) return;
-			if (!isRenderedValue(leftBranch) && (!rightBranch || !isRenderedValue(rightBranch))) {
-				const attribute = findEnclosingJsxAttribute(predicateNode);
-				if (!attribute || isEventHandlerAttribute(attribute)) return;
-			}
-			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;
-			reportedNodes.add(predicateNode);
-			context.report({
-				node: predicateNode,
-				message: `\`typeof ${predicateMatch.browserGlobalName}\` selects different rendered output on the server and during hydration. Render the same initial output, then switch after mount.`
-			});
-		};
-		return {
-			Program(node) {
-				fileHasUseClientDirective = hasDirective(node, "use client");
-				fileIsEmailTemplate = hasEmailTemplateImport(node);
-			},
-			ConditionalExpression(node) {
-				reportHydrationBranch(node.test, node.consequent, node.alternate, true);
-			},
-			LogicalExpression(node) {
-				if (node.operator !== "&&" && node.operator !== "||") return;
-				const renderedValue = node.operator === "&&" ? findRenderedValueInAndBranch(node.right) : isRenderedValue(node.right) ? node.right : null;
-				if (!renderedValue) return;
-				reportHydrationBranch(node, renderedValue, null, true);
-			},
-			IfStatement(node) {
-				if (node.alternate && areReturnTreesEquivalent(node.consequent, node.alternate)) return;
-				const consequentValues = getReturnedValues(node.consequent);
-				const alternateValues = node.alternate ? getReturnedValues(node.alternate) : findFollowingReturnedValues(node);
-				if (consequentValues.length === 0 || alternateValues.length === 0) return;
-				const componentOrHookNode = findRenderPhaseComponentOrHook(node.test, context.scopes);
-				if (!componentOrHookNode) return;
-				const enclosingFunction = findEnclosingFunction(node);
-				if (enclosingFunction !== componentOrHookNode && (!enclosingFunction || !isInRenderedOutput(enclosingFunction, componentOrHookNode, context.scopes))) return;
-				for (const consequentValue of consequentValues) for (const alternateValue of alternateValues) {
-					if (!isRenderedValue(consequentValue) && !isRenderedValue(alternateValue)) continue;
-					reportHydrationBranch(node.test, consequentValue, alternateValue, false);
-				}
-			}
-		};
-	}
-});
-//#endregion
 //#region src/plugin/rules/performance/no-img-lazy-with-high-fetchpriority.ts
 const MESSAGE$22 = "`<img loading=\"lazy\">` defers the request while `fetchPriority=\"high\"` asks the browser to rush it, so the two directives contradict each other. Drop one: keep `fetchPriority=\"high\"` (and eager loading) for an LCP image, or `loading=\"lazy\"` for a below-the-fold one.";
 const noImgLazyWithHighFetchpriority = defineRule({
@@ -31146,6 +30039,111 @@ const noLegacyContextApi = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/executes-during-render.ts
+const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
+	"map",
+	"filter",
+	"forEach",
+	"flatMap",
+	"reduce",
+	"reduceRight",
+	"some",
+	"every",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"sort",
+	"toSorted"
+]);
+const executesDuringRender = (functionNode) => {
+	const parent = functionNode.parent;
+	if (!isNodeOfType(parent, "CallExpression")) return false;
+	if (parent.callee === functionNode) return true;
+	if (isHookCall$2(parent, "useMemo") && parent.arguments?.[0] === functionNode) return true;
+	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.has(parent.callee.property.name) && parent.arguments?.[0] === functionNode;
+};
+//#endregion
+//#region src/plugin/utils/has-suppress-hydration-warning-attribute.ts
+const hasSuppressHydrationWarningAttribute = (openingElement) => {
+	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	for (const attr of openingElement.attributes ?? []) if (isNodeOfType(attr, "JSXAttribute") && isNodeOfType(attr.name, "JSXIdentifier") && attr.name.name === "suppressHydrationWarning") return true;
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/find-declarator-for-binding.ts
+const findDeclaratorForBinding = (bindingIdentifier) => {
+	let ancestor = bindingIdentifier.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "VariableDeclarator")) return ancestor;
+		if (isNodeOfType(ancestor, "FunctionDeclaration") || isNodeOfType(ancestor, "FunctionExpression") || isNodeOfType(ancestor, "ArrowFunctionExpression") || isNodeOfType(ancestor, "Program")) return null;
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/references-falsy-initial-state.ts
+const isFalsyLiteral = (node) => {
+	if (!node) return true;
+	if (isNodeOfType(node, "Literal")) return !node.value;
+	return isNodeOfType(node, "Identifier") && node.name === "undefined";
+};
+const isFalsyInitialStateBinding = (identifier) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const binding = findVariableInitializer(identifier, identifier.name);
+	if (!binding) return false;
+	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
+	if (!declarator?.init) return false;
+	const init = stripParenExpression(declarator.init);
+	if (!isHookCall$2(init, "useState") || !isNodeOfType(init, "CallExpression")) return false;
+	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
+	if (declarator.id.elements?.[0] !== binding.bindingIdentifier) return false;
+	return isFalsyLiteral(init.arguments?.[0]);
+};
+const referencesFalsyInitialState = (expression) => flattenLogicalAndChain(stripParenExpression(expression)).some((operand) => isFalsyInitialStateBinding(stripParenExpression(operand)));
+//#endregion
+//#region src/plugin/utils/is-gated-by-falsy-initial-state.ts
+const isGatedByFalsyInitialState = (node) => {
+	let cursor = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&" && parent.right === cursor && referencesFalsyInitialState(parent.left)) return true;
+		if (isNodeOfType(parent, "ConditionalExpression") && parent.consequent === cursor && referencesFalsyInitialState(parent.test)) return true;
+		if (isNodeOfType(parent, "IfStatement") && parent.consequent === cursor && referencesFalsyInitialState(parent.test)) return true;
+		cursor = parent;
+		parent = parent.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/references-client-only-flag.ts
+const CLIENT_ONLY_FLAG_NAME_PATTERN = /^(?:is|has|did)?_?(?:client|mounted|hydrated|browser)(?:_?(?:side|ready|only))?$/i;
+const referencesClientOnlyFlag = (expression) => {
+	const unwrapped = stripParenExpression(expression);
+	if (isNodeOfType(unwrapped, "Identifier")) return CLIENT_ONLY_FLAG_NAME_PATTERN.test(unwrapped.name);
+	if (isNodeOfType(unwrapped, "MemberExpression")) {
+		const property = unwrapped.property;
+		return isNodeOfType(property, "Identifier") && CLIENT_ONLY_FLAG_NAME_PATTERN.test(property.name);
+	}
+	if (isNodeOfType(unwrapped, "UnaryExpression") && unwrapped.operator === "!") return referencesClientOnlyFlag(unwrapped.argument);
+	if (isNodeOfType(unwrapped, "LogicalExpression")) return referencesClientOnlyFlag(unwrapped.left) || referencesClientOnlyFlag(unwrapped.right);
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/is-inside-client-only-guard.ts
+const isInsideClientOnlyGuard = (node) => {
+	let cursor = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&" && parent.right === cursor && referencesClientOnlyFlag(parent.left)) return true;
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === cursor || parent.alternate === cursor) && referencesClientOnlyFlag(parent.test)) return true;
+		if (isNodeOfType(parent, "IfStatement") && parent.consequent === cursor && referencesClientOnlyFlag(parent.test)) return true;
+		cursor = parent;
+		parent = parent.parent ?? null;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/performance/no-locale-format-in-render.ts
 const LOCALE_FORMAT_METHOD_NAMES = new Set([
 	"toLocaleString",
@@ -31275,12 +30273,75 @@ const matchDateDefaultStringification = (node) => {
 	}
 	return null;
 };
+const findRenderPhaseComponentOrHook = (node) => {
+	let functionNode = findEnclosingFunction(node);
+	while (functionNode) {
+		if (componentOrHookDisplayNameForFunction(functionNode)) return functionNode;
+		if (!executesDuringRender(functionNode)) return null;
+		functionNode = findEnclosingFunction(functionNode);
+	}
+	return null;
+};
+const hasClientRenderEvidence = (componentOrHookNode, fileHasUseClientDirective) => {
+	if (fileHasUseClientDirective) return true;
+	const displayName = componentOrHookDisplayNameForFunction(componentOrHookNode);
+	if (displayName && isReactHookName(displayName)) return true;
+	let callsHook = false;
+	walkAst((isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null) ?? componentOrHookNode, (child) => {
+		if (callsHook) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && isReactHookName(child.callee.name)) {
+			callsHook = true;
+			return false;
+		}
+	});
+	return callsHook;
+};
+const isAfterClientOnlyEarlyReturn = (node, componentOrHookNode) => {
+	const body = isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null;
+	if (!isNodeOfType(body, "BlockStatement")) return false;
+	const ancestors = /* @__PURE__ */ new Set();
+	let cursor = node;
+	while (cursor) {
+		ancestors.add(cursor);
+		cursor = cursor.parent ?? null;
+	}
+	for (const statement of body.body ?? []) {
+		if (ancestors.has(statement)) return false;
+		if (!isNodeOfType(statement, "IfStatement")) continue;
+		if (!referencesClientOnlyFlag(statement.test) && !referencesFalsyInitialState(statement.test)) continue;
+		let returnsEarly = false;
+		walkAst(statement.consequent, (child) => {
+			if (isFunctionLike$1(child)) return false;
+			if (isNodeOfType(child, "ReturnStatement")) {
+				returnsEarly = true;
+				return false;
+			}
+		});
+		if (returnsEarly) return true;
+	}
+	return false;
+};
+const findEnclosingJsxOpeningElement = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isNodeOfType(cursor, "JSXElement")) return cursor.openingElement;
+		if (isNodeOfType(cursor, "JSXFragment")) return null;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
 const noLocaleFormatInRender = defineRule({
 	id: "no-locale-format-in-render",
 	title: "Locale/timezone formatting during render",
 	severity: "warn",
 	category: "Correctness",
-	requires: ["ssr"],
+	disabledWhen: [
+		"vite",
+		"cra",
+		"expo",
+		"react-native",
+		"unknown"
+	],
 	recommendation: "Format locale/timezone-dependent values in a post-mount useEffect + state, or pass an explicit locale and timeZone so the server and the browser render the same text. Only runs on SSR-capable projects.",
 	create: (context) => {
 		if (isTestlikeFilename(context.filename)) return {};
@@ -31290,12 +30351,13 @@ const noLocaleFormatInRender = defineRule({
 		const reportedNodes = /* @__PURE__ */ new Set();
 		const reportIfRenderPhase = (match) => {
 			if (reportedNodes.has(match.node)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(match.node, context.scopes);
+			const componentOrHookNode = findRenderPhaseComponentOrHook(match.node);
 			if (!componentOrHookNode) return;
 			if (fileIsEmailTemplate) return;
 			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (isGatedByFalsyInitialState(match.node, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(match.node, componentOrHookNode, context.scopes)) return;
+			if (isInsideClientOnlyGuard(match.node)) return;
+			if (isGatedByFalsyInitialState(match.node)) return;
+			if (isAfterClientOnlyEarlyReturn(match.node, componentOrHookNode)) return;
 			if (hasSuppressHydrationWarningAttribute(findEnclosingJsxOpeningElement(match.node))) return;
 			if (isGeneratedImageRenderContext(context, findEnclosingJsxOpeningElement(match.node)?.parent ?? match.node)) return;
 			reportedNodes.add(match.node);
@@ -31322,7 +30384,7 @@ const noLocaleFormatInRender = defineRule({
 				if (!isNodeOfType(expression, "CallExpression")) return;
 				if (!isNodeOfType(expression.callee, "Identifier")) return;
 				const helperName = expression.callee.name;
-				const componentOrHookNode = findRenderPhaseComponentOrHook(node, context.scopes);
+				const componentOrHookNode = findRenderPhaseComponentOrHook(node);
 				if (!componentOrHookNode) return;
 				const helperNode = findVariableInitializer(expression.callee, helperName)?.initializer;
 				if (!helperNode || !isFunctionLike$1(helperNode)) return;
@@ -31334,8 +30396,9 @@ const noLocaleFormatInRender = defineRule({
 					if (!match || reportedNodes.has(match.node)) return;
 					if (fileIsEmailTemplate) return;
 					if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-					if (isGatedByFalsyInitialState(node, context.scopes)) return;
-					if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode, context.scopes)) return;
+					if (isInsideClientOnlyGuard(node)) return;
+					if (isGatedByFalsyInitialState(node)) return;
+					if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode)) return;
 					if (hasSuppressHydrationWarningAttribute(findEnclosingJsxOpeningElement(node))) return;
 					reportedNodes.add(match.node);
 					context.report({
@@ -31437,6 +30500,9 @@ const noLongTransitionDuration = defineRule({
 const BOOLEAN_PROP_PREFIX_PATTERN = /^(?:is|has|should|can|show|hide|enable|disable|with)[A-Z]/;
 const isBooleanPrefixedPropName = (propName) => BOOLEAN_PROP_PREFIX_PATTERN.test(propName);
 //#endregion
+//#region src/plugin/utils/is-event-handler-attribute.ts
+const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
+//#endregion
 //#region src/plugin/rules/architecture/no-many-boolean-props.ts
 const IMPERATIVE_CALLBACK_PREFIX_PATTERN = /^(?:show|hide|enable|disable)[A-Z]/;
 const collectCallbackUsedNames = (componentBody, propsParam, scopes) => {
@@ -31568,7 +30634,7 @@ const noMatchMediaInStateInitializer = defineRule({
 	title: "matchMedia in state initializer",
 	severity: "warn",
 	category: "Correctness",
-	requires: ["ssr"],
+	disabledWhen: ["vite", "cra"],
 	recommendation: "Prefer CSS media queries for layout, or subscribe with `useSyncExternalStore` and provide a stable server snapshot.",
 	create: (context) => {
 		if (isTestlikeFilename(context.filename)) return {};
@@ -32119,41 +31185,6 @@ const noMutableInDeps = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-result-discarded-call.ts
-const isResultDiscardedCall = (callExpression) => {
-	let node = callExpression;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "ExpressionStatement")) return true;
-		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void") return true;
-		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
-		if (isNodeOfType(parent, "ChainExpression")) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "SequenceExpression")) {
-			const expressions = parent.expressions ?? [];
-			if (expressions[expressions.length - 1] !== node) return true;
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		return false;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/lodash-mutator-call.ts
 const LODASH_MUTATOR_NAMES = new Set([
 	"set",
@@ -33444,7 +32475,7 @@ const isUseRefIdentifier = (identifier) => {
 };
 const COMMAND_PROP_NAME_PATTERN = /^(fetch|load|refetch|dispatch|register|render)([A-Z_]|$)/;
 const SETTER_NAMED_PROP_PATTERN = /^set[A-Z]/;
-const unwrapChainExpression$1 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const unwrapChainExpression = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
 const FUNCTION_WRAPPER_HOOK_NAMES$1 = new Set([
 	"useCallback",
 	"useMemo",
@@ -33479,7 +32510,7 @@ const isDirectParentCallbackRef = (analysis, ref) => {
 	return Boolean(ref.resolved?.defs.some((def) => {
 		const node = def.node;
 		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-		const initializer = unwrapChainExpression$1(node.init);
+		const initializer = unwrapChainExpression(node.init);
 		const wrappedFunction = getWrapperHookWrappedFunction(initializer);
 		if (wrappedFunction) {
 			if (wrappedFunction.async) return false;
@@ -33492,7 +32523,7 @@ const isDirectParentCallbackRef = (analysis, ref) => {
 const isWrapperHookCallbackRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-	return getWrapperHookWrappedFunction(unwrapChainExpression$1(node.init)) !== null;
+	return getWrapperHookWrappedFunction(unwrapChainExpression(node.init)) !== null;
 }));
 const isHandlerBagArgument = (analysis, argument) => {
 	if (!isNodeOfType(argument, "ObjectExpression")) return false;
@@ -33514,7 +32545,7 @@ const HOOK_NAME_PATTERN$1 = /^use[A-Z0-9]/;
 const isParentWiredHookResultRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-	const init = unwrapChainExpression$1(node.init);
+	const init = unwrapChainExpression(node.init);
 	if (!isNodeOfType(init, "CallExpression")) return false;
 	const callee = init.callee;
 	if (!isNodeOfType(callee, "Identifier") || !HOOK_NAME_PATTERN$1.test(callee.name)) return false;
@@ -33558,7 +32589,7 @@ const noPassDataToParent = defineRule({
 			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
 			if (isRefCall(analysis, ref)) continue;
 			if (!isSynchronous(ref.identifier, effectFn)) continue;
-			const calleeNode = unwrapChainExpression$1(callExpr.callee);
+			const calleeNode = unwrapChainExpression(callExpr.callee);
 			const identifier = ref.identifier;
 			if (calleeNode === identifier) {
 				if (!isDirectParentCallbackRef(analysis, ref)) continue;
@@ -34407,11 +33438,7 @@ const noReactChildren = defineRule({
 //#endregion
 //#region src/plugin/rules/architecture/utils/create-deprecated-react-import-rule.ts
 const createDeprecatedReactImportRule = ({ source, messages, handleExtraSource }) => ({ create: (context) => {
-	const namespaceImportSpecifiers = /* @__PURE__ */ new Set();
-	const resolvesToNamespaceImport = (identifier) => {
-		const symbol = resolveConstIdentifierAlias(identifier, context.scopes);
-		return Boolean(symbol && namespaceImportSpecifiers.has(symbol.declarationNode));
-	};
+	const namespaceBindings = /* @__PURE__ */ new Set();
 	return {
 		ImportDeclaration(node) {
 			const sourceValue = node.source?.value;
@@ -34431,15 +33458,18 @@ const createDeprecatedReactImportRule = ({ source, messages, handleExtraSource }
 					});
 					continue;
 				}
-				if (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier")) namespaceImportSpecifiers.add(specifier);
+				if (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
+					const localName = specifier.local?.name;
+					if (localName) namespaceBindings.add(localName);
+				}
 			}
 		},
 		MemberExpression(node) {
-			if (namespaceImportSpecifiers.size === 0) return;
+			if (namespaceBindings.size === 0) return;
 			if (node.computed) return;
 			const receiver = stripParenExpression(node.object);
 			if (!isNodeOfType(receiver, "Identifier")) return;
-			if (!resolvesToNamespaceImport(receiver)) return;
+			if (!namespaceBindings.has(receiver.name)) return;
 			if (!isNodeOfType(node.property, "Identifier")) return;
 			const message = messages.get(node.property.name);
 			if (message) context.report({
@@ -34504,9 +33534,15 @@ const noReactDomDeprecatedApis = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/architecture/no-react19-deprecated-apis.ts
+const REACT_19_DEPRECATED_MESSAGES = new Map([["forwardRef", "forwardRef is dead weight in React 19, since ref is a normal prop now, so drop it & pass ref straight through."]]);
+const isVendoredShadcnUiFilename = (rawFilename) => {
+	if (!rawFilename) return false;
+	const filename = rawFilename.replaceAll("\\", "/");
+	return (filename.startsWith("/") ? filename : `/${filename}`).includes("/components/ui/");
+};
 const deprecatedReactImportRule = createDeprecatedReactImportRule({
 	source: "react",
-	messages: new Map([["createFactory", "React 19 removed createFactory. Use JSX or createElement instead."]])
+	messages: REACT_19_DEPRECATED_MESSAGES
 });
 const buildOncePerApiContext = (context) => {
 	const reportedMessages = /* @__PURE__ */ new Set();
@@ -34536,8 +33572,11 @@ const noReact19DeprecatedApis = defineRule({
 	requires: ["react:19"],
 	tags: ["test-noise", "migration-hint"],
 	severity: "warn",
-	recommendation: "Replace removed React APIs with their supported React 19 alternatives. Only runs on React 19+ projects.",
-	create: (context) => deprecatedReactImportRule.create(buildOncePerApiContext(context))
+	recommendation: "Pass `ref` as a normal prop on function components, since `forwardRef` isn't needed in React 19. Only runs on React 19+ projects.",
+	create: (context) => {
+		if (isVendoredShadcnUiFilename(context.filename)) return {};
+		return deprecatedReactImportRule.create(buildOncePerApiContext(context));
+	}
 });
 //#endregion
 //#region src/plugin/constants/aria-element-roles.ts
@@ -36870,140 +35909,6 @@ const noUnescapedEntities = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/rules/performance/no-unguarded-browser-global-in-render-or-hook-init.ts
-const BROWSER_GLOBAL_NAMES = new Set([
-	"window",
-	"document",
-	"localStorage",
-	"sessionStorage",
-	"navigator",
-	"matchMedia"
-]);
-const getTypeofBrowserGlobalName = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "UnaryExpression") || unwrappedExpression.operator !== "typeof") return null;
-	const argument = stripParenExpression(unwrappedExpression.argument);
-	if (isNodeOfType(argument, "Identifier")) return BROWSER_GLOBAL_NAMES.has(argument.name) && context.scopes.isGlobalReference(argument) ? argument.name : null;
-	if (!isNodeOfType(argument, "MemberExpression") || argument.computed || !isNodeOfType(argument.object, "Identifier") || argument.object.name !== "globalThis" || !context.scopes.isGlobalReference(argument.object) || !isNodeOfType(argument.property, "Identifier") || !BROWSER_GLOBAL_NAMES.has(argument.property.name)) return null;
-	return argument.property.name;
-};
-const browserGuardCoversGlobal = (guardName, browserGlobalName) => guardName === browserGlobalName || guardName === "window" || guardName === "document";
-const mergeAvailability = (leftAvailability, rightAvailability) => {
-	if (leftAvailability === null) return rightAvailability;
-	if (rightAvailability === null) return leftAvailability;
-	return leftAvailability === rightAvailability ? leftAvailability : null;
-};
-const readAvailabilityWhenPredicate = (expression, browserGlobalName, context, predicateResult) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return readAvailabilityWhenPredicate(unwrappedExpression.argument, browserGlobalName, context, !predicateResult);
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		if (unwrappedExpression.operator === "&&" && predicateResult) return mergeAvailability(readAvailabilityWhenPredicate(unwrappedExpression.left, browserGlobalName, context, true), readAvailabilityWhenPredicate(unwrappedExpression.right, browserGlobalName, context, true));
-		if (unwrappedExpression.operator === "||" && !predicateResult) return mergeAvailability(readAvailabilityWhenPredicate(unwrappedExpression.left, browserGlobalName, context, false), readAvailabilityWhenPredicate(unwrappedExpression.right, browserGlobalName, context, false));
-		return null;
-	}
-	if (!isNodeOfType(unwrappedExpression, "BinaryExpression")) return null;
-	const leftTypeofName = getTypeofBrowserGlobalName(unwrappedExpression.left, context);
-	const rightTypeofName = getTypeofBrowserGlobalName(unwrappedExpression.right, context);
-	const leftComparedType = isNodeOfType(unwrappedExpression.left, "Literal") && typeof unwrappedExpression.left.value === "string" ? unwrappedExpression.left.value : null;
-	const rightComparedType = isNodeOfType(unwrappedExpression.right, "Literal") && typeof unwrappedExpression.right.value === "string" ? unwrappedExpression.right.value : null;
-	const guardName = leftTypeofName && rightComparedType ? leftTypeofName : rightTypeofName && leftComparedType ? rightTypeofName : null;
-	const comparedType = leftTypeofName && rightComparedType ? rightComparedType : rightTypeofName && leftComparedType ? leftComparedType : null;
-	if (!guardName || !browserGuardCoversGlobal(guardName, browserGlobalName)) return null;
-	if (!comparedType) return null;
-	const isEquality = unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==";
-	const isInequality = unwrappedExpression.operator === "!==" || unwrappedExpression.operator === "!=";
-	if (!isEquality && !isInequality) return null;
-	const browserType = guardName === "matchMedia" ? "function" : "object";
-	const browserResult = isEquality ? browserType === comparedType : browserType !== comparedType;
-	if (browserResult === (isEquality ? comparedType === "undefined" : comparedType !== "undefined")) return null;
-	return predicateResult === browserResult;
-};
-const isInsideAvailabilityGuard = (node, browserGlobalName, context) => {
-	let currentNode = node;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isFunctionLike$1(parentNode) && !executesDuringRender(parentNode, context.scopes)) break;
-		if (isNodeOfType(parentNode, "LogicalExpression") && (parentNode.operator === "&&" || parentNode.operator === "||") && parentNode.right === currentNode && readAvailabilityWhenPredicate(parentNode.left, browserGlobalName, context, parentNode.operator === "&&") === true) return true;
-		if (isNodeOfType(parentNode, "ConditionalExpression")) {
-			if (parentNode.consequent === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, true) === true || parentNode.alternate === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, false) === true) return true;
-		}
-		if (isNodeOfType(parentNode, "IfStatement")) {
-			if (parentNode.consequent === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, true) === true || parentNode.alternate === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, false) === true) return true;
-		}
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const isAfterAvailabilityEarlyExit = (node, componentOrHookNode, browserGlobalName, context) => {
-	const enclosingFunction = findEnclosingFunction(node);
-	if (!enclosingFunction || enclosingFunction !== componentOrHookNode && !executesDuringRender(enclosingFunction, context.scopes) || !isFunctionLike$1(enclosingFunction) || !isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
-	let currentNode = node;
-	while (currentNode !== enclosingFunction) {
-		const parentNode = currentNode.parent;
-		if (!parentNode) return false;
-		if (isNodeOfType(parentNode, "BlockStatement")) for (const statement of parentNode.body) {
-			if (statement === currentNode) break;
-			if (!isNodeOfType(statement, "IfStatement")) continue;
-			if (readAvailabilityWhenPredicate(statement.test, browserGlobalName, context, false) === true && statementAlwaysExits(statement.consequent)) return true;
-			if (readAvailabilityWhenPredicate(statement.test, browserGlobalName, context, true) === true && statement.alternate && statementAlwaysExits(statement.alternate)) return true;
-		}
-		currentNode = parentNode;
-	}
-	return false;
-};
-const isTypeofProbe = (node) => {
-	const expressionRoot = findTransparentExpressionRoot(node);
-	const parentNode = expressionRoot.parent;
-	return isNodeOfType(parentNode, "UnaryExpression") && parentNode.operator === "typeof" && parentNode.argument === expressionRoot;
-};
-const noUnguardedBrowserGlobalInRenderOrHookInit = defineRule({
-	id: "no-unguarded-browser-global-in-render-or-hook-init",
-	title: "Browser global read during server render",
-	severity: "error",
-	category: "Correctness",
-	requires: ["ssr"],
-	recommendation: "Move browser-only reads into an effect or event, guard them behind a client-only render path, or use useSyncExternalStore with a stable server snapshot.",
-	create: (context) => {
-		if (isTestlikeFilename(context.filename)) return {};
-		if (classifyReactNativeFileTarget(context) === "react-native") return {};
-		let fileIsEmailTemplate = false;
-		const reportedNodes = /* @__PURE__ */ new Set();
-		const reportBrowserRead = (node, browserGlobalName) => {
-			if (reportedNodes.has(node) || isTypeofProbe(node)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(node, context.scopes);
-			if (!componentOrHookNode) return;
-			if (fileIsEmailTemplate) return;
-			if (isGeneratedImageRenderContext(context, findEnclosingJsxOpeningElement(node) ?? node)) return;
-			if (isGatedByFalsyInitialState(node, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode, context.scopes)) return;
-			if (isInsideAvailabilityGuard(node, browserGlobalName, context)) return;
-			if (isAfterAvailabilityEarlyExit(node, componentOrHookNode, browserGlobalName, context)) return;
-			reportedNodes.add(node);
-			context.report({
-				node,
-				message: `\`${browserGlobalName}\` is read while React is rendering on the server, where browser globals are unavailable. Move the read into an effect or event, or provide a stable server snapshot.`
-			});
-		};
-		return {
-			Program(node) {
-				fileIsEmailTemplate = hasEmailTemplateImport(node);
-			},
-			Identifier(node) {
-				if (!BROWSER_GLOBAL_NAMES.has(node.name)) return;
-				if (!context.scopes.isGlobalReference(node)) return;
-				reportBrowserRead(node, node.name);
-			},
-			MemberExpression(node) {
-				if (node.computed) return;
-				const objectNode = stripParenExpression(node.object);
-				if (!isNodeOfType(objectNode, "Identifier") || objectNode.name !== "globalThis" || !context.scopes.isGlobalReference(objectNode) || !isNodeOfType(node.property, "Identifier") || !BROWSER_GLOBAL_NAMES.has(node.property.name)) return;
-				reportBrowserRead(node, node.property.name);
-			}
-		};
-	}
-});
-//#endregion
 //#region src/plugin/constants/dom-aria-properties.ts
 const ARIA_PROPERTY_NAMES = new Set([
 	"activedescendant",
@@ -40846,123 +39751,6 @@ const preferUseEffectEvent = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/is-cleanup-return.ts
-const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
-	"each",
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"flatMap",
-	"forEach",
-	"map",
-	"reduce",
-	"reduceRight",
-	"some",
-	"sort",
-	"toSorted"
-]);
-const STATIC_ITERATOR_CALLBACK_METHOD_NAMES = new Set([
-	"from",
-	"fromAsync",
-	"groupBy"
-]);
-const unwrapChainExpression = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
-const isNullLiteral = (node) => isNodeOfType(node, "Literal") && node.value === null;
-const isListenerRemovalViaNullHandler = (callNode) => {
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	const callee = unwrapChainExpression(callNode.callee);
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "on" && isNullLiteral(callNode.arguments?.[1]);
-};
-const REFERENCE_BASED_REMOVAL_METHOD_NAMES = new Set([
-	"off",
-	"removeEventListener",
-	"removeListener"
-]);
-const isNoOpInlineHandlerRemoval = (callNode, methodName) => {
-	if (!REFERENCE_BASED_REMOVAL_METHOD_NAMES.has(methodName)) return false;
-	const handlerArgument = callNode.arguments?.[1];
-	return isNodeOfType(handlerArgument, "ArrowFunctionExpression") || isNodeOfType(handlerArgument, "FunctionExpression");
-};
-const isReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	const callNode = unwrapChainExpression(node);
-	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	if (isListenerRemovalViaNullHandler(callNode)) return true;
-	const callee = unwrapChainExpression(callNode.callee);
-	if (isNodeOfType(callee, "Identifier")) {
-		if (TIMER_CLEANUP_CALLEE_NAMES.has(callee.name)) return true;
-		if (CLEANUP_LIKE_RELEASE_CALLEE_NAMES.has(callee.name)) return true;
-		if (knownCleanupFunctionNames.has(callee.name)) return true;
-		return false;
-	}
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-		if (isNoOpInlineHandlerRemoval(callNode, callee.property.name)) return false;
-		if (BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier") && knownBoundSubscriptionNames.has(callee.object.name)) return true;
-		return GLOBAL_RELEASE_METHOD_NAMES.has(callee.property.name);
-	}
-	return false;
-};
-const isStaticIteratorCallbackCallee = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && (callee.object.name === "Array" || callee.object.name === "Map" || callee.object.name === "Object") && STATIC_ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
-const isIteratorCallbackArgument = (node) => {
-	const parentNode = node.parent;
-	if (!isNodeOfType(parentNode, "CallExpression")) return false;
-	if (!parentNode.arguments?.some((argument) => argument === node)) return false;
-	const callee = unwrapChainExpression(parentNode.callee);
-	if (parentNode.arguments[1] === node && isStaticIteratorCallbackCallee(callee)) return true;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
-};
-const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	let didFindRelease = false;
-	walkAst(node, (child) => {
-		if (didFindRelease) return false;
-		if (child !== node && isFunctionLike$1(child) && !isIteratorCallbackArgument(child)) return false;
-		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
-			didFindRelease = true;
-			return false;
-		}
-	});
-	return didFindRelease;
-};
-const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	if (!isFunctionLike$1(node)) return false;
-	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
-};
-const isProvablyNoOpCleanupFunction = (node) => {
-	if (!isFunctionLike$1(node)) return false;
-	let sawNoOpRemoval = false;
-	let sawOtherCall = false;
-	walkAst(node.body, (child) => {
-		if (sawOtherCall) return false;
-		if (isFunctionLike$1(child)) return false;
-		const callNode = unwrapChainExpression(child);
-		if (!isNodeOfType(callNode, "CallExpression")) return;
-		const callee = unwrapChainExpression(callNode.callee);
-		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && isNoOpInlineHandlerRemoval(callNode, callee.property.name)) {
-			sawNoOpRemoval = true;
-			return;
-		}
-		sawOtherCall = true;
-	});
-	return sawNoOpRemoval && !sawOtherCall;
-};
-const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames, options = {}) => {
-	if (!returnedValue) return false;
-	const unwrappedValue = unwrapChainExpression(returnedValue);
-	if (isNodeOfType(unwrappedValue, "Literal") && unwrappedValue.value === null) return false;
-	if (isNodeOfType(unwrappedValue, "Identifier")) {
-		if (unwrappedValue.name === "undefined") return false;
-		if (knownCleanupFunctionNames.has(unwrappedValue.name)) return true;
-		return options.allowOpaqueReturn === true && !knownBoundSubscriptionNames.has(unwrappedValue.name);
-	}
-	if (isCleanupReturningSubscribeLikeCallExpression(unwrappedValue)) return true;
-	if (isProvablyNoOpCleanupFunction(unwrappedValue)) return false;
-	if (options.allowOpaqueReturn === true && !isSubscribeLikeCallExpression(unwrappedValue)) return true;
-	if (isCleanupFunctionLike(unwrappedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames)) return true;
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/prefer-use-sync-external-store.ts
 const findUseEffectsInComponent = (componentBody) => {
 	const effectCalls = [];
@@ -42431,7 +41219,7 @@ const renderingHydrationMismatchTime = defineRule({
 	title: "Time or random value in JSX",
 	severity: "warn",
 	category: "Correctness",
-	requires: ["ssr"],
+	disabledWhen: ["vite", "cra"],
 	recommendation: "Move time or random values into useEffect+useState so they only run in the browser, or add suppressHydrationWarning to the parent if it's intentional",
 	create: (context) => {
 		const isTestlikeFile = isTestlikeFilename(context.filename);
@@ -42445,7 +41233,8 @@ const renderingHydrationMismatchTime = defineRule({
 			const matched = NONDETERMINISTIC_RENDER_PATTERNS.find((pattern) => pattern.matches(node.expression));
 			if (matched) {
 				if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
-				if (isGatedByFalsyInitialState(node, context.scopes)) return;
+				if (isInsideClientOnlyGuard(node)) return;
+				if (isGatedByFalsyInitialState(node)) return;
 				if (isInsideMotionTransitionAttribute(node)) return;
 				context.report({
 					node,
@@ -42454,10 +41243,11 @@ const renderingHydrationMismatchTime = defineRule({
 				return;
 			}
 			walkAst(node.expression, (child) => {
-				if (isFunctionLike$1(child) && !executesDuringRender(child, context.scopes)) return false;
+				if (isFunctionLike$1(child) && !executesDuringRender(child)) return false;
 				for (const pattern of NONDETERMINISTIC_RENDER_PATTERNS) if (pattern.matches(child)) {
 					if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
-					if (isGatedByFalsyInitialState(child, context.scopes)) return;
+					if (isInsideClientOnlyGuard(child)) return;
+					if (isGatedByFalsyInitialState(child)) return;
 					if (isInsideMotionTransitionAttribute(child)) return;
 					if (pattern.display === "new Date()" && isYearOnlyDateRead(child)) return;
 					context.report({
@@ -55794,18 +54584,6 @@ const reactDoctorRules = [
 			category: "Accessibility"
 		}
 	},
-	{
-		key: "react-doctor/no-hydration-branch-on-browser-global",
-		id: "no-hydration-branch-on-browser-global",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noHydrationBranchOnBrowserGlobal,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noHydrationBranchOnBrowserGlobal.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-img-lazy-with-high-fetchpriority",
 		id: "no-img-lazy-with-high-fetchpriority",
@@ -56569,18 +55347,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noUnescapedEntities.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-unguarded-browser-global-in-render-or-hook-init",
-		id: "no-unguarded-browser-global-in-render-or-hook-init",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noUnguardedBrowserGlobalInRenderOrHookInit,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noUnguardedBrowserGlobalInRenderOrHookInit.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-unknown-property",
 		id: "no-unknown-property",
@@ -58913,12 +57679,10 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"nextjs-no-use-search-params-without-suspense",
 	"no-dynamic-import-path",
 	"no-full-lodash-import",
-	"no-hydration-branch-on-browser-global",
 	"no-indeterminate-attribute",
 	"no-locale-format-in-render",
 	"no-match-media-in-state-initializer",
 	"no-mutating-reducer-state",
-	"no-unguarded-browser-global-in-render-or-hook-init",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
 	"rn-no-legacy-shadow-styles",
@@ -59052,12 +57816,10 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["nextjs-no-use-search-params-without-suspense", collectNextjsSearchParamsDependencies],
 	["no-dynamic-import-path", collectNearestManifestDependencies],
 	["no-full-lodash-import", collectNearestManifestDependencies],
-	["no-hydration-branch-on-browser-global", collectNearestManifestDependencies],
 	["no-indeterminate-attribute", collectNearestManifestDependencies],
 	["no-locale-format-in-render", collectNearestManifestDependencies],
 	["no-match-media-in-state-initializer", collectNearestManifestDependencies],
 	["no-mutating-reducer-state", collectMutatingReducerDependencies],
-	["no-unguarded-browser-global-in-render-or-hook-init", collectNearestManifestDependencies],
 	["prefer-dynamic-import", collectNearestManifestDependencies],
 	["rendering-hydration-mismatch-time", collectNearestManifestDependencies],
 	["rn-no-legacy-shadow-styles", collectLegacyArchDependencies],