oxlint-plugin-react-doctor 0.8.1-dev.b852961 → 0.8.1-dev.c9f2c4b

package/dist/index.js

@@ -762,7 +762,7 @@ const EXTERNAL_SYNC_MEMBER_METHOD_NAMES = new Set([
 	"put",
 	"patch"
 ]);
-new Set([
+const EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS = new Set([
 	...FETCH_MEMBER_OBJECTS,
 	"api",
 	"client",
@@ -9008,16 +9008,6 @@ const hasVisibleBindingNamed = (node, bindingName, scopes) => {
 	}
 };
 //#endregion
-//#region src/plugin/utils/is-global-match-media-call.ts
-const isGlobalMatchMediaCall = (node, scopes) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (isNodeOfType(callee, "Identifier")) return callee.name === "matchMedia" && scopes.isGlobalReference(callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "matchMedia") return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && (receiver.name === "window" || receiver.name === "globalThis") && scopes.isGlobalReference(receiver);
-};
-//#endregion
 //#region src/plugin/utils/is-proven-browser-api-receiver.ts
 const DOM_EVENT_TARGET_TYPE_NAMES = new Set([
 	"AbortSignal",
@@ -9164,10 +9154,8 @@ const getProvenDomEventTargetPrototypeOwnerNames = (rawExpression, scopes, visit
 		if (memberName === "body" || memberName === "documentElement") return getDomPrototypeOwnerNamesForType("HTMLElement");
 	}
 	if (isNodeOfType(expression, "CallExpression")) {
-		if (isGlobalMatchMediaCall(expression, scopes)) return getDomPrototypeOwnerNamesForType("MediaQueryList");
 		const callee = stripParenExpression(expression.callee);
 		const methodName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : null;
-		if (methodName === "matchMedia" && isNodeOfType(callee, "MemberExpression") && getProvenDomEventTargetPrototypeOwnerNames(callee.object, scopes, visitedSymbolIds).includes("Window")) return getDomPrototypeOwnerNamesForType("MediaQueryList");
 		if (methodName === "createElement") return getDomPrototypeOwnerNamesForType("HTMLElement");
 		if (methodName === "createElementNS") return getDomPrototypeOwnerNamesForType("SVGElement");
 		if (methodName && DOM_EVENT_TARGET_FACTORY_METHOD_NAMES.has(methodName)) return getDomPrototypeOwnerNamesForType("Element");
@@ -13827,116 +13815,6 @@ const findRenderPhaseComponentOrHook = (node, scopes) => {
 	return null;
 };
 //#endregion
-//#region src/plugin/utils/get-final-sequence-expression-value.ts
-const getFinalSequenceExpressionValue = (expression) => {
-	let finalExpression = stripParenExpression(expression);
-	while (isNodeOfType(finalExpression, "SequenceExpression")) {
-		const sequenceResult = finalExpression.expressions.at(-1);
-		if (!sequenceResult) break;
-		finalExpression = stripParenExpression(sequenceResult);
-	}
-	return finalExpression;
-};
-//#endregion
-//#region src/plugin/utils/collect-expression-path-coverage-nodes.ts
-const collectExpressionPathCoverageNodes = (owner, matchingNodes, context, expressionBoundary = owner) => {
-	const coverageNodes = /* @__PURE__ */ new Set();
-	const pendingNodes = matchingNodes.filter((matchingNode) => {
-		if (context.cfg.enclosingFunction(matchingNode) !== owner) return false;
-		let currentNode = matchingNode;
-		while (currentNode && currentNode !== expressionBoundary) currentNode = currentNode.parent ?? null;
-		return currentNode === expressionBoundary;
-	});
-	const visitedNodes = new Set(pendingNodes);
-	const coveredBranchesByConditional = /* @__PURE__ */ new Map();
-	while (pendingNodes.length > 0) {
-		const coverageCandidate = pendingNodes.pop();
-		if (!coverageCandidate) break;
-		if (coverageCandidate === expressionBoundary) {
-			coverageNodes.add(coverageCandidate);
-			continue;
-		}
-		let currentChild = coverageCandidate;
-		let currentParent = currentChild.parent ?? null;
-		let conditionalExpression = null;
-		let conditionalBranch = null;
-		let isBlockedByNonExhaustiveExpression = false;
-		while (currentParent && currentParent !== expressionBoundary) {
-			if (isNodeOfType(currentParent, "ConditionalExpression")) {
-				const isConsequent = currentParent.consequent === currentChild;
-				const isAlternate = currentParent.alternate === currentChild;
-				if (isConsequent || isAlternate) {
-					const staticTestValue = readStaticBoolean(getFinalSequenceExpressionValue(currentParent.test));
-					if (staticTestValue !== null) {
-						if (staticTestValue !== isConsequent) {
-							isBlockedByNonExhaustiveExpression = true;
-							break;
-						}
-						currentChild = currentParent;
-						currentParent = currentChild.parent ?? null;
-						continue;
-					}
-					conditionalExpression = currentParent;
-					conditionalBranch = isConsequent ? "consequent" : "alternate";
-					break;
-				}
-			}
-			if (isNodeOfType(currentParent, "LogicalExpression") && currentParent.right === currentChild) {
-				const staticLeftValue = readStaticBoolean(getFinalSequenceExpressionValue(currentParent.left));
-				if (!(currentParent.operator === "&&" && staticLeftValue === true || currentParent.operator === "||" && staticLeftValue === false)) {
-					isBlockedByNonExhaustiveExpression = true;
-					break;
-				}
-			}
-			if (isNodeOfType(currentParent, "AssignmentPattern") && currentParent.right === currentChild) {
-				isBlockedByNonExhaustiveExpression = true;
-				break;
-			}
-			currentChild = currentParent;
-			currentParent = currentChild.parent ?? null;
-		}
-		if (isBlockedByNonExhaustiveExpression) continue;
-		if (!conditionalExpression || !conditionalBranch) {
-			coverageNodes.add(coverageCandidate);
-			continue;
-		}
-		const coveredBranches = coveredBranchesByConditional.get(conditionalExpression) ?? /* @__PURE__ */ new Set();
-		coveredBranches.add(conditionalBranch);
-		coveredBranchesByConditional.set(conditionalExpression, coveredBranches);
-		if (coveredBranches.has("alternate") && coveredBranches.has("consequent") && !visitedNodes.has(conditionalExpression)) {
-			visitedNodes.add(conditionalExpression);
-			pendingNodes.push(conditionalExpression);
-		}
-	}
-	return coverageNodes;
-};
-//#endregion
-//#region src/plugin/utils/do-nodes-cover-every-path-from-function-entry.ts
-const doNodesCoverEveryPathFromFunctionEntry = (owner, matchingNodes, context, options = {}) => {
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return false;
-	const matchingBlocks = new Set([...collectExpressionPathCoverageNodes(owner, matchingNodes, context)].flatMap((matchingNode) => {
-		const matchingBlock = functionCfg.blockOf(matchingNode);
-		return matchingBlock ? [matchingBlock] : [];
-	}));
-	if (matchingBlocks.size === 0) return false;
-	const visitedBlocks = new Set([functionCfg.entry]);
-	const pendingBlocks = [functionCfg.entry];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		if (matchingBlocks.has(currentBlock)) continue;
-		for (const edge of currentBlock.successors) {
-			if (options.ignoreThrowEdges && edge.kind === "throw") continue;
-			if (edge.to === functionCfg.exit) return false;
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return true;
-};
-//#endregion
 //#region src/plugin/utils/get-function-binding-name.ts
 const getFunctionBindingIdentifier$1 = (functionNode) => {
 	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
@@ -13974,19 +13852,14 @@ const isAstDescendant = (inner, outer) => {
 };
 //#endregion
 //#region src/plugin/utils/react-ref-origin.ts
-const REACT_REF_API_NAMES = new Set(["createRef", "useRef"]);
-const resolveReactRefSymbol = (memberExpression, scopes, options = {}) => {
+const resolveReactRefSymbol = (memberExpression, scopes) => {
 	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
 	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticPropertyName(memberExpression) !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
 	const symbol = resolveConstIdentifierAlias(receiver, scopes);
 	if (!symbol?.initializer) return null;
 	const initializer = stripParenExpression(symbol.initializer);
 	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, options.includeCreateRef ? REACT_REF_API_NAMES : "useRef", scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: options.allowUnboundBareCalls,
-		resolveNamedAliases: options.resolveNamedAliases
-	}) ? symbol : null;
+	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
 };
 const resolveReactRefCurrentOriginSymbol = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(node);
@@ -14085,35 +13958,9 @@ const isNodeReachableWithinFunction = (node, context) => {
 	return false;
 };
 //#endregion
-//#region src/plugin/utils/is-within-assignment-target.ts
-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;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
 const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
 const REPLAYABLE_ITERATOR_COLLECTION_CACHE = /* @__PURE__ */ new WeakMap();
-const REPLAY_ENTRY_DROPPING_ARRAY_METHOD_NAMES = new Set([
-	"pop",
-	"shift",
-	"splice",
-	"fill",
-	"copyWithin"
-]);
-const REPLAY_ENTRY_DROPPING_COLLECTION_METHOD_NAMES = new Set([
-	"clear",
-	"delete",
-	"set"
-]);
 const REACT_REF_EFFECT_ANALYSIS_CACHE = /* @__PURE__ */ new WeakMap();
 const RESOURCE_NOUN_BY_KIND = {
 	subscribe: "subscription",
@@ -14154,92 +14001,6 @@ const resolveExpressionKey = (expression, context, visitedSymbolIds = /* @__PURE
 	}
 	return null;
 };
-const resolveForEachProjection = (expression, context) => {
-	if (!expression) return null;
-	let currentExpression = stripParenExpression(expression);
-	const memberNames = [];
-	while (isNodeOfType(currentExpression, "MemberExpression") && !currentExpression.computed) {
-		if (!isNodeOfType(currentExpression.property, "Identifier")) return null;
-		memberNames.unshift(currentExpression.property.name);
-		currentExpression = stripParenExpression(currentExpression.object);
-	}
-	if (!isNodeOfType(currentExpression, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(currentExpression);
-	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 forEachCall = findEnclosingForEachCall(callbackNode);
-	if (!forEachCall) return null;
-	const forEachCallee = stripParenExpression(forEachCall.callee);
-	if (!isNodeOfType(forEachCallee, "MemberExpression")) return null;
-	const collectionKey = resolveExpressionKey(forEachCallee.object, context);
-	if (!collectionKey) return null;
-	const firstParameter = callbackNode.params[0];
-	const bindingProperty = symbol.bindingIdentifier.parent;
-	const propertyName = isNodeOfType(firstParameter, "ObjectPattern") && isNodeOfType(bindingProperty, "Property") && bindingProperty.parent === firstParameter && bindingProperty.value === symbol.bindingIdentifier ? getStaticPropertyKeyName(bindingProperty) : null;
-	const parameterProjection = firstParameter === symbol.bindingIdentifier ? "value" : propertyName;
-	if (!parameterProjection) return null;
-	return {
-		collectionKey,
-		projectionKey: [parameterProjection, ...memberNames].join(".")
-	};
-};
-const resolveForEachProjectionKey = (expression, context) => {
-	const projection = resolveForEachProjection(expression, context);
-	return projection ? `forEach:${projection.collectionKey}:${projection.projectionKey}` : null;
-};
-const resolveResourceIdentityKey = (expression, context) => resolveForEachProjectionKey(expression, context) ?? resolveExpressionKey(expression, context);
-const resolveEventListenerCaptureIdentityKey = (optionsNode, context, allowOpaqueOptionsIdentity) => {
-	const capture = resolveEventListenerCapture(optionsNode, { allowIndeterminateEntries: true });
-	if (capture !== null) return `capture:${String(capture)}`;
-	if (!optionsNode) return null;
-	const unwrappedOptions = stripParenExpression(optionsNode);
-	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) {
-		const optionsKey = allowOpaqueOptionsIdentity ? resolveResourceIdentityKey(unwrappedOptions, context) : null;
-		return optionsKey ? `options:${optionsKey}` : null;
-	}
-	let captureKey = "capture:false";
-	for (const property of unwrappedOptions.properties ?? []) {
-		if (!isNodeOfType(property, "Property")) {
-			captureKey = null;
-			continue;
-		}
-		const propertyName = getStaticPropertyKeyName(property);
-		if (propertyName === null || !property.computed && propertyName === "__proto__") {
-			captureKey = null;
-			continue;
-		}
-		if (propertyName === "capture") {
-			const propertyValueKey = resolveResourceIdentityKey(property.value, context);
-			captureKey = propertyValueKey ? `capture-value:${propertyValueKey}` : null;
-		}
-	}
-	return captureKey;
-};
-const resolveEventListenerCaptureProjection = (optionsNode, context) => {
-	if (!optionsNode) return null;
-	const unwrappedOptions = stripParenExpression(optionsNode);
-	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) return resolveForEachProjection(unwrappedOptions, context);
-	let captureProjection = null;
-	for (const property of unwrappedOptions.properties ?? []) {
-		if (!isNodeOfType(property, "Property")) {
-			captureProjection = null;
-			continue;
-		}
-		const propertyName = getStaticPropertyKeyName(property);
-		if (propertyName === null || !property.computed && propertyName === "__proto__") {
-			captureProjection = null;
-			continue;
-		}
-		if (propertyName === "capture") captureProjection = resolveForEachProjection(property.value, context);
-	}
-	return captureProjection;
-};
-const doEventListenerCapturesMatch = (registrationOptions, releaseOptions, context, allowOpaqueOptionsIdentity = false) => {
-	const registrationCaptureKey = resolveEventListenerCaptureIdentityKey(registrationOptions, context, allowOpaqueOptionsIdentity);
-	return registrationCaptureKey !== null && registrationCaptureKey === resolveEventListenerCaptureIdentityKey(releaseOptions, context, allowOpaqueOptionsIdentity);
-};
 const findAssignedResourceKey = (resourceNode, context) => {
 	let currentNode = resourceNode;
 	let parentNode = currentNode.parent;
@@ -14251,30 +14012,6 @@ const findAssignedResourceKey = (resourceNode, context) => {
 	if (isNodeOfType(parentNode, "AssignmentExpression") && parentNode.right === currentNode) return resolveExpressionKey(parentNode.left, context);
 	return null;
 };
-const resolveStableMediaQueryListenerIdentityKey = (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 || visitedSymbolIds.has(symbol.id) || !symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier))) return null;
-		const initializer = getDirectUnreassignedInitializer(symbol);
-		if (!initializer) return `symbol:${symbol.id}`;
-		const unwrappedInitializer = stripParenExpression(initializer);
-		if (!isNodeOfType(unwrappedInitializer, "Identifier")) return `symbol:${symbol.id}`;
-		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-		nextVisitedSymbolIds.add(symbol.id);
-		return resolveStableMediaQueryListenerIdentityKey(unwrappedInitializer, context, nextVisitedSymbolIds) ?? `symbol:${symbol.id}`;
-	}
-	if (isFunctionLike$1(unwrappedExpression)) {
-		const rangeStart = getRangeStart(unwrappedExpression);
-		return rangeStart === null ? null : `function:${rangeStart}`;
-	}
-	return null;
-};
-const isProvenLegacyMediaQueryListMethodCall = (callNode, methodName, context) => {
-	const callee = stripParenExpression(callNode.callee);
-	return callNode.arguments?.length === 1 && isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName && getProvenDomEventTargetPrototypeOwnerNames(callee.object, context.scopes).includes("MediaQueryList");
-};
 const getCallRegistrationDetails = (callNode, context) => {
 	const callee = stripParenExpression(callNode.callee);
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return {
@@ -14283,17 +14020,11 @@ const getCallRegistrationDetails = (callNode, context) => {
 		eventKey: null,
 		handlerKey: null
 	};
-	if (isProvenLegacyMediaQueryListMethodCall(callNode, "addListener", context)) return {
-		receiverKey: resolveStableMediaQueryListenerIdentityKey(callee.object, context),
-		registrationVerbName: callee.property.name,
-		eventKey: null,
-		handlerKey: resolveStableMediaQueryListenerIdentityKey(callNode.arguments?.[0], context)
-	};
 	return {
-		receiverKey: resolveResourceIdentityKey(callee.object, context),
+		receiverKey: resolveExpressionKey(callee.object, context),
 		registrationVerbName: callee.property.name,
-		eventKey: resolveResourceIdentityKey(callNode.arguments?.[0], context),
-		handlerKey: resolveResourceIdentityKey(callNode.arguments?.[1], context)
+		eventKey: resolveExpressionKey(callNode.arguments?.[0], context),
+		handlerKey: resolveExpressionKey(callNode.arguments?.[1], context)
 	};
 };
 const findSubscribeLikeUsages = (callback, context) => {
@@ -14393,6 +14124,30 @@ const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, conte
 	}
 	return matchingBlocks.size > 0;
 };
+const doMatchingNodesCoverEveryPathFromFunctionEntry = (owner, matchingNodes, context) => {
+	const functionCfg = context.cfg.cfgFor(owner);
+	if (!functionCfg) return false;
+	const matchingBlocks = new Set(matchingNodes.flatMap((matchingNode) => {
+		if (context.cfg.enclosingFunction(matchingNode) !== owner) return [];
+		const matchingBlock = functionCfg.blockOf(matchingNode);
+		return matchingBlock ? [matchingBlock] : [];
+	}));
+	if (matchingBlocks.size === 0) return false;
+	const visitedBlocks = new Set([functionCfg.entry]);
+	const pendingBlocks = [functionCfg.entry];
+	while (pendingBlocks.length > 0) {
+		const currentBlock = pendingBlocks.pop();
+		if (!currentBlock) break;
+		if (matchingBlocks.has(currentBlock)) continue;
+		for (const edge of currentBlock.successors) {
+			if (edge.to === functionCfg.exit) return false;
+			if (visitedBlocks.has(edge.to)) continue;
+			visitedBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return true;
+};
 const removeSynchronouslyReleasedUsages = (callback, usages, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
@@ -14635,6 +14390,18 @@ const findPushedResourceCollectionKey = (usage, context) => {
 		return memberNode.property.name === "forEach" || memberNode.property.name === "push";
 	}) ? resolveExpressionKey(pushCallee.object, context) : 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);
@@ -14682,8 +14449,8 @@ const isSynchronousIteratorCallback = (functionNode) => {
 	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$2.has(callee.property.name) && callNode.arguments?.[0] === functionNode;
 };
 const findEnclosingForEachCall = (node) => {
-	const callbackNode = isFunctionLike$1(node) ? node : findEnclosingFunction$1(node);
-	if (!callbackNode || !isFunctionLike$1(callbackNode) || callbackNode.async || callbackNode.generator) return null;
+	const callbackNode = findEnclosingFunction$1(node);
+	if (!callbackNode) return null;
 	const callNode = callbackNode.parent;
 	if (!isNodeOfType(callNode, "CallExpression") || callNode.arguments?.[0] !== callbackNode) return null;
 	const callee = stripParenExpression(callNode.callee);
@@ -14758,7 +14525,7 @@ const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visite
 		const helperFunction = isNodeOfType(stableHelperFunction, "Identifier") ? resolveSingleAssignedCleanupFunction(stableHelperFunction, usage, context) : stableHelperFunction;
 		if (helperFunction && isFunctionLike$1(helperFunction) && !helperFunction.async && !helperFunction.generator && doesCleanupFunctionReleaseUsage(helperFunction, usage, context, new Set(visitedFunctions))) matchingLoopOrHelperAnchors.push(cleanupCall);
 	});
-	return didCleanupFunctionMatch || doNodesCoverEveryPathFromFunctionEntry(cleanupFunction, matchingLoopOrHelperAnchors, context);
+	return didCleanupFunctionMatch || doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, matchingLoopOrHelperAnchors, context);
 };
 const doesBoundCleanupReleaseUsage = (expression, usage, context) => {
 	const callExpression = stripParenExpression(expression);
@@ -14787,7 +14554,7 @@ const callbackReturnsCleanupForUsage = (callback, usage, context) => {
 	walkInsideStatementBlocks(callback.body, (child) => {
 		if (isNodeOfType(child, "ReturnStatement") && child.argument && doesReturnedValueReleaseUsage(stripParenExpression(child.argument))) matchingCleanupReturns.push(child);
 	});
-	return doNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
+	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
 };
 const doesTestRequireLiveExpressionKey = (test, expressionKey, context) => {
 	if (resolveExpressionKey(test, context) === expressionKey) return true;
@@ -14830,7 +14597,7 @@ const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 		const helperFunction = resolveStableValue(child.callee, context);
 		if (helperFunction && isFunctionLike$1(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context)) matchingReleaseAnchors.push(handleGuard ?? child);
 	});
-	return doNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
+	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
 };
 const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	const componentFunction = findEnclosingFunction$1(callback);
@@ -15081,7 +14848,7 @@ const hasGuardedRefOwnedNestedCleanup = (callback, usage, cleanupReturns, contex
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	const usageExpression = findTransparentExpressionRoot(usage.node);
 	const usageAssignment = usageExpression.parent;
-	if (usage.kind !== "subscribe" && usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !resolveReactRefSymbol(stripParenExpression(usageAssignment.left), context.scopes) || !collectSynchronouslyEffectInvokedFunctions(callback).has(usageFunction) || !cleanupReturnsReleaseUsage(cleanupReturns, usage, context) || !doNodesCoverEveryPathFromFunctionEntry(callback, cleanupReturns, context)) return false;
+	if (usage.kind !== "subscribe" && usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !resolveReactRefSymbol(stripParenExpression(usageAssignment.left), context.scopes) || !collectSynchronouslyEffectInvokedFunctions(callback).has(usageFunction) || !cleanupReturnsReleaseUsage(cleanupReturns, usage, context) || !doMatchingNodesCoverEveryPathFromFunctionEntry(callback, cleanupReturns, context)) return false;
 	const cleanupFunctions = cleanupReturns.flatMap((cleanupReturn) => {
 		if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return [];
 		const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
@@ -15129,7 +14896,7 @@ const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) =>
 				});
 			}
 		});
-		if (!doNodesCoverEveryPathFromFunctionEntry(cleanupFunction, globalReleaseProofs.map((releaseProof) => releaseProof.anchor), context)) return false;
+		if (!doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, globalReleaseProofs.map((releaseProof) => releaseProof.anchor), context)) return false;
 		globalReleaseProofsByCleanup.set(cleanupFunction, globalReleaseProofs);
 	}
 	const handleAssignments = handleSymbol.references.filter((reference) => isWithinAssignmentTarget(reference.identifier));
@@ -15332,7 +15099,9 @@ const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
 	const nodeParameterKey = resolveExpressionKey(usageFunction.params?.[0], context);
 	const releaseReceiverKey = resolveExpressionKey(releaseCallee.object, context);
 	if (registrationReceiverKey === null || registrationReceiverKey !== nodeParameterKey || releaseReceiverKey === null || usage.eventKey === null || usage.eventKey !== resolveExpressionKey(releaseCall.arguments?.[0], context) || usage.handlerKey === null || usage.handlerKey !== resolveExpressionKey(releaseCall.arguments?.[1], context)) return false;
-	if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], releaseCall.arguments?.[2], context)) return false;
+	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
+	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
+	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
 	const releaseStart = getRangeStart(releaseCall);
 	const matchingOwnershipAssignments = [];
 	const usageFunctionBody = usageFunction.body;
@@ -15342,127 +15111,7 @@ const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
 	});
 	const releaseAnchor = findLiveExpressionGuardForRelease(releaseCall, usageFunction, releaseReceiverKey, context) ?? releaseCall;
 	const safeOwnershipAssignments = matchingOwnershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, [releaseAnchor], usageFunction, context));
-	return doNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
-};
-const findDirectExhaustiveForEachCleanupFunction = (releaseNode, requiredCollectionKeys, context) => {
-	let currentNode = findTransparentExpressionRoot(releaseNode);
-	const visitedFunctions = /* @__PURE__ */ new Set();
-	const replayedCollectionKeys = /* @__PURE__ */ new Set();
-	while (true) {
-		const ownerFunction = findEnclosingFunction$1(currentNode);
-		if (!ownerFunction || !isFunctionLike$1(ownerFunction) || visitedFunctions.has(ownerFunction)) return null;
-		visitedFunctions.add(ownerFunction);
-		const isDirectConciseBody = ownerFunction.body === currentNode;
-		const statementNode = currentNode.parent;
-		const isDirectBlockStatement = isNodeOfType(ownerFunction.body, "BlockStatement") && isNodeOfType(statementNode, "ExpressionStatement") && statementNode.parent === ownerFunction.body;
-		if (!isDirectConciseBody && !isDirectBlockStatement || !doNodesCoverEveryPathFromFunctionEntry(ownerFunction, [isDirectBlockStatement ? statementNode : currentNode], context)) return null;
-		const forEachCall = findEnclosingForEachCall(ownerFunction);
-		if (!forEachCall) return replayedCollectionKeys.size === requiredCollectionKeys.size && isReturnedEffectCleanupFunction(ownerFunction, context) ? ownerFunction : null;
-		const forEachCallee = stripParenExpression(forEachCall.callee);
-		if (!isNodeOfType(forEachCallee, "MemberExpression")) return null;
-		const collectionKey = resolveExpressionKey(forEachCallee.object, context);
-		if (!collectionKey || !requiredCollectionKeys.has(collectionKey)) return null;
-		replayedCollectionKeys.add(collectionKey);
-		currentNode = findTransparentExpressionRoot(forEachCall);
-	}
-};
-const collectReplayOwnerFunctions = (usageNode) => {
-	const ownerFunctions = /* @__PURE__ */ new Set();
-	let currentNode = usageNode;
-	while (true) {
-		const ownerFunction = findEnclosingFunction$1(currentNode);
-		if (!ownerFunction || !isFunctionLike$1(ownerFunction) || ownerFunctions.has(ownerFunction)) break;
-		ownerFunctions.add(ownerFunction);
-		const forEachCall = findEnclosingForEachCall(ownerFunction);
-		if (!forEachCall) break;
-		currentNode = forEachCall;
-	}
-	return ownerFunctions;
-};
-const hasCollectionMutationBeforeRelease = (usageNode, releaseNode, collectionKeys, context) => {
-	const usageStart = getRangeStart(usageNode);
-	const releaseStart = getRangeStart(releaseNode);
-	if (usageStart === null || releaseStart === null) return true;
-	const setupOwnerFunctions = collectReplayOwnerFunctions(usageNode);
-	const cleanupOwnerFunctions = collectReplayOwnerFunctions(releaseNode);
-	let programNode = usageNode;
-	while (programNode.parent) programNode = programNode.parent;
-	let didFindMutation = false;
-	walkAst(programNode, (child) => {
-		if (didFindMutation) return false;
-		const childStart = getRangeStart(child);
-		if (childStart === null) return;
-		const ownerFunction = context.cfg.enclosingFunction(child);
-		if (!ownerFunction) return;
-		const isAfterRegistration = setupOwnerFunctions.has(ownerFunction) && childStart > usageStart;
-		const isBeforeRelease = cleanupOwnerFunctions.has(ownerFunction) && childStart < releaseStart;
-		if (!isAfterRegistration && !isBeforeRelease) return;
-		if (isNodeOfType(child, "AssignmentExpression")) {
-			const assignmentKey = resolveExpressionKey(child.left, context);
-			const assignmentTarget = stripParenExpression(child.left);
-			if (assignmentKey && [...collectionKeys].some((collectionKey) => assignmentKey === collectionKey || assignmentKey === `${collectionKey}.length`) || isNodeOfType(assignmentTarget, "MemberExpression") && assignmentTarget.computed && collectionKeys.has(resolveExpressionKey(assignmentTarget.object, context) ?? "")) {
-				didFindMutation = true;
-				return false;
-			}
-			return;
-		}
-		if (isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
-			const deletedMember = stripParenExpression(child.argument);
-			if (!isNodeOfType(deletedMember, "MemberExpression")) return;
-			if (collectionKeys.has(resolveExpressionKey(deletedMember.object, context) ?? "")) {
-				didFindMutation = true;
-				return false;
-			}
-			return;
-		}
-		if (isNodeOfType(child, "UpdateExpression")) {
-			const updatedKey = resolveExpressionKey(child.argument, context);
-			if (updatedKey && [...collectionKeys].some((collectionKey) => updatedKey === `${collectionKey}.length`)) {
-				didFindMutation = true;
-				return false;
-			}
-			return;
-		}
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = stripParenExpression(child.callee);
-		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || !REPLAY_ENTRY_DROPPING_ARRAY_METHOD_NAMES.has(callee.property.name) && !REPLAY_ENTRY_DROPPING_COLLECTION_METHOD_NAMES.has(callee.property.name) || !collectionKeys.has(resolveExpressionKey(callee.object, context) ?? "")) return;
-		didFindMutation = true;
-		return false;
-	});
-	return didFindMutation;
-};
-const usesUnaryListenerSignature = (registrationCall, releaseCall) => getCalleeName$1(registrationCall) === "addListener" && registrationCall.arguments?.length === 1 && releaseCall.arguments?.length === 1;
-const hasSafeForEachProjectionCleanup = (registrationCall, releaseCall, context) => {
-	const registrationCallee = stripParenExpression(registrationCall.callee);
-	const releaseCallee = stripParenExpression(releaseCall.callee);
-	if (!isNodeOfType(registrationCallee, "MemberExpression") || !isNodeOfType(releaseCallee, "MemberExpression")) return true;
-	const registrationVerbName = getCalleeName$1(registrationCall);
-	const releaseVerbName = getCalleeName$1(releaseCall);
-	const releaseHandler = releaseCall.arguments?.[usesUnaryListenerSignature(registrationCall, releaseCall) ? 0 : 1];
-	const releaseFunction = findEnclosingFunction$1(releaseCall);
-	const registrationEventKey = resolveResourceIdentityKey(registrationCall.arguments?.[0], context);
-	const releaseEventKey = resolveResourceIdentityKey(releaseCall.arguments?.[0], context);
-	const doesHandlerlessOffReleaseEveryRegistration = releaseVerbName === "off" && !releaseHandler && (releaseCall.arguments?.length === 0 || registrationEventKey !== null && registrationEventKey === releaseEventKey);
-	if (Boolean(releaseFunction && isFunctionLike$1(releaseFunction) && isReturnedEffectCleanupFunction(releaseFunction, context) && doNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseCall], context)) && (releaseVerbName !== null && UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName) || doesHandlerlessOffReleaseEveryRegistration)) return true;
-	const projections = [
-		registrationCallee.object,
-		registrationCall.arguments?.[0],
-		registrationCall.arguments?.[1],
-		releaseCallee.object,
-		releaseCall.arguments?.[0],
-		releaseCall.arguments?.[1]
-	].flatMap((expression) => {
-		const projection = resolveForEachProjection(expression, context);
-		return projection ? [projection] : [];
-	});
-	if (registrationVerbName === "addEventListener" && releaseVerbName === "removeEventListener") for (const optionsNode of [registrationCall.arguments?.[2], releaseCall.arguments?.[2]]) {
-		const captureProjection = resolveEventListenerCaptureProjection(optionsNode, context);
-		if (captureProjection) projections.push(captureProjection);
-	}
-	if (projections.length === 0) return true;
-	const collectionKeys = new Set(projections.map((projection) => projection.collectionKey));
-	if (!findDirectExhaustiveForEachCleanupFunction(releaseCall, collectionKeys, context)) return false;
-	return !hasCollectionMutationBeforeRelease(registrationCall, releaseCall, collectionKeys, context);
+	return doMatchingNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
 };
 const doesReleaseCallMatchUsage = (node, usage, context) => {
 	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
@@ -15479,8 +15128,8 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	const releaseVerbName = getReleaseVerbName(callNode);
 	if (!releaseVerbName) return false;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
-	const releaseReceiverKey = resolveResourceIdentityKey(callee.object, context);
-	const releaseEventKey = resolveResourceIdentityKey(callNode.arguments?.[0], context);
+	const releaseReceiverKey = resolveExpressionKey(callee.object, context);
+	const releaseEventKey = resolveExpressionKey(callNode.arguments?.[0], context);
 	const pairedReleaseVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
 	const pushedResourceCollectionKey = findPushedResourceCollectionKey(usage, context);
 	const releaseReceiverForOfStatement = findForOfStatementForIteratorExpression(callee.object, context);
@@ -15490,13 +15139,7 @@ const doesReleaseCallMatchUsage = (node, usage, 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.registrationVerbName === "addListener" && isNodeOfType(usage.node, "CallExpression") && usage.node.arguments?.length === 1) return isProvenLegacyMediaQueryListMethodCall(usage.node, "addListener", context) && releaseVerbName === "removeListener" && isProvenLegacyMediaQueryListMethodCall(callNode, "removeListener", context) && usage.receiverKey !== null && resolveStableMediaQueryListenerIdentityKey(callee.object, context) === usage.receiverKey && usage.handlerKey !== null && resolveStableMediaQueryListenerIdentityKey(callNode.arguments?.[0], context) === usage.handlerKey;
 	if (releaseVerbName === "abort" && isRetainedAbortControllerRefRelease(callee.object, usage, context)) return true;
-	if (usage.registrationVerbName === "addEventListener" && releaseVerbName === "removeEventListener" && isNodeOfType(usage.node, "CallExpression")) {
-		if (!isNodeOfType(stripParenExpression(usage.node.callee), "MemberExpression")) return false;
-		if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], callNode.arguments?.[2], context, true)) return false;
-	}
-	if (isNodeOfType(usage.node, "CallExpression") && !hasSafeForEachProjectionCleanup(usage.node, callNode, context)) return false;
 	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) return false;
 	if (usage.registrationVerbName === "subscribe" && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub") && usage.handleKey !== null && resolveExpressionKey(callNode.arguments?.[0], context) === usage.handleKey) return true;
 	const pairedVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
@@ -15506,9 +15149,6 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (isAssignmentFormForOfIteratorReference(usageEventArgument, context) || isAssignmentFormForOfIteratorReference(releaseEventArgument, context)) return false;
 	if (usage.eventKey !== null && releaseEventKey !== null && usage.eventKey !== releaseEventKey) {
 		if (!isNodeOfType(usage.node, "CallExpression")) return false;
-		const registrationEventProjectionKey = resolveForEachProjectionKey(usage.node.arguments?.[0], context);
-		const releaseEventProjectionKey = resolveForEachProjectionKey(callNode.arguments?.[0], context);
-		if ((registrationEventProjectionKey !== null || releaseEventProjectionKey !== null) && registrationEventProjectionKey !== releaseEventProjectionKey) return false;
 		const usageForOfStatement = findForOfStatementForIteratorExpression(usageEventArgument, context);
 		const releaseForOfStatement = findForOfStatementForIteratorExpression(releaseEventArgument, context);
 		if (usageForOfStatement === null !== (releaseForOfStatement === null)) return false;
@@ -15522,7 +15162,9 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 			const registrationCallee = stripParenExpression(usage.node.callee);
 			if (!isNodeOfType(registrationCallee, "MemberExpression")) return false;
 			if (!isStableLoopReceiver(registrationCallee.object, context) || !isStableLoopReceiver(callee.object, context) || registrationHandlerSymbolId === null || registrationHandlerSymbolId !== releaseHandlerSymbolId) return false;
-			if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], callNode.arguments?.[2], context)) return false;
+			const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
+			const releaseCapture = resolveEventListenerCapture(callNode.arguments?.[2], { allowIndeterminateEntries: true });
+			if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
 			if (!isDirectExhaustiveForOfRelease(callNode, releaseForOfStatement)) return false;
 		}
 	}
@@ -15531,28 +15173,27 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 		return isNodeOfType(handlerArgument, "Literal") && handlerArgument.value === null;
 	}
 	if (releaseVerbName === "removeEventListener" || releaseVerbName === "removeListener" || releaseVerbName === "off") {
-		const usesUnaryListenerSignatureForCalls = isNodeOfType(usage.node, "CallExpression") && usesUnaryListenerSignature(usage.node, callNode);
-		const releaseHandler = usesUnaryListenerSignatureForCalls ? callNode.arguments?.[0] : callNode.arguments?.[1];
+		const usesUnaryListenerSignature = usage.registrationVerbName === "addListener" && isNodeOfType(usage.node, "CallExpression") && usage.node.arguments?.length === 1 && callNode.arguments?.length === 1;
+		const releaseHandler = usesUnaryListenerSignature ? callNode.arguments?.[0] : callNode.arguments?.[1];
 		if (!releaseHandler) return releaseVerbName === "off";
-		const expectedHandlerKey = usesUnaryListenerSignatureForCalls ? usage.eventKey : usage.handlerKey;
-		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignatureForCalls ? 0 : 1] : null;
-		return expectedHandlerKey !== null && resolveResourceIdentityKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
+		const expectedHandlerKey = usesUnaryListenerSignature ? usage.eventKey : usage.handlerKey;
+		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignature ? 0 : 1] : null;
+		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
 	}
 	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, context) => {
-	const effectCallback = findEnclosingFunction$1(functionNode);
-	if (!effectCallback || !isFunctionLike$1(effectCallback)) return false;
-	const effectCall = effectCallback.parent;
-	if (!isNodeOfType(effectCall, "CallExpression") || !isReactHookCall(effectCall, CLEANUP_EFFECT_HOOK_NAMES, context.scopes)) return false;
-	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return resolveStableValue(effectCallback.body, context) === functionNode;
-	let isReturned = false;
-	walkInsideStatementBlocks(effectCallback.body, (child) => {
-		if (isNodeOfType(child, "ReturnStatement") && child.argument && resolveStableValue(child.argument, context) === functionNode) isReturned = true;
-	});
-	return isReturned;
+	let currentNode = functionNode;
+	let parentNode = currentNode.parent;
+	while (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
+		currentNode = parentNode;
+		parentNode = currentNode.parent;
+	}
+	const effectCallback = isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode ? findEnclosingFunction$1(parentNode) : isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode ? parentNode : null;
+	const effectCall = effectCallback?.parent;
+	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isReactHookCall(effectCall, CLEANUP_EFFECT_HOOK_NAMES, context.scopes));
 };
 const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode, context)) return true;
@@ -15642,7 +15283,7 @@ const hasEffectCleanupInvocation = (storage, usage, context) => {
 			if (!cleanupFunction || !cleanupFunctionInvokesRef(cleanupFunction)) return;
 			matchingReturns.push(child);
 		});
-		return doNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+		return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
 	};
 	let didFindInvocation = false;
 	walkAst(componentFunction.body, (child) => {
@@ -15694,10 +15335,12 @@ const isRetainedDisposerRefRelease = (releaseNode, usage, context) => {
 	return findRetainedDisposerStorages(disposerFunction, usage, context).some((storage) => isRetainedDisposerStorageEstablished(storage, usage, context) && !hasUnsafeRetainedDisposerOverwrite(storage, usage, context) && (hasEffectCleanupInvocation(storage, usage, context) || hasCallbackRefReplacementInvocation(storage, usage, context)));
 };
 const isSelfReleasingListenerRelease = (releaseNode, releaseFunction, usage, context) => {
-	if (usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.receiverKey === null || usage.eventKey === null || !isNodeOfType(usage.node, "CallExpression") || !isFunctionLike$1(releaseFunction) || releaseFunction.async || releaseFunction.generator || !isNodeOfType(releaseFunction.body, "BlockStatement") || !doNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
+	if (usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.receiverKey === null || usage.eventKey === null || !isNodeOfType(usage.node, "CallExpression") || !isFunctionLike$1(releaseFunction) || releaseFunction.async || releaseFunction.generator || !isNodeOfType(releaseFunction.body, "BlockStatement") || !doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
+	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
 	const releaseCall = isNodeOfType(releaseNode, "ChainExpression") ? releaseNode.expression : releaseNode;
 	if (!isNodeOfType(releaseCall, "CallExpression")) return false;
-	if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], releaseCall.arguments?.[2], context)) return false;
+	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
+	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
 	const ownerFunction = findEnclosingFunction$1(releaseFunction);
 	if (!ownerFunction || !isFunctionLike$1(ownerFunction)) return false;
 	const triggerRegistrations = [];
@@ -15922,7 +15565,7 @@ const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retaine
 	walkInsideStatementBlocks(effectCallback.body, (child) => {
 		if (isNodeOfType(child, "ReturnStatement") && child.argument && matchesReturnedCleanup(stripParenExpression(child.argument))) matchingReturns.push(child);
 	});
-	return doNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+	return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
 };
 const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) => {
 	const componentFunction = findEnclosingFunction$1(retainedFunction);
@@ -15965,6 +15608,15 @@ const findUnconditionalReturnStatement = (expression, ownerFunction) => {
 	const returnStatement = expressionRoot.parent;
 	return isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument === expressionRoot && findEnclosingFunction$1(returnStatement) === ownerFunction ? returnStatement : null;
 };
+const getFinalSequenceExpressionValue = (expression) => {
+	let finalExpression = stripParenExpression(expression);
+	while (isNodeOfType(finalExpression, "SequenceExpression")) {
+		const sequenceResult = finalExpression.expressions.at(-1);
+		if (!sequenceResult) break;
+		finalExpression = stripParenExpression(sequenceResult);
+	}
+	return finalExpression;
+};
 const doesResourceResultEscape = (resourceNode, allowReturnedResourceEscape, allowConciseReturnEscape, context) => {
 	if (!allowReturnedResourceEscape) return false;
 	let currentNode = resourceNode;
@@ -16213,7 +15865,7 @@ const isReactRefCallbackCleanupOwnedByEffect = (retainedFunction, cleanupFunctio
 			if (child !== returnedCleanupFunction.body && isFunctionLike$1(child)) return false;
 			if (isNodeOfType(child, "CallExpression") && resolveRefOwnedCleanupFunction(child.callee, context) === cleanupFunction) matchingCalls.push(child);
 		});
-		return doNodesCoverEveryPathFromFunctionEntry(returnedCleanupFunction, matchingCalls, context);
+		return doMatchingNodesCoverEveryPathFromFunctionEntry(returnedCleanupFunction, matchingCalls, context);
 	};
 	const matchingReturns = [];
 	walkInsideStatementBlocks(retainedFunction.body, (child) => {
@@ -22563,49 +22215,25 @@ const jsLengthCheckFirst = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/is-proven-global-namespace-reference.ts
-const GLOBAL_SELF_PROPERTY_NAMES = new Set([
-	"global",
-	"globalThis",
-	"self",
-	"window"
-]);
 const isProvenGlobalObjectReference = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	let currentExpression = expression;
-	while (true) {
-		const strippedExpression = stripParenExpression(currentExpression);
-		if (!isNodeOfType(strippedExpression, "Identifier")) return false;
-		if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
-		const symbol = scopes.symbolFor(strippedExpression);
-		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
-		const declaration = symbol.declarationNode;
-		const initializer = declaration.init;
-		if (!initializer) return false;
-		const isDirectIdentifierAlias = isNodeOfType(declaration.id, "Identifier") && declaration.id === symbol.bindingIdentifier && initializer === symbol.initializer;
-		const bindingProperty = symbol.bindingIdentifier.parent;
-		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
-		const isDirectGlobalSelfAlias = isNodeOfType(declaration.id, "ObjectPattern") && isNodeOfType(bindingProperty, "Property") && bindingProperty.value === symbol.bindingIdentifier && bindingProperty.parent === declaration.id && destructuredPropertyName !== null && GLOBAL_SELF_PROPERTY_NAMES.has(destructuredPropertyName);
-		if (!isDirectIdentifierAlias && !isDirectGlobalSelfAlias) return false;
-		visitedSymbolIds.add(symbol.id);
-		currentExpression = initializer;
-	}
+	const strippedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
+	if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
+	const symbol = scopes.symbolFor(strippedExpression);
+	if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isProvenGlobalObjectReference(symbol.initializer, scopes, visitedSymbolIds);
 };
 const isProvenGlobalNamespaceReference = (expression, namespaceName, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	let currentExpression = expression;
-	while (true) {
-		const strippedExpression = stripParenExpression(currentExpression);
-		if (!isNodeOfType(strippedExpression, "Identifier")) return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
 		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
 		const symbol = scopes.symbolFor(strippedExpression);
-		if (!symbol || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
 		visitedSymbolIds.add(symbol.id);
-		const declaration = symbol.declarationNode;
-		const bindingIdentifier = symbol.bindingIdentifier;
-		const bindingProperty = bindingIdentifier.parent;
-		if (getDestructuredBindingPropertyName(bindingIdentifier) === namespaceName && isNodeOfType(declaration, "VariableDeclarator") && isNodeOfType(declaration.id, "ObjectPattern") && isNodeOfType(bindingProperty, "Property") && bindingProperty.value === bindingIdentifier && bindingProperty.parent === declaration.id && declaration.init) return isProvenGlobalObjectReference(declaration.init, scopes);
-		const directInitializer = getDirectConstInitializer(symbol);
-		if (!directInitializer) return false;
-		currentExpression = directInitializer;
+		return isProvenGlobalNamespaceReference(symbol.initializer, namespaceName, scopes, visitedSymbolIds);
 	}
+	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
 };
 //#endregion
 //#region src/plugin/rules/js-performance/js-min-max-loop.ts
@@ -34867,19 +34495,6 @@ const noCascadingSetState = defineRetiredRule({
 	recommendation: "Retired: React batches synchronous state updates from one effect into the same follow-up commit, so setter count does not prove repeated redraws."
 });
 //#endregion
-//#region src/plugin/utils/get-react-use-callback-call.ts
-const getReactUseCallbackCall = (expression, scopes) => {
-	const identifier = stripParenExpression(expression);
-	if (!isNodeOfType(identifier, "Identifier")) return null;
-	const symbol = resolveConstIdentifierAlias(identifier, scopes);
-	if (symbol?.kind !== "const" || !symbol.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	return isNodeOfType(initializer, "CallExpression") && isReactApiCall(initializer, "useCallback", scopes, {
-		allowGlobalReactNamespace: true,
-		resolveNamedAliases: true
-	}) ? initializer : null;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/create-state-trigger-reachability.ts
 const getRefCurrentSymbol = (node, context) => {
 	const expression = stripParenExpression(node);
@@ -35408,8 +35023,19 @@ const isBuiltinNamespaceCallee = (callee) => {
 	}
 	return false;
 };
+const getReactUseCallbackSource = (reference, context) => {
+	const identifier = reference.identifier;
+	const symbol = resolveConstIdentifierAlias(identifier, context.scopes);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	if (isNodeOfType(initializer, "CallExpression") && isReactApiCall(initializer, "useCallback", context.scopes, {
+		allowGlobalReactNamespace: true,
+		resolveNamedAliases: true
+	})) return initializer;
+	return null;
+};
 const getDependencyStateRefs = (analysis, context, dependencyReference) => {
-	const useCallbackCall = getReactUseCallbackCall(dependencyReference.identifier, context.scopes);
+	const useCallbackCall = getReactUseCallbackSource(dependencyReference, context);
 	if (!useCallbackCall) return getUpstreamRefs(analysis, dependencyReference).filter((reference) => isState(analysis, reference));
 	const dependencyList = useCallbackCall.arguments?.[1];
 	if (!dependencyList || !isNodeOfType(dependencyList, "ArrayExpression")) return getUpstreamRefs(analysis, dependencyReference).filter((reference) => isState(analysis, reference));
@@ -38923,17 +38549,6 @@ const noDynamicImportPath = defineRule({
 	})
 });
 //#endregion
-//#region src/plugin/utils/get-require-call-source.ts
-const getRequireCallSource = (expression) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return getRequireCallSource(unwrappedExpression.object);
-	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
-	if (!isNodeOfType(unwrappedExpression.callee, "Identifier") || unwrappedExpression.callee.name !== "require") return null;
-	const [firstArgument] = unwrappedExpression.arguments ?? [];
-	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
-	return typeof firstArgument.value === "string" ? firstArgument.value : null;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/is-cleanup-return.ts
 const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
 	"each",
@@ -39078,16 +38693,7 @@ const collectDependencyStateSymbolIds = (effectNode, stateSymbolIds, scopes) =>
 	}
 	return dependencyStateSymbolIds;
 };
-const resolveSynchronouslyInvokedFunction = (expression, scopes) => {
-	const localFunction = resolveExactLocalFunction(expression, scopes);
-	if (localFunction) return localFunction;
-	const useCallbackCall = getReactUseCallbackCall(expression, scopes);
-	if (!useCallbackCall) return null;
-	const callback = useCallbackCall.arguments[0];
-	if (!callback || isNodeOfType(callback, "SpreadElement")) return null;
-	return resolveExactLocalFunction(callback, scopes);
-};
-const collectSynchronouslyInvokedFunctions = (effectCallback, scopes, includeStableCallbacks = true) => {
+const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
 	const analysisFunctions = new Set([effectCallback]);
 	const pendingFunctions = [effectCallback];
 	while (pendingFunctions.length > 0) {
@@ -39095,9 +38701,9 @@ const collectSynchronouslyInvokedFunctions = (effectCallback, scopes, includeSta
 		if (!currentFunction || !isFunctionLike$1(currentFunction)) continue;
 		walkInsideStatementBlocks(currentFunction.body, (child) => {
 			if (!isNodeOfType(child, "CallExpression")) return;
-			const invokedFunction = includeStableCallbacks ? resolveSynchronouslyInvokedFunction(child.callee, scopes) : resolveExactLocalFunction(child.callee, scopes);
+			const invokedFunction = resolveExactLocalFunction(child.callee, scopes);
 			if (!invokedFunction || analysisFunctions.has(invokedFunction)) return;
-			if (isFunctionLike$1(invokedFunction) && (invokedFunction.async || invokedFunction.generator)) return;
+			if (isFunctionLike$1(invokedFunction) && invokedFunction.async) return;
 			analysisFunctions.add(invokedFunction);
 			pendingFunctions.push(invokedFunction);
 		});
@@ -39110,51 +38716,7 @@ const visitSynchronousFunctionBodies = (analysisFunctions, visitor) => {
 		walkInsideStatementBlocks(analysisFunction.body, visitor);
 	}
 };
-const getStateNameForSetterCall = (node, setterSymbolIdToStateName, scopes) => {
-	if (!isNodeOfType(node, "CallExpression") || !isNodeOfType(node.callee, "Identifier")) return null;
-	const setterSymbol = resolveConstIdentifierAlias(node.callee, scopes, true);
-	return setterSymbol ? setterSymbolIdToStateName.get(setterSymbol.id) ?? null : null;
-};
-const collectStateWriteAnalysisFunctions = (effectCallback, scopes, setterSymbolIdToStateName) => {
-	const ordinaryAnalysisFunctions = collectSynchronouslyInvokedFunctions(effectCallback, scopes, false);
-	const fullAnalysisFunctions = collectSynchronouslyInvokedFunctions(effectCallback, scopes);
-	const stableAnalysisFunctions = [...fullAnalysisFunctions].filter((analysisFunction) => !ordinaryAnalysisFunctions.has(analysisFunction));
-	if (stableAnalysisFunctions.length === 0) return ordinaryAnalysisFunctions;
-	let hasUnprovenObservableWork = stableAnalysisFunctions.some((analysisFunction) => {
-		if (!isFunctionLike$1(analysisFunction)) return false;
-		let hasExecutableDefault = false;
-		for (const parameter of analysisFunction.params) {
-			walkInsideStatementBlocks(parameter, (child) => {
-				if (isNodeOfType(child, "CallExpression") || isNodeOfType(child, "AssignmentExpression") || isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "ImportExpression") || isNodeOfType(child, "NewExpression") || isNodeOfType(child, "TaggedTemplateExpression") || isNodeOfType(child, "ThrowStatement") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") hasExecutableDefault = true;
-			});
-			if (hasExecutableDefault) return true;
-		}
-		return false;
-	});
-	const stableWrittenStateNames = /* @__PURE__ */ new Set();
-	const allWrittenStateNames = /* @__PURE__ */ new Set();
-	visitSynchronousFunctionBodies(fullAnalysisFunctions, (child) => {
-		const writtenStateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
-		if (writtenStateName) allWrittenStateNames.add(writtenStateName);
-	});
-	visitSynchronousFunctionBodies(new Set(stableAnalysisFunctions), (child) => {
-		if (hasUnprovenObservableWork) return;
-		if (isNodeOfType(child, "CallExpression")) {
-			const writtenStateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
-			if (writtenStateName) {
-				stableWrittenStateNames.add(writtenStateName);
-				return;
-			}
-			const invokedFunction = resolveSynchronouslyInvokedFunction(child.callee, scopes);
-			if (invokedFunction && fullAnalysisFunctions.has(invokedFunction)) return;
-			hasUnprovenObservableWork = true;
-			return;
-		}
-		if (isNodeOfType(child, "AssignmentExpression") || isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "ImportExpression") || isNodeOfType(child, "NewExpression") || isNodeOfType(child, "TaggedTemplateExpression") || isNodeOfType(child, "ThrowStatement") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") hasUnprovenObservableWork = true;
-	});
-	return !hasUnprovenObservableWork && stableWrittenStateNames.size === 1 && allWrittenStateNames.size === 1 ? fullAnalysisFunctions : ordinaryAnalysisFunctions;
-};
-const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, visitedSymbolIds = /* @__PURE__ */ new Set(), additionalStateValues = /* @__PURE__ */ new Map()) => {
+const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	if (isNodeOfType(unwrappedExpression, "Literal")) {
 		const literalValue = unwrappedExpression.value;
@@ -39162,49 +38724,46 @@ const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, vi
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const symbol = scopes.symbolFor(unwrappedExpression);
-		if (symbol?.id === stateSymbolId) return stateValue;
-		if (symbol && additionalStateValues.has(symbol.id)) return additionalStateValues.get(symbol.id) ?? null;
+		if (scopes.symbolFor(unwrappedExpression)?.id === stateSymbolId) return stateValue;
 		if (unwrappedExpression.name === "undefined" && scopes.isGlobalReference(unwrappedExpression)) return { value: void 0 };
-		if (unwrappedExpression.name === "NaN" && scopes.isGlobalReference(unwrappedExpression)) return { value: NaN };
 		const immutableSymbol = scopes.symbolFor(unwrappedExpression);
 		if (immutableSymbol?.kind !== "const" || !immutableSymbol.initializer || !isNodeOfType(immutableSymbol.declarationNode, "VariableDeclarator") || immutableSymbol.declarationNode.id !== immutableSymbol.bindingIdentifier || immutableSymbol.declarationNode.init !== immutableSymbol.initializer || immutableSymbol.references.some((reference) => reference.flag !== "read") || visitedSymbolIds.has(immutableSymbol.id)) return null;
-		return readStaticEffectValue(immutableSymbol.initializer, scopes, stateSymbolId, stateValue, new Set(visitedSymbolIds).add(immutableSymbol.id), additionalStateValues);
+		return readStaticEffectValue(immutableSymbol.initializer, scopes, stateSymbolId, stateValue, new Set(visitedSymbolIds).add(immutableSymbol.id));
 	}
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression")) {
 		if (unwrappedExpression.operator === "void") return { value: void 0 };
 		if (unwrappedExpression.operator !== "!") return null;
-		const argumentValue = readStaticEffectValue(unwrappedExpression.argument, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const argumentValue = readStaticEffectValue(unwrappedExpression.argument, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		return argumentValue ? { value: !argumentValue.value } : null;
 	}
 	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
 		if (isNodeOfType(unwrappedExpression.callee, "Identifier") && unwrappedExpression.callee.name === "Boolean" && scopes.isGlobalReference(unwrappedExpression.callee) && unwrappedExpression.arguments.length === 1 && unwrappedExpression.arguments[0] && !isNodeOfType(unwrappedExpression.arguments[0], "SpreadElement")) {
-			const argumentValue = readStaticEffectValue(unwrappedExpression.arguments[0], scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+			const argumentValue = readStaticEffectValue(unwrappedExpression.arguments[0], scopes, stateSymbolId, stateValue, visitedSymbolIds);
 			return argumentValue ? { value: Boolean(argumentValue.value) } : null;
 		}
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		if (!leftValue) return null;
 		if (unwrappedExpression.operator === "&&" && !leftValue.value) return leftValue;
 		if (unwrappedExpression.operator === "||" && leftValue.value) return leftValue;
 		if (unwrappedExpression.operator === "??" && leftValue.value !== null && leftValue.value !== void 0) return leftValue;
-		return readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		return readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 	}
 	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
-		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		if (!testValue) return null;
-		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 	}
 	if (isNodeOfType(unwrappedExpression, "MemberExpression") && unwrappedExpression.optional) {
-		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		if (objectValue?.value === null || objectValue?.value === void 0) return { value: void 0 };
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "BinaryExpression")) {
-		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
-		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		if (!leftValue || !rightValue) return null;
 		if (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "!==") {
 			const areEqual = leftValue.value === rightValue.value;
@@ -39243,7 +38802,8 @@ const collectStateWritesInEffect = (analysisFunctions, setterSymbolIdToStateName
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
-		const stateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
+		const setterSymbol = resolveConstIdentifierAlias(child.callee, scopes, true);
+		const stateName = setterSymbol ? setterSymbolIdToStateName.get(setterSymbol.id) : void 0;
 		if (!stateName) return;
 		const writeInfo = stateWrites.get(stateName) ?? {
 			values: /* @__PURE__ */ new Set(),
@@ -39259,27 +38819,27 @@ const collectStateWritesInEffect = (analysisFunctions, setterSymbolIdToStateName
 const isGlobalBooleanCall = (node, scopes) => {
 	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Boolean" && scopes.isGlobalReference(node.callee);
 };
-const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map()) => {
+const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, scopes) => {
 	let currentNode = workNode;
 	while (currentNode.parent) {
 		const parentNode = currentNode.parent;
 		if (isFunctionLike$1(parentNode)) break;
 		if (isNodeOfType(parentNode, "IfStatement")) {
-			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
 			if (testValue) {
 				if (currentNode === parentNode.consequent && !testValue.value) return false;
 				if (currentNode === parentNode.alternate && testValue.value) return false;
 			}
 		}
 		if (isNodeOfType(parentNode, "ConditionalExpression")) {
-			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
 			if (testValue) {
 				if (currentNode === parentNode.consequent && !testValue.value) return false;
 				if (currentNode === parentNode.alternate && testValue.value) return false;
 			}
 		}
 		if (isNodeOfType(parentNode, "LogicalExpression") && currentNode === parentNode.right) {
-			const leftValue = readStaticEffectValue(parentNode.left, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
+			const leftValue = readStaticEffectValue(parentNode.left, scopes, stateSymbolId, stateValue);
 			if (leftValue) {
 				if (parentNode.operator === "&&" && !leftValue.value) return false;
 				if (parentNode.operator === "||" && leftValue.value) return false;
@@ -39291,7 +38851,7 @@ const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, s
 			if (statementIndex >= 0) for (let index = 0; index < statementIndex; index += 1) {
 				const earlierStatement = parentNode.body[index];
 				if (!isNodeOfType(earlierStatement, "IfStatement") || earlierStatement.alternate || !statementAlwaysExits(earlierStatement.consequent)) continue;
-				if (readStaticEffectValue(earlierStatement.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues)?.value) return false;
+				if (readStaticEffectValue(earlierStatement.test, scopes, stateSymbolId, stateValue)?.value) return false;
 			}
 		}
 		currentNode = parentNode;
@@ -39301,93 +38861,24 @@ const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, s
 const isReaderWorkNode = (node, analysisFunctions, scopes) => {
 	if (isNodeOfType(node, "CallExpression")) {
 		if (isGlobalBooleanCall(node, scopes)) return false;
-		const invokedFunction = resolveSynchronouslyInvokedFunction(node.callee, scopes);
+		const invokedFunction = resolveExactLocalFunction(node.callee, scopes);
 		return !invokedFunction || !analysisFunctions.has(invokedFunction);
 	}
 	return isNodeOfType(node, "AssignmentExpression") || isNodeOfType(node, "UpdateExpression") || isNodeOfType(node, "NewExpression") || isNodeOfType(node, "TaggedTemplateExpression") || isNodeOfType(node, "ThrowStatement") || isNodeOfType(node, "UnaryExpression") && node.operator === "delete";
 };
-const mergeKnownStateValues = (additionalStateValues, parameterStateValues) => {
-	if (parameterStateValues.size === 0) return additionalStateValues;
-	const knownStateValues = new Map(additionalStateValues);
-	for (const [symbolId, value] of parameterStateValues) knownStateValues.set(symbolId, value);
-	return knownStateValues;
-};
-const buildInvokedFunctionParameterStateValues = (invokedFunction, invocation, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map(), callerParameterStateValues = /* @__PURE__ */ new Map()) => {
-	if (!isFunctionLike$1(invokedFunction)) return /* @__PURE__ */ new Map();
-	const parameterStateValues = /* @__PURE__ */ new Map();
-	const callerKnownStateValues = mergeKnownStateValues(additionalStateValues, callerParameterStateValues);
-	for (let parameterIndex = 0; parameterIndex < invokedFunction.params.length; parameterIndex += 1) {
-		const rawParameter = invokedFunction.params[parameterIndex];
-		const rawArgument = invocation.arguments[parameterIndex];
-		if (rawArgument && isNodeOfType(rawArgument, "SpreadElement")) break;
-		const parameter = isNodeOfType(rawParameter, "AssignmentPattern") ? rawParameter.left : rawParameter;
-		if (!isNodeOfType(parameter, "Identifier")) continue;
-		const parameterSymbol = scopes.symbolFor(parameter);
-		if (!parameterSymbol) continue;
-		let argumentValue = null;
-		if (rawArgument) {
-			argumentValue = readStaticEffectValue(rawArgument, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), callerKnownStateValues);
-			if (argumentValue !== null && argumentValue.value === void 0 && isNodeOfType(rawParameter, "AssignmentPattern")) {
-				const defaultKnownStateValues = mergeKnownStateValues(callerKnownStateValues, parameterStateValues);
-				argumentValue = readStaticEffectValue(rawParameter.right, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), defaultKnownStateValues);
-			}
-		} else if (isNodeOfType(rawParameter, "AssignmentPattern")) {
-			const defaultKnownStateValues = mergeKnownStateValues(callerKnownStateValues, parameterStateValues);
-			argumentValue = readStaticEffectValue(rawParameter.right, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), defaultKnownStateValues);
-		} else argumentValue = { value: void 0 };
-		if (argumentValue) parameterStateValues.set(parameterSymbol.id, argumentValue);
-	}
-	return parameterStateValues;
-};
-const haveEqualParameterStateValues = (leftValues, rightValues) => {
-	if (leftValues.size !== rightValues.size) return false;
-	for (const [symbolId, leftValue] of leftValues) {
-		const rightValue = rightValues.get(symbolId);
-		if (!rightValue || !Object.is(leftValue.value, rightValue.value)) return false;
-	}
-	return true;
-};
-const canReaderWorkRunForStateValues = (readerEffect, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map()) => {
-	const pendingFrames = [{
-		functionNode: readerEffect.callback,
-		parameterStateValues: /* @__PURE__ */ new Map()
-	}];
-	const visitedParameterStateValues = /* @__PURE__ */ new Map();
-	while (pendingFrames.length > 0) {
-		const frame = pendingFrames.pop();
-		if (!frame || !isFunctionLike$1(frame.functionNode)) continue;
-		const functionParameterStateValues = visitedParameterStateValues.get(frame.functionNode) ?? [];
-		if (functionParameterStateValues.some((previousValues) => haveEqualParameterStateValues(previousValues, frame.parameterStateValues))) continue;
-		functionParameterStateValues.push(frame.parameterStateValues);
-		visitedParameterStateValues.set(frame.functionNode, functionParameterStateValues);
-		const knownStateValues = mergeKnownStateValues(additionalStateValues, frame.parameterStateValues);
+const canStateWriteReachReaderWork = (writeInfo, readerEffect, stateSymbolId, scopes) => {
+	if (writeInfo.hasUnknownValue || stateSymbolId === null) return true;
+	for (const writtenValue of writeInfo.values) {
+		const stateValue = { value: writtenValue };
 		let didFindReachableWork = false;
-		walkInsideStatementBlocks(frame.functionNode.body, (child) => {
-			if (didFindReachableWork) return;
-			if (isNodeOfType(child, "CallExpression")) {
-				const invokedFunction = resolveSynchronouslyInvokedFunction(child.callee, scopes);
-				if (invokedFunction && readerEffect.analysisFunctions.has(invokedFunction)) {
-					if (isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes, knownStateValues)) pendingFrames.push({
-						functionNode: invokedFunction,
-						parameterStateValues: buildInvokedFunctionParameterStateValues(invokedFunction, child, stateSymbolId, stateValue, scopes, additionalStateValues, frame.parameterStateValues)
-					});
-					return;
-				}
-			}
-			if (isReaderWorkNode(child, readerEffect.analysisFunctions, scopes) && isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes, knownStateValues)) didFindReachableWork = true;
+		visitSynchronousFunctionBodies(readerEffect.analysisFunctions, (child) => {
+			if (didFindReachableWork || !isReaderWorkNode(child, readerEffect.analysisFunctions, scopes)) return;
+			if (isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes)) didFindReachableWork = true;
 		});
 		if (didFindReachableWork) return true;
 	}
 	return false;
 };
-const canStateWriteReachReaderWork = (writtenStateName, writerEffect, readerEffect, stateSymbolIds, scopes) => {
-	const writeInfo = writerEffect.stateWrites.get(writtenStateName);
-	const stateSymbolId = stateSymbolIds.get(writtenStateName);
-	if (!writeInfo || stateSymbolId === void 0) return true;
-	if (writeInfo.hasUnknownValue) return true;
-	for (const writtenValue of writeInfo.values) if (canReaderWorkRunForStateValues(readerEffect, stateSymbolId, { value: writtenValue }, scopes)) return true;
-	return false;
-};
 const EMPTY_CLEANUP_NAME_SET = /* @__PURE__ */ new Set();
 const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
 	"clear",
@@ -39398,499 +38889,26 @@ const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
 	"keys",
 	"values"
 ]);
-const EXTERNAL_SYNC_DIRECT_IMPORT_SOURCES = new Map([
-	["fetch", new Set([
-		"cross-fetch",
-		"node-fetch",
-		"undici"
-	])],
-	["ky", new Set(["ky"])],
-	["got", new Set(["got"])],
-	["wretch", new Set(["wretch"])],
-	["ofetch", new Set(["ofetch"])],
-	["setTimeout", new Set([
-		"node:timers",
-		"node:timers/promises",
-		"timers",
-		"timers/promises"
-	])],
-	["setInterval", new Set([
-		"node:timers",
-		"node:timers/promises",
-		"timers",
-		"timers/promises"
-	])]
-]);
-const EXTERNAL_SYNC_DEFAULT_IMPORT_NAMES = new Map([
-	["axios", "axios"],
-	["cross-fetch", "fetch"],
-	["got", "got"],
-	["ky", "ky"],
-	["node-fetch", "fetch"],
-	["wretch", "wretch"]
-]);
-const EXTERNAL_SYNC_HTTP_CLIENT_MODULE_SOURCES = new Set([
-	"axios",
-	"cross-fetch",
-	"got",
-	"ky",
-	"node-fetch",
-	"ofetch",
-	"undici",
-	"wretch"
-]);
-const EXTERNAL_SYNC_GLOBAL_HTTP_CLIENT_NAMES = new Set([
-	"axios",
-	"got",
-	"ky",
-	"ofetch",
-	"wretch"
-]);
-const EXTERNAL_SYNC_HTTP_METHOD_NAMES = new Set([
-	...EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES,
-	"fetch",
-	"patch",
-	"post",
-	"put",
-	"request"
-]);
-const TANSTACK_QUERY_CLIENT_MODULE_SOURCES = new Set(["@tanstack/query-core", "@tanstack/react-query"]);
-const TANSTACK_QUERY_EXTERNAL_SYNC_METHOD_NAMES = new Set(["fetchQuery", "prefetchQuery"]);
-const EXTERNAL_SYNC_RESOURCE_CONSTRUCTOR_NAMES = new Set([
-	...EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS,
-	...SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP,
-	"EventTarget",
-	"XMLHttpRequest"
-]);
-const getDestructuredBindingDepth = (bindingIdentifier) => {
-	let bindingNode = bindingIdentifier;
-	let depth = 0;
-	while (true) {
-		if (isNodeOfType(bindingNode.parent, "AssignmentPattern") && bindingNode.parent.left === bindingNode) bindingNode = bindingNode.parent;
-		const property = bindingNode.parent;
-		if (!property || !isNodeOfType(property, "Property") || property.value !== bindingNode || !property.parent || !isNodeOfType(property.parent, "ObjectPattern")) return depth;
-		depth += 1;
-		bindingNode = property.parent;
-	}
-};
-const isMutatedMemberExpression = (rawMemberExpression) => {
-	let expression = findTransparentExpressionRoot(rawMemberExpression);
-	while (expression.parent) {
-		const parent = expression.parent;
-		if (isNodeOfType(parent, "MemberExpression") && parent.object === expression) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "Property") && parent.value === expression && isNodeOfType(parent.parent, "ObjectPattern")) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "ObjectPattern") && parent.properties.some((property) => property === expression)) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "ArrayPattern") && parent.elements.some((element) => element === expression)) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "RestElement") && parent.argument === expression || isNodeOfType(parent, "AssignmentPattern") && parent.left === expression) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		break;
-	}
-	const parent = expression.parent;
-	return Boolean(isNodeOfType(parent, "AssignmentExpression") && parent.left === expression || isNodeOfType(parent, "UpdateExpression") && parent.argument === expression || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === expression || (isNodeOfType(parent, "ForInStatement") || isNodeOfType(parent, "ForOfStatement")) && parent.left === expression);
-};
-const isReactHookDependencyArgument = (expression, scopes) => {
-	const call = expression.parent;
-	return Boolean(isNodeOfType(call, "CallExpression") && call.arguments[1] === expression && isReactApiCall(call, HOOKS_WITH_DEPS, scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true,
-		resolveNamedAliases: true
-	}));
-};
-const isPlainDependencyObjectExpression = (expression) => isNodeOfType(expression, "ObjectExpression") && expression.properties.every((property) => isNodeOfType(property, "Property") && property.kind === "init" && !property.computed && !property.method);
-const getContainingReactDependencyValue = (rawExpression, containerKind) => {
-	const expression = findTransparentExpressionRoot(rawExpression);
-	const parent = expression.parent;
-	if (isNodeOfType(parent, "ArrayExpression")) return {
-		expression: parent,
-		containerKind: "array"
-	};
-	if (containerKind === "array" && isNodeOfType(parent, "SpreadElement") && parent.argument === expression && isNodeOfType(parent.parent, "ArrayExpression")) return {
-		expression: parent.parent,
-		containerKind: "array"
-	};
-	if (isNodeOfType(parent, "Property") && (parent.value === expression || parent.shorthand && parent.key === expression) && parent.parent && isPlainDependencyObjectExpression(parent.parent)) return {
-		expression: parent.parent,
-		containerKind: "object"
-	};
-	return null;
-};
-const getFullArrayRestCopySymbol = (initializer, scopes) => {
-	const declaration = initializer.parent;
-	if (!isNodeOfType(declaration, "VariableDeclarator") || declaration.init !== initializer || !isNodeOfType(declaration.id, "ArrayPattern") || declaration.id.elements.length !== 1) return null;
-	const restElement = declaration.id.elements[0];
-	if (!isNodeOfType(restElement, "RestElement") || !isNodeOfType(restElement.argument, "Identifier")) return null;
-	const symbol = scopes.symbolFor(restElement.argument);
-	return symbol?.kind === "const" && symbol.declarationNode === declaration && symbol.references.every((reference) => reference.flag === "read") ? symbol : null;
-};
-const isReactDependencyArrayReference = (initialExpression, scopes) => {
-	const pendingPaths = [{
-		expression: initialExpression,
-		containerKind: null
-	}];
-	const visitedExpressions = /* @__PURE__ */ new Set();
-	let didFindReactDependencyArgument = false;
-	while (pendingPaths.length > 0) {
-		const pendingPath = pendingPaths.pop();
-		if (!pendingPath) continue;
-		const expression = findTransparentExpressionRoot(pendingPath.expression);
-		if (visitedExpressions.has(expression)) continue;
-		visitedExpressions.add(expression);
-		if (pendingPath.containerKind === "array" && isReactHookDependencyArgument(expression, scopes)) {
-			didFindReactDependencyArgument = true;
-			continue;
-		}
-		const containingValue = getContainingReactDependencyValue(expression, pendingPath.containerKind);
-		if (containingValue) {
-			pendingPaths.push(containingValue);
-			continue;
-		}
-		const declaration = expression.parent;
-		if (isNodeOfType(declaration, "VariableDeclarator") && declaration.init === expression && isNodeOfType(declaration.id, "Identifier")) {
-			const symbol = scopes.symbolFor(declaration.id);
-			if (!symbol || getDirectUnreassignedInitializer(symbol) !== expression) return false;
-			if (symbol.references.length === 0) return false;
-			for (const reference of symbol.references) pendingPaths.push({
-				expression: reference.identifier,
-				containerKind: pendingPath.containerKind
-			});
-			continue;
-		}
-		if (pendingPath.containerKind === "array") {
-			const restCopySymbol = getFullArrayRestCopySymbol(expression, scopes);
-			if (restCopySymbol) {
-				if (restCopySymbol.references.length === 0) return false;
-				for (const reference of restCopySymbol.references) pendingPaths.push({
-					expression: reference.identifier,
-					containerKind: "array"
-				});
-				continue;
-			}
-		}
-		return false;
-	}
-	return didFindReactDependencyArgument;
-};
-const hasSafeReceiverAliases = (rootSymbols, scopes) => {
-	const pendingSymbols = [...rootSymbols];
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	while (pendingSymbols.length > 0) {
-		const symbol = pendingSymbols.pop();
-		if (!symbol || visitedSymbolIds.has(symbol.id)) continue;
-		visitedSymbolIds.add(symbol.id);
-		for (const reference of symbol.references) {
-			const expression = findTransparentExpressionRoot(reference.identifier);
-			const container = expression.parent;
-			if (isReactDependencyArrayReference(expression, scopes)) continue;
-			if (isNodeOfType(container, "MemberExpression") && container.object === expression) {
-				if (isMutatedMemberExpression(container)) return false;
-				continue;
-			}
-			if (isNodeOfType(container, "CallExpression") && container.callee === expression) continue;
-			if (isNodeOfType(container, "VariableDeclarator") && container.init === expression && isNodeOfType(container.id, "ObjectPattern")) continue;
-			if (isNodeOfType(container, "AssignmentExpression") && container.right === expression && isNodeOfType(container.left, "ObjectPattern")) continue;
-			if (isNodeOfType(container, "VariableDeclarator") && container.init === expression && isNodeOfType(container.id, "Identifier")) {
-				const aliasSymbol = scopes.symbolFor(container.id);
-				const aliasInitializer = aliasSymbol && getDirectUnreassignedInitializer(aliasSymbol);
-				if (!aliasSymbol || aliasInitializer !== expression) return false;
-				pendingSymbols.push(aliasSymbol);
-				continue;
-			}
-			return false;
+const isFunctionShapedReturn = (returnedValue, setterToStateName, setterSymbolIdToStateName, scopes, isExplicitReturnStatement) => {
+	if (isNodeOfType(returnedValue, "ArrowFunctionExpression") || isNodeOfType(returnedValue, "FunctionExpression")) return true;
+	if (isNodeOfType(returnedValue, "CallExpression")) {
+		if (isNodeOfType(returnedValue.callee, "Identifier")) {
+			const setterSymbol = resolveConstIdentifierAlias(returnedValue.callee, scopes, true);
+			if (setterToStateName.has(returnedValue.callee.name) || setterSymbol && setterSymbolIdToStateName.has(setterSymbol.id)) return false;
+			if (isSetterIdentifier(returnedValue.callee.name)) return true;
 		}
+		return isCleanupReturn(returnedValue, EMPTY_CLEANUP_NAME_SET, EMPTY_CLEANUP_NAME_SET, { allowOpaqueReturn: isExplicitReturnStatement });
 	}
-	return true;
-};
-const hasProvenGlobalNamespaceReference = (expression, namespaceNames, scopes) => {
-	for (const namespaceName of namespaceNames) if (isProvenGlobalNamespaceReference(expression, namespaceName, scopes)) return true;
+	if (isNodeOfType(returnedValue, "Identifier")) return true;
 	return false;
 };
-const getTypeScriptImportEqualsSource = (symbol) => {
-	if (symbol.kind !== "ts-import-equals" || !isNodeOfType(symbol.declarationNode, "TSImportEqualsDeclaration")) return null;
-	const moduleReference = symbol.declarationNode.moduleReference;
-	if (!isNodeOfType(moduleReference, "TSExternalModuleReference") || !isNodeOfType(moduleReference.expression, "Literal")) return null;
-	return typeof moduleReference.expression.value === "string" ? moduleReference.expression.value : null;
-};
-const getUnshadowedRequireSource = (rawExpression, scopes) => {
-	let expression = stripParenExpression(rawExpression);
-	while (isNodeOfType(expression, "MemberExpression")) expression = stripParenExpression(expression.object);
-	if (!isNodeOfType(expression, "CallExpression") || !isNodeOfType(expression.callee, "Identifier") || expression.callee.name !== "require" || !scopes.isGlobalReference(expression.callee)) return null;
-	return getRequireCallSource(rawExpression);
-};
-const resolveExternalModuleBinding = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set(), ignoreCommonJsMutation = false) => {
-	let expression = stripParenExpression(rawExpression);
-	let outermostExportedName = null;
-	let exportedPropertyDepth = 0;
-	let resolvedBinding = null;
-	let isCommonJsModuleObject = false;
-	const traversedSymbolIds = new Set(visitedSymbolIds);
-	const commonJsModuleObjectSymbols = /* @__PURE__ */ new Set();
-	while (true) {
-		if (isNodeOfType(expression, "MemberExpression")) {
-			const propertyName = getStaticPropertyName(expression);
-			if (propertyName === null) return null;
-			outermostExportedName ??= propertyName;
-			exportedPropertyDepth += 1;
-			expression = stripParenExpression(expression.object);
-			continue;
-		}
-		const requireSource = getUnshadowedRequireSource(expression, scopes);
-		if (requireSource !== null) {
-			resolvedBinding = {
-				source: requireSource,
-				exportedName: null,
-				isModuleObject: true
-			};
-			isCommonJsModuleObject = true;
-			break;
-		}
-		if (!isNodeOfType(expression, "Identifier")) return null;
-		const symbol = scopes.symbolFor(expression);
-		if (!symbol || traversedSymbolIds.has(symbol.id)) return null;
-		if (symbol.kind === "import") {
-			const importDeclaration = symbol.declarationNode.parent;
-			if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration") || typeof importDeclaration.source.value !== "string") return null;
-			if (isNodeOfType(symbol.declarationNode, "ImportSpecifier")) resolvedBinding = {
-				source: importDeclaration.source.value,
-				exportedName: getImportedName(symbol.declarationNode) ?? null,
-				isModuleObject: false
-			};
-			else if (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier")) resolvedBinding = {
-				source: importDeclaration.source.value,
-				exportedName: "default",
-				isModuleObject: false
-			};
-			else if (isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")) resolvedBinding = {
-				source: importDeclaration.source.value,
-				exportedName: null,
-				isModuleObject: true
-			};
-			break;
-		}
-		const importEqualsSource = getTypeScriptImportEqualsSource(symbol);
-		if (importEqualsSource !== null) {
-			resolvedBinding = {
-				source: importEqualsSource,
-				exportedName: null,
-				isModuleObject: true
-			};
-			isCommonJsModuleObject = true;
-			commonJsModuleObjectSymbols.add(symbol);
-			break;
-		}
-		const directInitializer = getDirectUnreassignedInitializer(symbol);
-		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
-		const initializer = directInitializer ?? (destructuredPropertyName !== null && symbol.kind === "const" && isNodeOfType(symbol.declarationNode, "VariableDeclarator") ? symbol.declarationNode.init : null);
-		if (!initializer) return null;
-		traversedSymbolIds.add(symbol.id);
-		outermostExportedName ??= destructuredPropertyName;
-		if (destructuredPropertyName !== null) exportedPropertyDepth += getDestructuredBindingDepth(symbol.bindingIdentifier);
-		const unwrappedInitializer = stripParenExpression(initializer);
-		if (destructuredPropertyName === null && !isNodeOfType(unwrappedInitializer, "MemberExpression")) commonJsModuleObjectSymbols.add(symbol);
-		expression = unwrappedInitializer;
-	}
-	if (!resolvedBinding) return null;
-	if (!ignoreCommonJsMutation && isCommonJsModuleObject && !hasSafeReceiverAliases(commonJsModuleObjectSymbols, scopes)) return null;
-	if (outermostExportedName === null) return resolvedBinding;
-	if (!resolvedBinding.isModuleObject || exportedPropertyDepth !== 1) return null;
-	return {
-		source: resolvedBinding.source,
-		exportedName: outermostExportedName,
-		isModuleObject: false
-	};
-};
-const getCanonicalExternalSyncExportName = (binding) => {
-	if (binding.exportedName && binding.exportedName !== "default") return binding.exportedName;
-	return EXTERNAL_SYNC_DEFAULT_IMPORT_NAMES.get(binding.source) ?? null;
-};
-const isKnownExternalSyncDirectModuleBinding = (binding) => {
-	const exportedName = getCanonicalExternalSyncExportName(binding);
-	return Boolean(exportedName && EXTERNAL_SYNC_DIRECT_IMPORT_SOURCES.get(exportedName)?.has(binding.source));
-};
-const DEFINITELY_NON_FUNCTION_GLOBAL_CALL_NAMES = new Set([
-	"Array",
-	"BigInt",
-	"Boolean",
-	"Date",
-	"Number",
-	"String",
-	"Symbol"
-]);
-const DEFINITELY_NON_FUNCTION_GLOBAL_CONSTRUCTOR_NAMES = new Set([
-	"Array",
-	"Boolean",
-	"Date",
-	"Map",
-	"Number",
-	"Promise",
-	"RegExp",
-	"Set",
-	"String",
-	"URL",
-	"URLSearchParams",
-	"WeakMap",
-	"WeakSet"
-]);
-const PROMISE_STATIC_RESULT_METHOD_NAMES = new Set([
-	"all",
-	"allSettled",
-	"any",
-	"race",
-	"reject",
-	"resolve",
-	"withResolvers"
-]);
-const returnsOnlyNonCleanupValues = (functionNode, setterToStateName, scopes, visitedFunctions = /* @__PURE__ */ new Set()) => {
-	if (!isFunctionLike$1(functionNode) || functionNode.async || functionNode.generator || visitedFunctions.has(functionNode)) return false;
-	const nextVisitedFunctions = new Set(visitedFunctions).add(functionNode);
-	const isNonCleanupValue = (returnValue) => {
-		const expression = stripParenExpression(returnValue);
-		if (isNodeOfType(expression, "Identifier") && expression.name === "undefined" && scopes.isGlobalReference(expression)) return true;
-		if (isNodeOfType(expression, "Literal") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "JSXElement") || isNodeOfType(expression, "JSXFragment") || isNodeOfType(expression, "TemplateLiteral") || isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return true;
-		if (isNodeOfType(expression, "ConditionalExpression")) return isNonCleanupValue(expression.consequent) && isNonCleanupValue(expression.alternate);
-		if (isNodeOfType(expression, "LogicalExpression")) return isNonCleanupValue(expression.left) && isNonCleanupValue(expression.right);
-		if (isNodeOfType(expression, "SequenceExpression")) {
-			const finalExpression = expression.expressions.at(-1);
-			return Boolean(finalExpression && isNonCleanupValue(finalExpression));
-		}
-		if (isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && DEFINITELY_NON_FUNCTION_GLOBAL_CONSTRUCTOR_NAMES.has(expression.callee.name) && scopes.isGlobalReference(expression.callee)) return true;
-		if (!isNodeOfType(expression, "CallExpression")) return false;
-		if (isNodeOfType(expression.callee, "Identifier") && DEFINITELY_NON_FUNCTION_GLOBAL_CALL_NAMES.has(expression.callee.name) && scopes.isGlobalReference(expression.callee)) return true;
-		if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.object, "Identifier") && expression.callee.object.name === "Promise" && scopes.isGlobalReference(expression.callee.object) && PROMISE_STATIC_RESULT_METHOD_NAMES.has(getStaticPropertyName(expression.callee) ?? "")) return true;
-		if (isNodeOfType(expression.callee, "Identifier") && setterToStateName.has(expression.callee.name)) return true;
-		const invokedFunction = resolveSynchronouslyInvokedFunction(expression.callee, scopes);
-		return Boolean(invokedFunction && returnsOnlyNonCleanupValues(invokedFunction, setterToStateName, scopes, nextVisitedFunctions));
-	};
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isNonCleanupValue(functionNode.body);
-	let returnsOnlyNonCleanup = true;
-	walkAst(functionNode.body, (child) => {
-		if (!returnsOnlyNonCleanup) return false;
-		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "ReturnStatement")) return;
-		if (child.argument && !isNonCleanupValue(child.argument)) {
-			returnsOnlyNonCleanup = false;
-			return false;
-		}
-	});
-	return returnsOnlyNonCleanup;
-};
-const getResolvedFunctionCleanupReturnProof = (functionNode, scopes, visitedFunctions = /* @__PURE__ */ new Set()) => {
-	if (!isFunctionLike$1(functionNode) || functionNode.async || functionNode.generator || visitedFunctions.has(functionNode)) return {
-		hasCleanup: false,
-		isValid: false
-	};
-	const nextVisitedFunctions = new Set(visitedFunctions).add(functionNode);
-	const getCleanupReturnProof = (returnValue) => {
-		const expression = stripParenExpression(returnValue);
-		if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression")) return {
-			hasCleanup: true,
-			isValid: true
-		};
-		if (isNodeOfType(expression, "Identifier")) {
-			if (expression.name === "undefined" && scopes.isGlobalReference(expression)) return {
-				hasCleanup: false,
-				isValid: true
-			};
-			const localFunction = resolveExactLocalFunction(expression, scopes);
-			return {
-				hasCleanup: Boolean(localFunction),
-				isValid: Boolean(localFunction)
-			};
-		}
-		if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return {
-			hasCleanup: false,
-			isValid: true
-		};
-		if (isNodeOfType(expression, "ConditionalExpression")) {
-			const consequentProof = getCleanupReturnProof(expression.consequent);
-			const alternateProof = getCleanupReturnProof(expression.alternate);
-			return {
-				hasCleanup: consequentProof.hasCleanup || alternateProof.hasCleanup,
-				isValid: consequentProof.isValid && alternateProof.isValid
-			};
-		}
-		if (isNodeOfType(expression, "LogicalExpression")) {
-			const leftProof = getCleanupReturnProof(expression.left);
-			const rightProof = getCleanupReturnProof(expression.right);
-			return {
-				hasCleanup: leftProof.hasCleanup || rightProof.hasCleanup,
-				isValid: leftProof.isValid && rightProof.isValid
-			};
-		}
-		if (isNodeOfType(expression, "SequenceExpression")) {
-			const finalExpression = expression.expressions.at(-1);
-			return finalExpression ? getCleanupReturnProof(finalExpression) : {
-				hasCleanup: false,
-				isValid: false
-			};
-		}
-		if (!isNodeOfType(expression, "CallExpression")) return {
-			hasCleanup: false,
-			isValid: false
-		};
-		const invokedFunction = resolveSynchronouslyInvokedFunction(expression.callee, scopes);
-		return invokedFunction ? getResolvedFunctionCleanupReturnProof(invokedFunction, scopes, nextVisitedFunctions) : {
-			hasCleanup: false,
-			isValid: false
-		};
-	};
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) return getCleanupReturnProof(functionNode.body);
-	let cleanupReturnProof = {
-		hasCleanup: false,
-		isValid: true
-	};
-	walkAst(functionNode.body, (child) => {
-		if (!cleanupReturnProof.isValid) return false;
-		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "ReturnStatement")) return;
-		if (!child.argument) return;
-		const returnProof = getCleanupReturnProof(child.argument);
-		if (!returnProof.isValid) {
-			cleanupReturnProof = {
-				hasCleanup: false,
-				isValid: false
-			};
-			return false;
-		}
-		cleanupReturnProof.hasCleanup ||= returnProof.hasCleanup;
-	});
-	return cleanupReturnProof;
-};
-const isFunctionShapedReturn = (returnedValue, setterToStateName, setterSymbolIdToStateName, scopes, isExplicitReturnStatement) => {
-	const unwrappedReturnedValue = stripParenExpression(returnedValue);
-	if (isNodeOfType(unwrappedReturnedValue, "ArrowFunctionExpression") || isNodeOfType(unwrappedReturnedValue, "FunctionExpression")) return true;
-	if (isNodeOfType(unwrappedReturnedValue, "CallExpression")) {
-		if (isNodeOfType(unwrappedReturnedValue.callee, "Identifier")) {
-			const setterSymbol = resolveConstIdentifierAlias(unwrappedReturnedValue.callee, scopes, true);
-			if (setterToStateName.has(unwrappedReturnedValue.callee.name) || setterSymbol && setterSymbolIdToStateName.has(setterSymbol.id)) return false;
-		}
-		const invokedFunction = resolveSynchronouslyInvokedFunction(unwrappedReturnedValue.callee, scopes);
-		if (invokedFunction && returnsOnlyNonCleanupValues(invokedFunction, setterToStateName, scopes)) return false;
-		if (invokedFunction) {
-			const cleanupReturnProof = getResolvedFunctionCleanupReturnProof(invokedFunction, scopes);
-			if (cleanupReturnProof.isValid) return cleanupReturnProof.hasCleanup;
-		}
-		if (!invokedFunction && isNodeOfType(unwrappedReturnedValue.callee, "Identifier") && isSetterIdentifier(unwrappedReturnedValue.callee.name)) return true;
-		return isCleanupReturn(unwrappedReturnedValue, EMPTY_CLEANUP_NAME_SET, EMPTY_CLEANUP_NAME_SET, { allowOpaqueReturn: isExplicitReturnStatement });
-	}
-	if (isNodeOfType(unwrappedReturnedValue, "Identifier")) return true;
+const STORAGE_GLOBAL_NAMES = new Set(["localStorage", "sessionStorage"]);
+const isBrowserStorageReceiver = (receiver) => {
+	if (!receiver) return false;
+	if (isNodeOfType(receiver, "Identifier")) return STORAGE_GLOBAL_NAMES.has(receiver.name);
+	if (isNodeOfType(receiver, "MemberExpression")) return isNodeOfType(receiver.property, "Identifier") && STORAGE_GLOBAL_NAMES.has(receiver.property.name);
 	return false;
 };
-const STORAGE_GLOBAL_NAMES = ["localStorage", "sessionStorage"];
-const isBrowserStorageReceiver = (receiver, scopes) => Boolean(receiver && STORAGE_GLOBAL_NAMES.some((storageName) => isProvenGlobalNamespaceReference(receiver, storageName, scopes)));
 const STORAGE_HOOK_PATTERN = /^use\w*Storage/i;
 const collectStorageHookSetterNames = (componentBody) => {
 	const setterNames = /* @__PURE__ */ new Set();
@@ -39922,16 +38940,23 @@ const callsOpaqueExternalSetter = (analysisFunctions, setterToStateName) => {
 	});
 	return didFindOpaqueSetterCall;
 };
-const isReactUseRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && isReactApiCall(expression, "useRef", scopes, {
+const isReactRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && (isReactApiCall(expression, "useRef", scopes, {
 	allowGlobalReactNamespace: true,
 	allowUnboundBareCalls: true,
 	resolveNamedAliases: true
-});
-const isReactRefCall = (expression, scopes) => isReactUseRefCall(expression, scopes) || isNodeOfType(expression, "CallExpression") && isReactApiCall(expression, "createRef", scopes, {
+}) || isReactApiCall(expression, "createRef", scopes, {
 	allowGlobalReactNamespace: true,
 	allowUnboundBareCalls: true,
 	resolveNamedAliases: true
-});
+}));
+const getDirectReactRefSymbol = (rawExpression, scopes) => {
+	const expression = stripParenExpression(rawExpression);
+	if (!isNodeOfType(expression, "Identifier")) return null;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol) return null;
+	const initializer = getDirectUnreassignedInitializer(symbol);
+	return initializer && isReactRefCall(stripParenExpression(initializer), scopes) ? symbol : null;
+};
 const isReactNativeJsxElement = (openingElement, scopes) => {
 	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
 	const symbol = scopes.symbolFor(openingElement.name);
@@ -39939,33 +38964,19 @@ const isReactNativeJsxElement = (openingElement, scopes) => {
 	return Boolean(symbol?.kind === "import" && importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react-native");
 };
 const isDirectHostJsxRef = (symbol, scopes) => {
-	let didFindHostRef = false;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	const pendingSymbols = [symbol];
-	while (pendingSymbols.length > 0) {
-		const currentSymbol = pendingSymbols.pop();
-		if (!currentSymbol || visitedSymbolIds.has(currentSymbol.id)) continue;
-		visitedSymbolIds.add(currentSymbol.id);
-		for (const reference of currentSymbol.references) {
-			const expression = findTransparentExpressionRoot(reference.identifier);
-			const container = expression.parent;
-			if (isNodeOfType(container, "MemberExpression") && container.object === expression && getStaticPropertyName(container) === "current") continue;
-			if (isNodeOfType(container, "VariableDeclarator") && container.init === expression && isNodeOfType(container.id, "Identifier")) {
-				const aliasSymbol = scopes.symbolFor(container.id);
-				const aliasInitializer = aliasSymbol && getDirectUnreassignedInitializer(aliasSymbol);
-				if (!aliasSymbol || aliasInitializer !== expression) return false;
-				pendingSymbols.push(aliasSymbol);
-				continue;
-			}
-			if (!container || !isNodeOfType(container, "JSXExpressionContainer") || container.expression !== expression) return false;
-			const attribute = container.parent;
-			if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
-			const openingElement = attribute.parent;
-			if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement") || !isProvenIntrinsicJsxElement(openingElement, scopes) && !isReactNativeJsxElement(openingElement, scopes)) return false;
-			didFindHostRef = true;
-		}
-	}
-	return didFindHostRef;
+	let hostRefCount = 0;
+	for (const reference of symbol.references) {
+		const expression = findTransparentExpressionRoot(reference.identifier);
+		const container = expression.parent;
+		if (isNodeOfType(container, "MemberExpression") && container.object === expression && getStaticPropertyName(container) === "current") continue;
+		if (!container || !isNodeOfType(container, "JSXExpressionContainer") || container.expression !== expression) return false;
+		const attribute = container.parent;
+		if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
+		const openingElement = attribute.parent;
+		if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement") || !isProvenIntrinsicJsxElement(openingElement, scopes) && !isReactNativeJsxElement(openingElement, scopes)) return false;
+		hostRefCount += 1;
+	}
+	return hostRefCount > 0;
 };
 const isIntrinsicRefCallbackParameter = (expression, scopes) => {
 	const identifier = stripParenExpression(expression);
@@ -39975,18 +38986,7 @@ const isIntrinsicRefCallbackParameter = (expression, scopes) => {
 	const rawFirstParameter = callback.params?.[0];
 	const firstParameter = isNodeOfType(rawFirstParameter, "AssignmentPattern") ? rawFirstParameter.left : rawFirstParameter;
 	const symbol = scopes.symbolFor(identifier);
-	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter && symbol.references.every((reference) => {
-		if (reference.flag !== "read") return false;
-		let referenceRoot = reference.identifier;
-		while (referenceRoot.parent) {
-			const parent = referenceRoot.parent;
-			if (isNodeOfType(parent, "AssignmentExpression")) return parent.left !== referenceRoot;
-			if (isNodeOfType(parent, "UpdateExpression")) return parent.argument !== referenceRoot;
-			if (isNodeOfType(parent, "ForInStatement") || isNodeOfType(parent, "ForOfStatement")) return parent.left !== referenceRoot;
-			referenceRoot = parent;
-		}
-		return true;
-	}));
+	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter);
 };
 const getDirectReactRefCall = (symbol, scopes) => {
 	const initializer = getDirectUnreassignedInitializer(symbol);
@@ -39994,38 +38994,15 @@ const getDirectReactRefCall = (symbol, scopes) => {
 	const expression = stripParenExpression(initializer);
 	return isNodeOfType(expression, "CallExpression") && isReactRefCall(expression, scopes) ? expression : null;
 };
-const isEmptyGlobalMapConstruction = (rawExpression, scopes) => {
-	const expression = stripParenExpression(rawExpression);
-	return isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Map" && scopes.isGlobalReference(expression.callee) && expression.arguments.length === 0;
-};
-const hasEmptyRefSentinelInitializer = (refCall, scopes) => {
-	if (!isReactUseRefCall(refCall, scopes) || refCall.arguments.length > 1) return false;
-	const [initialValue] = refCall.arguments;
-	return !initialValue || isNodeOfType(initialValue, "Literal") && initialValue.value === null || isNodeOfType(initialValue, "Identifier") && initialValue.name === "undefined" && scopes.isGlobalReference(initialValue);
-};
-const isDirectLazyEmptyMapInitialization = (currentExpression, symbol, scopes) => {
-	const assignment = currentExpression.parent;
-	if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.left !== currentExpression || assignment.operator !== "??=" || !isEmptyGlobalMapConstruction(assignment.right, scopes)) return false;
-	const refOwner = findEnclosingFunction$1(symbol.bindingIdentifier);
-	return refOwner !== null && findEnclosingFunction$1(assignment) === refOwner;
-};
 const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
-	const refCall = getDirectReactRefCall(symbol, scopes);
-	const initialValue = refCall?.arguments[0];
-	const hasDirectEmptyMapInitializer = Boolean(initialValue && isEmptyGlobalMapConstruction(initialValue, scopes));
-	const hasLazyEmptyMapInitializer = Boolean(refCall && hasEmptyRefSentinelInitializer(refCall, scopes));
-	if (!hasDirectEmptyMapInitializer && !hasLazyEmptyMapInitializer) return false;
+	const initialValue = getDirectReactRefCall(symbol, scopes)?.arguments?.[0];
+	if (!initialValue || !isNodeOfType(initialValue, "NewExpression") || !isNodeOfType(initialValue.callee, "Identifier") || initialValue.callee.name !== "Map" || !scopes.isGlobalReference(initialValue.callee) || initialValue.arguments.length !== 0) return false;
 	let intrinsicValueWriteCount = 0;
-	let lazyEmptyMapInitializationCount = 0;
 	for (const reference of symbol.references) {
 		const identifier = findTransparentExpressionRoot(reference.identifier);
 		const currentMember = identifier.parent;
 		if (!isNodeOfType(currentMember, "MemberExpression") || currentMember.object !== identifier || getStaticPropertyName(currentMember) !== "current") return false;
 		const currentExpression = findTransparentExpressionRoot(currentMember);
-		if (hasLazyEmptyMapInitializer && isDirectLazyEmptyMapInitialization(currentExpression, symbol, scopes)) {
-			lazyEmptyMapInitializationCount += 1;
-			continue;
-		}
 		const methodMember = currentExpression.parent;
 		if (!isNodeOfType(methodMember, "MemberExpression") || methodMember.object !== currentExpression) return false;
 		const methodName = getStaticPropertyName(methodMember);
@@ -40038,7 +39015,7 @@ const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
 		if (!storedValue || isNodeOfType(storedValue, "SpreadElement") || !isIntrinsicRefCallbackParameter(storedValue, scopes)) return false;
 		intrinsicValueWriteCount += 1;
 	}
-	return intrinsicValueWriteCount > 0 && (hasDirectEmptyMapInitializer || lazyEmptyMapInitializationCount === 1);
+	return intrinsicValueWriteCount > 0;
 };
 const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollectionValue = false, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(rawExpression);
@@ -40052,11 +39029,7 @@ const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollecti
 	}
 	if (isNodeOfType(expression, "MemberExpression")) {
 		if (getStaticPropertyName(expression) === "current") {
-			const symbol = resolveReactRefSymbol(expression, scopes, {
-				allowUnboundBareCalls: true,
-				includeCreateRef: true,
-				resolveNamedAliases: true
-			});
+			const symbol = getDirectReactRefSymbol(expression.object, scopes);
 			return Boolean(symbol && (isDirectHostJsxRef(symbol, scopes) || didReadCollectionValue && storesOnlyIntrinsicRefCallbackValues(symbol, scopes)));
 		}
 		return isDerivedFromProvenDomRefCurrent(expression.object, scopes, didReadCollectionValue, visitedSymbolIds);
@@ -40074,80 +39047,19 @@ const isCommittedDomSyncNode = (node, scopes) => {
 	if (propertyName === null || !EXTERNAL_SYNC_DOM_MEMBER_METHOD_NAMES.has(propertyName)) return false;
 	return isDerivedFromProvenDomRefCurrent(callee.object, scopes) || isProvenBrowserApiReceiver(callee.object, "dom-event-target", scopes);
 };
-const isProvenHttpClientReceiver = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isNodeOfType(expression, "Identifier")) {
-		const receiverSymbol = scopes.symbolFor(expression);
-		if (receiverSymbol && !hasSafeReceiverAliases(new Set([receiverSymbol]), scopes)) return false;
-	}
-	if (hasProvenGlobalNamespaceReference(expression, EXTERNAL_SYNC_GLOBAL_HTTP_CLIENT_NAMES, scopes)) return true;
-	const moduleBinding = resolveExternalModuleBinding(expression, scopes);
-	if (moduleBinding && EXTERNAL_SYNC_HTTP_CLIENT_MODULE_SOURCES.has(moduleBinding.source) && (moduleBinding.isModuleObject || moduleBinding.exportedName === "default" && EXTERNAL_SYNC_DEFAULT_IMPORT_NAMES.has(moduleBinding.source) || isKnownExternalSyncDirectModuleBinding(moduleBinding))) return true;
-	if (isNodeOfType(expression, "CallExpression")) {
-		const callee = stripParenExpression(expression.callee);
-		return Boolean(isNodeOfType(callee, "MemberExpression") && getStaticPropertyName(callee) === "create" && isProvenHttpClientReceiver(callee.object, scopes, visitedSymbolIds));
-	}
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	if (resolveExternalModuleBinding(expression, scopes, /* @__PURE__ */ new Set(), true)) return false;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	return Boolean(initializer && isProvenHttpClientReceiver(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id)));
-};
-const isProvenTanStackQueryClientReceiver = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isNodeOfType(expression, "Identifier")) {
-		const receiverSymbol = scopes.symbolFor(expression);
-		if (receiverSymbol && !hasSafeReceiverAliases(new Set([receiverSymbol]), scopes)) return false;
-	}
-	if (isNodeOfType(expression, "CallExpression")) {
-		const binding = resolveExternalModuleBinding(expression.callee, scopes);
-		return Boolean(binding && binding.source === "@tanstack/react-query" && binding.exportedName === "useQueryClient");
-	}
-	if (isNodeOfType(expression, "NewExpression")) {
-		const binding = resolveExternalModuleBinding(expression.callee, scopes);
-		return Boolean(binding && TANSTACK_QUERY_CLIENT_MODULE_SOURCES.has(binding.source) && binding.exportedName === "QueryClient");
-	}
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	return Boolean(initializer && isProvenTanStackQueryClientReceiver(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id)));
-};
-const isProvenExternalResourceReceiver = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isDerivedFromProvenDomRefCurrent(expression, scopes) || isProvenBrowserApiReceiver(expression, "dom-event-target", scopes) || isProvenBrowserApiReceiver(expression, "xml-http-request", scopes) || isProvenHttpClientReceiver(expression, scopes)) return true;
-	if (isNodeOfType(expression, "NewExpression")) return hasProvenGlobalNamespaceReference(expression.callee, EXTERNAL_SYNC_RESOURCE_CONSTRUCTOR_NAMES, scopes);
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	return Boolean(initializer && isProvenExternalResourceReceiver(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id)));
-};
-const isProvenExternalSyncDirectCallee = (callee, scopes) => {
-	if (hasProvenGlobalNamespaceReference(callee, EXTERNAL_SYNC_DIRECT_CALLEE_NAMES, scopes)) return true;
-	const moduleBinding = resolveExternalModuleBinding(callee, scopes);
-	return Boolean(moduleBinding && isKnownExternalSyncDirectModuleBinding(moduleBinding));
-};
-const isExternalSyncNode = (node, scopes) => {
-	if (isNodeOfType(node, "NewExpression")) return hasProvenGlobalNamespaceReference(node.callee, EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS, scopes);
-	if (isNodeOfType(node, "AssignmentExpression") || isNodeOfType(node, "UpdateExpression")) {
-		const mutationTarget = isNodeOfType(node, "AssignmentExpression") ? node.left : node.argument;
-		return isNodeOfType(mutationTarget, "MemberExpression") && getStaticPropertyName(mutationTarget) === "current" && Boolean(resolveReactRefSymbol(mutationTarget, scopes, {
-			allowUnboundBareCalls: true,
-			includeCreateRef: true,
-			resolveNamedAliases: true
-		}));
-	}
+const isExternalSyncNode = (node) => {
+	if (isNodeOfType(node, "NewExpression")) return isNodeOfType(node.callee, "Identifier") && EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS.has(node.callee.name);
+	if (isNodeOfType(node, "AssignmentExpression")) return isNodeOfType(node.left, "MemberExpression") && isNodeOfType(node.left.property, "Identifier") && node.left.property.name === "current";
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	if (isProvenExternalSyncDirectCallee(node.callee, scopes)) return true;
+	if (isNodeOfType(node.callee, "Identifier")) return EXTERNAL_SYNC_DIRECT_CALLEE_NAMES.has(node.callee.name);
 	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
 	const propertyName = getStaticPropertyName(node.callee);
 	if (propertyName === null) return false;
-	if (isBrowserStorageReceiver(node.callee.object, scopes)) return true;
-	if (TANSTACK_QUERY_EXTERNAL_SYNC_METHOD_NAMES.has(propertyName)) return isProvenTanStackQueryClientReceiver(node.callee.object, scopes);
-	if (EXTERNAL_SYNC_HTTP_METHOD_NAMES.has(propertyName)) return isProvenHttpClientReceiver(node.callee.object, scopes);
-	return EXTERNAL_SYNC_MEMBER_METHOD_NAMES.has(propertyName) && isProvenExternalResourceReceiver(node.callee.object, scopes);
+	if (EXTERNAL_SYNC_MEMBER_METHOD_NAMES.has(propertyName)) return true;
+	if (isBrowserStorageReceiver(node.callee.object)) return true;
+	if (!EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES.has(propertyName)) return false;
+	const receiverRootName = getRootIdentifierName(node.callee.object);
+	return receiverRootName !== null && EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS.has(receiverRootName);
 };
 const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, setterSymbolIdToStateName, scopes, allowCommittedDomSync) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
@@ -40156,7 +39068,7 @@ const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateNa
 	} else for (const statement of effectCallback.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument && isFunctionShapedReturn(statement.argument, setterToStateName, setterSymbolIdToStateName, scopes, true)) return true;
 	let didFindExternalCall = false;
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
-		if (isExternalSyncNode(child, scopes) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
+		if (isExternalSyncNode(child) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
 	});
 	return didFindExternalCall;
 };
@@ -40178,11 +39090,11 @@ const noEffectChain = defineRule({
 				setterToStateName.set(binding.setterName, binding.valueName);
 				if (!isNodeOfType(binding.declarator.id, "ArrayPattern")) continue;
 				const stateIdentifier = binding.declarator.id.elements[0];
-				const setterIdentifier = binding.declarator.id.elements[1];
 				if (isNodeOfType(stateIdentifier, "Identifier")) {
 					const stateSymbol = context.scopes.symbolFor(stateIdentifier);
 					if (stateSymbol) stateSymbolIds.set(binding.valueName, stateSymbol.id);
 				}
+				const setterIdentifier = binding.declarator.id.elements[1];
 				if (isNodeOfType(setterIdentifier, "Identifier")) {
 					const setterSymbol = context.scopes.symbolFor(setterIdentifier);
 					if (setterSymbol) setterSymbolIdToStateName.set(setterSymbol.id, binding.valueName);
@@ -40195,11 +39107,10 @@ const noEffectChain = defineRule({
 				const callback = getEffectCallback(effectCall, context.scopes);
 				if (!callback || !isFunctionLike$1(callback) || callback.async) continue;
 				const analysisFunctions = collectSynchronouslyInvokedFunctions(callback, context.scopes);
-				const stateWrites = collectStateWritesInEffect(collectStateWriteAnalysisFunctions(callback, context.scopes, setterSymbolIdToStateName), setterSymbolIdToStateName, context.scopes);
+				const stateWrites = collectStateWritesInEffect(analysisFunctions, setterSymbolIdToStateName, context.scopes);
 				const writtenStateNames = new Set(stateWrites.keys());
 				effectInfos.push({
 					node: effectCall,
-					callback,
 					dependencyStateSymbolIds: collectDependencyStateSymbolIds(effectCall, stateSymbolIdSet, context.scopes),
 					stateWrites,
 					analysisFunctions,
@@ -40216,10 +39127,10 @@ const noEffectChain = defineRule({
 					if (readerEffect.isExternalSync) continue;
 					if (readerEffect.dependencyStateSymbolIds.size === 0) continue;
 					let chainedStateName = null;
-					for (const writtenName of writerEffect.stateWrites.keys()) {
+					for (const [writtenName, writeInfo] of writerEffect.stateWrites) {
 						const writtenStateSymbolId = stateSymbolIds.get(writtenName);
 						if (writtenStateSymbolId === void 0 || !readerEffect.dependencyStateSymbolIds.has(writtenStateSymbolId)) continue;
-						if (!canStateWriteReachReaderWork(writtenName, writerEffect, readerEffect, stateSymbolIds, context.scopes)) continue;
+						if (!canStateWriteReachReaderWork(writeInfo, readerEffect, stateSymbolIds.get(writtenName) ?? null, context.scopes)) continue;
 						chainedStateName = writtenName;
 						break;
 					}
@@ -45004,6 +43915,16 @@ const noManyBooleanProps = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-global-match-media-call.ts
+const isGlobalMatchMediaCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (isNodeOfType(callee, "Identifier")) return callee.name === "matchMedia" && scopes.isGlobalReference(callee);
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "matchMedia") return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && (receiver.name === "window" || receiver.name === "globalThis") && scopes.isGlobalReference(receiver);
+};
+//#endregion
 //#region src/plugin/rules/performance/no-match-media-in-state-initializer.ts
 const REACT_USE_STATE_OPTIONS = {
 	allowGlobalReactNamespace: true,
@@ -56529,6 +55450,17 @@ const preferModuleScopePureFunction = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-require-call-source.ts
+const getRequireCallSource = (expression) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return getRequireCallSource(unwrappedExpression.object);
+	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
+	if (!isNodeOfType(unwrappedExpression.callee, "Identifier") || unwrappedExpression.callee.name !== "require") return null;
+	const [firstArgument] = unwrappedExpression.arguments ?? [];
+	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
+	return typeof firstArgument.value === "string" ? firstArgument.value : null;
+};
+//#endregion
 //#region src/plugin/utils/is-proven-node-crypto-namespace-reference.ts
 const NODE_CRYPTO_MODULE_SOURCES = new Set(["crypto", "node:crypto"]);
 const isProvenNodeCryptoNamespaceReference = (expression, scopes) => {
@@ -61236,717 +60168,6 @@ const isSetterCalledDuringRender = (root, setterName) => {
 	return found;
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/create-external-location-invalidation-checker.ts
-const HISTORY_LOCATION_MUTATION_METHOD_NAMES = new Set(["pushState", "replaceState"]);
-const AGGREGATE_MUTATION_METHOD_NAMES = new Set([...MUTATING_ARRAY_METHODS, ...MUTATING_COLLECTION_METHODS]);
-const OBJECT_AGGREGATE_MUTATION_METHOD_NAMES = new Set([
-	"assign",
-	"defineProperties",
-	"defineProperty",
-	"setPrototypeOf"
-]);
-const REFLECT_AGGREGATE_MUTATION_METHOD_NAMES = new Set([
-	"defineProperty",
-	"deleteProperty",
-	"set",
-	"setPrototypeOf"
-]);
-const LOCATION_CHANGE_EVENT_NAMES = new Set(["hashchange", "popstate"]);
-const containsGlobalLocationSnapshotRead = (node, scopes) => {
-	let didFindLocationSnapshotRead = false;
-	walkAst(node, (child) => {
-		if (didFindLocationSnapshotRead) return false;
-		if (child !== node && isFunctionLike$1(child) && !executesDuringRender(findTransparentExpressionRoot(child), scopes)) return false;
-		if (!isProvenGlobalNamespaceReference(child, "location", scopes)) return;
-		didFindLocationSnapshotRead = true;
-		return false;
-	});
-	return didFindLocationSnapshotRead;
-};
-const resolveExactLocalOrReactCallbackFunction = (expression, scopes) => {
-	const localFunction = resolveExactLocalFunction(expression, scopes);
-	if (isFunctionLike$1(localFunction)) return localFunction;
-	const unwrappedExpression = stripParenExpression(expression);
-	let callbackSource = unwrappedExpression;
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const callbackSymbol = resolveConstIdentifierAlias(unwrappedExpression, scopes);
-		if (callbackSymbol?.kind !== "const" || !callbackSymbol.initializer) return null;
-		callbackSource = callbackSymbol.initializer;
-	}
-	const unwrappedCallbackSource = stripParenExpression(callbackSource);
-	if (!isNodeOfType(unwrappedCallbackSource, "CallExpression") || !isReactApiCall(unwrappedCallbackSource, "useCallback", scopes, { resolveNamedAliases: true })) return null;
-	const callback = unwrappedCallbackSource.arguments?.[0];
-	if (!callback || isNodeOfType(callback, "SpreadElement")) return null;
-	return resolveExactLocalFunction(stripParenExpression(callback), scopes);
-};
-const bindingReadsExactGlobalLocationSnapshot = (bindingIdentifier, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const symbol = scopes.symbolFor(bindingIdentifier);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	if ((symbol.kind === "function" ? scopes.scopeFor(symbol.declarationNode) : symbol.scope).symbols.some((candidateSymbol) => candidateSymbol.name === symbol.name && candidateSymbol.references.some((reference) => reference.flag !== "read"))) return false;
-	const resolvedFunction = resolveExactLocalOrReactCallbackFunction(bindingIdentifier, scopes);
-	const initializer = isFunctionLike$1(resolvedFunction) ? resolvedFunction.body : getDirectUnreassignedInitializer(symbol);
-	if (!initializer) return false;
-	const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-	nextVisitedSymbolIds.add(symbol.id);
-	if (containsGlobalLocationSnapshotRead(initializer, scopes)) return true;
-	let didFindAliasedLocationSnapshotRead = false;
-	walkAst(initializer, (child) => {
-		if (didFindAliasedLocationSnapshotRead) return false;
-		if (child !== initializer && isFunctionLike$1(child) && !executesDuringRender(findTransparentExpressionRoot(child), scopes)) return false;
-		if (!isNodeOfType(child, "Identifier")) return;
-		if (bindingReadsExactGlobalLocationSnapshot(child, scopes, nextVisitedSymbolIds)) {
-			didFindAliasedLocationSnapshotRead = true;
-			return false;
-		}
-	});
-	return didFindAliasedLocationSnapshotRead;
-};
-const hasRenderReachableLocationSnapshotRead = (componentBody, renderReachableExpressions, directRenderNames, scopes) => {
-	if (renderReachableExpressions.some((expression) => containsGlobalLocationSnapshotRead(expression, scopes))) return true;
-	for (const statement of componentBody.body ?? []) {
-		if (isNodeOfType(statement, "FunctionDeclaration") && statement.id) {
-			if (directRenderNames.has(statement.id.name) && bindingReadsExactGlobalLocationSnapshot(statement.id, scopes)) return true;
-			continue;
-		}
-		if (!isNodeOfType(statement, "VariableDeclaration")) continue;
-		for (const declarator of statement.declarations ?? []) {
-			if (!isNodeOfType(declarator.id, "Identifier") || !declarator.init) continue;
-			if (!directRenderNames.has(declarator.id.name)) continue;
-			if (bindingReadsExactGlobalLocationSnapshot(declarator.id, scopes)) return true;
-		}
-	}
-	return false;
-};
-const isGlobalHistoryLocationMutation = (node, scopes) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const methodName = getStaticPropertyName(callee);
-	return Boolean(methodName && HISTORY_LOCATION_MUTATION_METHOD_NAMES.has(methodName) && isProvenGlobalNamespaceReference(callee.object, "history", scopes));
-};
-const getStaticLocationChangeEvent = (node) => {
-	if (!node) return null;
-	const eventNameNode = stripParenExpression(node);
-	if (!isNodeOfType(eventNameNode, "Literal") || typeof eventNameNode.value !== "string") return null;
-	return LOCATION_CHANGE_EVENT_NAMES.has(eventNameNode.value) ? eventNameNode.value : null;
-};
-const addToSetIndex = (index, key, value) => {
-	const indexedValues = index.get(key) ?? /* @__PURE__ */ new Set();
-	indexedValues.add(value);
-	index.set(key, indexedValues);
-};
-const getSynchronousInvocationExpression = (functionNode, scopes) => {
-	const functionExpressionRoot = findTransparentExpressionRoot(functionNode);
-	if (!executesDuringRender(functionExpressionRoot, scopes)) return null;
-	const parent = functionExpressionRoot.parent;
-	return isNodeOfType(parent, "CallExpression") || isNodeOfType(parent, "NewExpression") ? parent : null;
-};
-const getLocationListenerOperation = (callExpression, scopes) => {
-	if (!isNodeOfType(callExpression, "CallExpression")) return null;
-	const callee = stripParenExpression(callExpression.callee);
-	const methodName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : isNodeOfType(callee, "Identifier") ? callee.name : null;
-	if (methodName !== "addEventListener" && methodName !== "removeEventListener") return null;
-	if (!(isNodeOfType(callee, "MemberExpression") ? isProvenGlobalObjectReference(callee.object, scopes) : isNodeOfType(callee, "Identifier") && scopes.isGlobalReference(callee))) return null;
-	const eventName = getStaticLocationChangeEvent(callExpression.arguments?.[0]);
-	if (!eventName) return null;
-	const listenerExpression = callExpression.arguments?.[1];
-	if (!listenerExpression || isNodeOfType(listenerExpression, "SpreadElement")) return null;
-	const listenerFunction = resolveExactLocalOrReactCallbackFunction(listenerExpression, scopes);
-	if (!isFunctionLike$1(listenerFunction)) return null;
-	const captureArgument = callExpression.arguments?.[2];
-	const capture = isNodeOfType(captureArgument, "SpreadElement") ? null : resolveEventListenerCapture(captureArgument, {
-		allowComputedString: true,
-		allowIndeterminateEntries: true
-	});
-	return {
-		operation: methodName === "addEventListener" ? "add" : "remove",
-		registration: {
-			callExpression,
-			listenerFunction,
-			capture,
-			eventName
-		}
-	};
-};
-const buildLocationInvalidationIndex = (componentBody, componentFunction, context) => {
-	const index = {
-		componentFunction,
-		context,
-		effectCallbacks: /* @__PURE__ */ new Set(),
-		expressionsByOwner: /* @__PURE__ */ new Map(),
-		historyMutationsByOwner: /* @__PURE__ */ new Map(),
-		awaitExpressionsByOwner: /* @__PURE__ */ new Map(),
-		callSitesByFunction: /* @__PURE__ */ new Map(),
-		calledFunctionByExpression: /* @__PURE__ */ new Map(),
-		synchronousInvocationsByFunction: /* @__PURE__ */ new Map(),
-		synchronousCallbacksByExpression: /* @__PURE__ */ new Map(),
-		callsByCalleeSymbolId: /* @__PURE__ */ new Map(),
-		identifierCalls: /* @__PURE__ */ new Set(),
-		listenerRegistrations: [],
-		listenerRemovals: [],
-		mountedListenerFunctions: /* @__PURE__ */ new Set(),
-		mutationExecutionsByOwner: /* @__PURE__ */ new Map(),
-		synchronousMutationResultByFunction: /* @__PURE__ */ new Map()
-	};
-	walkAst(componentBody, (child) => {
-		if (isFunctionLike$1(child)) {
-			const invocationExpression = getSynchronousInvocationExpression(child, context.scopes);
-			if (invocationExpression) {
-				addToSetIndex(index.synchronousInvocationsByFunction, child, invocationExpression);
-				addToSetIndex(index.synchronousCallbacksByExpression, invocationExpression, child);
-			}
-			return;
-		}
-		const owner = context.cfg.enclosingFunction(child);
-		if (!owner) return;
-		if (isNodeOfType(child, "AwaitExpression")) {
-			addToSetIndex(index.awaitExpressionsByOwner, owner, child);
-			return;
-		}
-		if (!isNodeOfType(child, "CallExpression") && !isNodeOfType(child, "NewExpression")) return;
-		addToSetIndex(index.expressionsByOwner, owner, child);
-		if (isNodeOfType(child, "CallExpression")) {
-			if (isGlobalHistoryLocationMutation(child, context.scopes)) addToSetIndex(index.historyMutationsByOwner, owner, child);
-			if (isNodeOfType(stripParenExpression(child.callee), "Identifier")) index.identifierCalls.add(child);
-			const calledFunction = resolveExactLocalOrReactCallbackFunction(child.callee, context.scopes);
-			if (isFunctionLike$1(calledFunction)) {
-				addToSetIndex(index.callSitesByFunction, calledFunction, child);
-				index.calledFunctionByExpression.set(child, calledFunction);
-			}
-			if (context.cfg.enclosingFunction(child) === componentFunction && isReactApiCall(child, EFFECT_HOOK_NAMES$1, context.scopes, {
-				allowGlobalReactNamespace: true,
-				allowUnboundBareCalls: true,
-				resolveNamedAliases: true
-			})) {
-				const effectCallback = getEffectCallback(child, context.scopes);
-				if (isFunctionLike$1(effectCallback)) index.effectCallbacks.add(effectCallback);
-			}
-			const listenerOperation = getLocationListenerOperation(child, context.scopes);
-			if (listenerOperation?.operation === "add") index.listenerRegistrations.push(listenerOperation.registration);
-			else if (listenerOperation) index.listenerRemovals.push(listenerOperation.registration);
-		}
-	});
-	return index;
-};
-const isDescendantWithoutFunctionBoundary = (descendant, ancestor) => {
-	let current = descendant;
-	while (current && current !== ancestor) {
-		if (current !== descendant && isFunctionLike$1(current)) return false;
-		current = current.parent;
-	}
-	return current === ancestor;
-};
-const areInMutuallyExclusiveConditionalBranches = (firstNode, secondNode) => {
-	const firstBranches = /* @__PURE__ */ new Map();
-	let current = firstNode;
-	while (current?.parent) {
-		const parent = current.parent;
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === current || parent.alternate === current)) firstBranches.set(parent, current);
-		if (current !== firstNode && isFunctionLike$1(current)) break;
-		current = parent;
-	}
-	current = secondNode;
-	while (current?.parent) {
-		const parent = current.parent;
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === current || parent.alternate === current)) {
-			const firstBranch = firstBranches.get(parent);
-			if (firstBranch && firstBranch !== current) return true;
-		}
-		if (current !== secondNode && isFunctionLike$1(current)) break;
-		current = parent;
-	}
-	return false;
-};
-const collectStableBooleanGuardConstraints = (node, functionBoundary, scopes) => {
-	const constraintsBySymbolId = /* @__PURE__ */ new Map();
-	const recordConstraint = (test, requiredTestValue) => {
-		let expression = stripParenExpression(test);
-		let requiredValue = requiredTestValue;
-		while (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") {
-			requiredValue = !requiredValue;
-			expression = stripParenExpression(expression.argument);
-		}
-		if (!isNodeOfType(expression, "Identifier")) return;
-		const symbol = scopes.symbolFor(expression);
-		if (!symbol || symbol.references.some((reference) => reference.flag !== "read")) return;
-		const existingConstraint = constraintsBySymbolId.get(symbol.id);
-		constraintsBySymbolId.set(symbol.id, existingConstraint === void 0 || existingConstraint === requiredValue ? requiredValue : null);
-	};
-	let current = node;
-	while (current?.parent && current !== functionBoundary) {
-		const parent = current.parent;
-		if (isNodeOfType(parent, "IfStatement")) {
-			if (parent.consequent === current) recordConstraint(parent.test, true);
-			if (parent.alternate === current) recordConstraint(parent.test, false);
-		} else if (isNodeOfType(parent, "ConditionalExpression")) {
-			if (parent.consequent === current) recordConstraint(parent.test, true);
-			if (parent.alternate === current) recordConstraint(parent.test, false);
-		} else if (isNodeOfType(parent, "LogicalExpression") && parent.right === current) {
-			if (parent.operator === "&&") recordConstraint(parent.left, true);
-			if (parent.operator === "||") recordConstraint(parent.left, false);
-		}
-		if (current !== node && isFunctionLike$1(current)) break;
-		current = parent;
-	}
-	return constraintsBySymbolId;
-};
-const haveContradictoryStableBooleanGuards = (firstNode, secondNode, functionBoundary, scopes) => {
-	const firstConstraints = collectStableBooleanGuardConstraints(firstNode, functionBoundary, scopes);
-	const secondConstraints = collectStableBooleanGuardConstraints(secondNode, functionBoundary, scopes);
-	for (const requiredValue of firstConstraints.values()) if (requiredValue === null) return true;
-	for (const requiredValue of secondConstraints.values()) if (requiredValue === null) return true;
-	for (const [symbolId, firstRequiredValue] of firstConstraints) {
-		const secondRequiredValue = secondConstraints.get(symbolId);
-		if (firstRequiredValue !== null && secondRequiredValue !== void 0 && secondRequiredValue !== null && firstRequiredValue !== secondRequiredValue) return true;
-	}
-	return false;
-};
-const isInsideIntrinsicReactEventHandlerAttribute = (node, functionBoundary) => {
-	let current = node;
-	while (current && current !== functionBoundary) {
-		if (isEventHandlerAttribute(current) && isJsxAttributeOnIntrinsicHtmlElement(current)) return true;
-		current = current.parent;
-	}
-	return false;
-};
-const getTransparentExpressionBindingIdentifier = (expression) => {
-	const expressionRoot = findTransparentExpressionRoot(expression);
-	const parent = expressionRoot.parent;
-	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
-	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === expressionRoot && isNodeOfType(parent.left, "Identifier")) return parent.left;
-	return null;
-};
-const getIntrinsicReactEventHandlerBindingIdentifier = (functionNode, index) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
-	const functionExpressionRoot = findTransparentExpressionRoot(functionNode);
-	const directTransparentBindingIdentifier = getTransparentExpressionBindingIdentifier(functionExpressionRoot);
-	if (directTransparentBindingIdentifier) return directTransparentBindingIdentifier;
-	const callbackCall = functionExpressionRoot.parent;
-	if (!isNodeOfType(callbackCall, "CallExpression") || callbackCall.arguments?.[0] !== functionExpressionRoot || !isReactApiCall(callbackCall, "useCallback", index.context.scopes, { resolveNamedAliases: true })) return null;
-	return getTransparentExpressionBindingIdentifier(callbackCall);
-};
-const isExclusiveIntrinsicReactEventHandler = (functionNode, index) => {
-	const bindingIdentifier = getIntrinsicReactEventHandlerBindingIdentifier(functionNode, index);
-	if (!bindingIdentifier) return isInsideIntrinsicReactEventHandlerAttribute(functionNode, index.componentFunction);
-	const bindingSymbol = index.context.scopes.symbolFor(bindingIdentifier);
-	return Boolean(bindingSymbol && bindingSymbol.references.length > 0 && bindingSymbol.references.every((reference) => isInsideIntrinsicReactEventHandlerAttribute(reference.identifier, index.componentFunction)));
-};
-const canNodeReachNode = (sourceNode, targetNode, index) => {
-	const { context } = index;
-	if (!isNodeReachableWithinFunction(sourceNode, context)) return false;
-	if (!isNodeReachableWithinFunction(targetNode, context)) return false;
-	const sourceOwner = context.cfg.enclosingFunction(sourceNode);
-	const targetOwner = context.cfg.enclosingFunction(targetNode);
-	if (!sourceOwner || sourceOwner !== targetOwner) return false;
-	if (areInMutuallyExclusiveConditionalBranches(sourceNode, targetNode)) return false;
-	if (haveContradictoryStableBooleanGuards(sourceNode, targetNode, sourceOwner, context.scopes)) return false;
-	if (isDescendantWithoutFunctionBoundary(targetNode, sourceNode)) return false;
-	if (isDescendantWithoutFunctionBoundary(sourceNode, targetNode)) return true;
-	const functionCfg = context.cfg.cfgFor(sourceOwner);
-	const sourceBlock = functionCfg?.blockOf(sourceNode);
-	const targetBlock = functionCfg?.blockOf(targetNode);
-	if (!functionCfg || !sourceBlock || !targetBlock) return false;
-	if (sourceBlock === targetBlock) {
-		const sourceStart = getRangeStart(sourceNode);
-		const targetStart = getRangeStart(targetNode);
-		return sourceStart !== null && targetStart !== null && sourceStart < targetStart;
-	}
-	const visitedBlocks = new Set([sourceBlock]);
-	const pendingBlocks = sourceBlock.successors.filter((edge) => edge.kind !== "throw").map((edge) => edge.to);
-	while (pendingBlocks.length > 0) {
-		const block = pendingBlocks.pop();
-		if (!block || visitedBlocks.has(block)) continue;
-		if (block === targetBlock) return true;
-		visitedBlocks.add(block);
-		for (const edge of block.successors) if (edge.kind !== "throw") pendingBlocks.push(edge.to);
-	}
-	return false;
-};
-const getInlineIntrinsicHandlerJsxElement = (functionNode) => {
-	let currentNode = functionNode;
-	while (currentNode) {
-		if (isNodeOfType(currentNode, "JSXAttribute") && isEventHandlerAttribute(currentNode) && isJsxAttributeOnIntrinsicHtmlElement(currentNode)) {
-			const openingElement = currentNode.parent;
-			return isNodeOfType(openingElement?.parent, "JSXElement") ? openingElement.parent : null;
-		}
-		if (currentNode !== functionNode && isFunctionLike$1(currentNode)) return null;
-		currentNode = currentNode.parent;
-	}
-	return null;
-};
-const isProvenNonEscapingVoidRead = (identifier) => {
-	const expressionRoot = findTransparentExpressionRoot(identifier);
-	return isNodeOfType(expressionRoot.parent, "UnaryExpression") && expressionRoot.parent.operator === "void" && expressionRoot.parent.argument === expressionRoot;
-};
-const getDirectReadonlyValueAliasSymbol = (referenceIdentifier, sourceSymbol, index) => {
-	const referenceRoot = findTransparentExpressionRoot(referenceIdentifier);
-	const parent = referenceRoot.parent;
-	if (isNodeOfType(parent, "VariableDeclarator") && parent.init === referenceRoot && isNodeOfType(parent.id, "Identifier")) {
-		const aliasSymbol = index.context.scopes.symbolFor(parent.id);
-		const aliasInitializer = aliasSymbol ? getDirectConstInitializer(aliasSymbol) : null;
-		const unwrappedInitializer = aliasInitializer ? stripParenExpression(aliasInitializer) : null;
-		return aliasSymbol && isNodeOfType(unwrappedInitializer, "Identifier") && index.context.scopes.symbolFor(unwrappedInitializer) === sourceSymbol ? aliasSymbol : null;
-	}
-	if (!isNodeOfType(parent, "CallExpression") || parent.arguments?.[0] !== referenceRoot || !isReactApiCall(parent, "useCallback", index.context.scopes, { resolveNamedAliases: true })) return null;
-	const callbackResultRoot = findTransparentExpressionRoot(parent);
-	const resultParent = callbackResultRoot.parent;
-	if (!isNodeOfType(resultParent, "VariableDeclarator") || resultParent.init !== callbackResultRoot || !isNodeOfType(resultParent.id, "Identifier")) return null;
-	const callbackResultSymbol = index.context.scopes.symbolFor(resultParent.id);
-	return callbackResultSymbol && getDirectConstInitializer(callbackResultSymbol) === callbackResultRoot ? callbackResultSymbol : null;
-};
-const isKnownAggregateMutationReference = (referenceIdentifier, index) => {
-	const referenceRoot = findTransparentExpressionRoot(referenceIdentifier);
-	const parent = referenceRoot.parent;
-	if (isNodeOfType(parent, "MemberExpression") && parent.object === referenceRoot) {
-		const memberRoot = findTransparentExpressionRoot(parent);
-		const callExpression = memberRoot.parent;
-		const methodName = getStaticPropertyName(parent);
-		if (isNodeOfType(callExpression, "CallExpression") && callExpression.callee === memberRoot && methodName !== null && AGGREGATE_MUTATION_METHOD_NAMES.has(methodName)) return true;
-	}
-	if (!isNodeOfType(parent, "CallExpression") || parent.arguments?.[0] !== referenceRoot) return false;
-	const callee = stripParenExpression(parent.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const methodName = getStaticPropertyName(callee);
-	if (methodName === null) return false;
-	return OBJECT_AGGREGATE_MUTATION_METHOD_NAMES.has(methodName) && isProvenGlobalNamespaceReference(callee.object, "Object", index.context.scopes) || REFLECT_AGGREGATE_MUTATION_METHOD_NAMES.has(methodName) && isProvenGlobalNamespaceReference(callee.object, "Reflect", index.context.scopes);
-};
-const collectExactReadonlyValueEscapeAnchors = (symbol, index, valueFunctionNode, options = {}, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (visitedSymbolIds.has(symbol.id)) return null;
-	if (symbol.references.some((reference) => reference.flag !== "read" || isWithinAssignmentTarget(reference.identifier) || options.rejectKnownMutations && isKnownAggregateMutationReference(reference.identifier, index))) return null;
-	const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-	nextVisitedSymbolIds.add(symbol.id);
-	const escapeAnchors = [];
-	for (const reference of symbol.references) {
-		if (valueFunctionNode && index.context.cfg.enclosingFunction(reference.identifier) === valueFunctionNode || isProvenNonEscapingVoidRead(reference.identifier)) continue;
-		const aliasSymbol = getDirectReadonlyValueAliasSymbol(reference.identifier, symbol, index);
-		if (!aliasSymbol) {
-			escapeAnchors.push(reference.identifier);
-			continue;
-		}
-		const aliasEscapeAnchors = collectExactReadonlyValueEscapeAnchors(aliasSymbol, index, valueFunctionNode, options, nextVisitedSymbolIds);
-		if (!aliasEscapeAnchors) return null;
-		escapeAnchors.push(...aliasEscapeAnchors);
-	}
-	return escapeAnchors.length > 0 ? escapeAnchors : null;
-};
-const findReadonlyJsxAggregateRoot = (jsxElement) => {
-	let aggregateRoot = findTransparentExpressionRoot(jsxElement);
-	while (aggregateRoot.parent) {
-		const parent = aggregateRoot.parent;
-		if ((isNodeOfType(parent, "JSXElement") || isNodeOfType(parent, "JSXFragment")) && parent.children?.some((child) => child === aggregateRoot)) {
-			aggregateRoot = parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "ArrayExpression") && parent.elements?.some((element) => element === aggregateRoot)) {
-			aggregateRoot = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "Property") && parent.value === aggregateRoot && parent.kind === "init" && !parent.computed && isNodeOfType(parent.parent, "ObjectExpression")) {
-			aggregateRoot = findTransparentExpressionRoot(parent.parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === aggregateRoot || parent.alternate === aggregateRoot)) {
-			aggregateRoot = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression") && (parent.right === aggregateRoot || parent.left === aggregateRoot && parent.operator !== "&&")) {
-			aggregateRoot = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "SequenceExpression") && getFinalSequenceExpressionValue(parent) === getFinalSequenceExpressionValue(aggregateRoot)) {
-			aggregateRoot = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		break;
-	}
-	return aggregateRoot;
-};
-const getReadonlyJsxValueEscapeAnchors = (jsxElement, index) => {
-	const jsxValueRoot = findReadonlyJsxAggregateRoot(jsxElement);
-	const parent = jsxValueRoot.parent;
-	if (!isNodeOfType(parent, "VariableDeclarator") || parent.init !== jsxValueRoot) return [jsxValueRoot];
-	if (!isNodeOfType(parent.id, "Identifier")) return null;
-	const bindingSymbol = index.context.scopes.symbolFor(parent.id);
-	if (!bindingSymbol || getDirectConstInitializer(bindingSymbol) !== jsxValueRoot) return null;
-	return collectExactReadonlyValueEscapeAnchors(bindingSymbol, index, null, { rejectKnownMutations: true });
-};
-const getExclusiveIntrinsicReactEventHandlerAnchors = (functionNode, index) => {
-	if (!isExclusiveIntrinsicReactEventHandler(functionNode, index)) return null;
-	const bindingIdentifier = getIntrinsicReactEventHandlerBindingIdentifier(functionNode, index);
-	if (!bindingIdentifier) {
-		const jsxElement = getInlineIntrinsicHandlerJsxElement(functionNode);
-		return jsxElement ? getReadonlyJsxValueEscapeAnchors(jsxElement, index) : null;
-	}
-	return index.context.scopes.symbolFor(bindingIdentifier)?.references.map((reference) => reference.identifier) ?? null;
-};
-const getReadonlyFunctionEscapeAnchors = (functionNode, index) => {
-	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
-	if (!bindingIdentifier) return null;
-	const bindingSymbol = index.context.scopes.symbolFor(bindingIdentifier);
-	if (!bindingSymbol || resolveExactLocalFunction(bindingIdentifier, index.context.scopes) !== functionNode) return null;
-	return collectExactReadonlyValueEscapeAnchors(bindingSymbol, index, functionNode);
-};
-const isAliasInitializedBeforeExecution = (aliasDeclaration, executionNode, index, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
-	if (!isNodeReachableWithinFunction(aliasDeclaration, index.context)) return false;
-	const aliasOwner = index.context.cfg.enclosingFunction(aliasDeclaration);
-	const executionOwner = index.context.cfg.enclosingFunction(executionNode);
-	if (!aliasOwner || !executionOwner) return false;
-	if (aliasOwner === executionOwner) return canNodeReachNode(aliasDeclaration, executionNode, index);
-	if (visitedFunctionNodes.has(executionOwner)) return false;
-	const nextVisitedFunctionNodes = new Set(visitedFunctionNodes);
-	nextVisitedFunctionNodes.add(executionOwner);
-	if (aliasOwner === index.componentFunction && (index.effectCallbacks.has(executionOwner) || index.mountedListenerFunctions.has(executionOwner))) return doNodesCoverEveryPathFromFunctionEntry(index.componentFunction, [aliasDeclaration], index.context, { ignoreThrowEdges: true });
-	const invocations = new Set([...index.callSitesByFunction.get(executionOwner) ?? [], ...index.synchronousInvocationsByFunction.get(executionOwner) ?? []]);
-	if (invocations.size > 0) return [...invocations].every((invocation) => isAliasInitializedBeforeExecution(aliasDeclaration, invocation, index, nextVisitedFunctionNodes));
-	const deferredExecutionAnchors = getExclusiveIntrinsicReactEventHandlerAnchors(executionOwner, index);
-	if (deferredExecutionAnchors) return deferredExecutionAnchors.every((anchor) => isAliasInitializedBeforeExecution(aliasDeclaration, anchor, index, nextVisitedFunctionNodes));
-	const functionEscapeAnchors = getReadonlyFunctionEscapeAnchors(executionOwner, index);
-	return Boolean(functionEscapeAnchors?.every((anchor) => isAliasInitializedBeforeExecution(aliasDeclaration, anchor, index, nextVisitedFunctionNodes)));
-};
-const resolveExactReadonlyCalleeSymbolId = (callExpression, index) => {
-	if (!isNodeOfType(callExpression, "CallExpression")) return null;
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "Identifier")) return null;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	let symbol = index.context.scopes.symbolFor(callee);
-	while (symbol) {
-		if (visitedSymbolIds.has(symbol.id)) return null;
-		visitedSymbolIds.add(symbol.id);
-		const initializer = getDirectConstInitializer(symbol);
-		if (!initializer) return symbol.id;
-		if (symbol.references.some((reference) => reference.flag !== "read" || isWithinAssignmentTarget(reference.identifier)) || !isAliasInitializedBeforeExecution(symbol.declarationNode, callExpression, index)) return null;
-		const unwrappedInitializer = stripParenExpression(initializer);
-		if (!isNodeOfType(unwrappedInitializer, "Identifier")) return symbol.id;
-		const initializerSymbol = index.context.scopes.symbolFor(unwrappedInitializer);
-		if (!initializerSymbol || !isAliasInitializedBeforeExecution(initializerSymbol.declarationNode, symbol.declarationNode, index)) return null;
-		symbol = initializerSymbol;
-	}
-	return null;
-};
-const collectExactReadonlyCalleeCalls = (index) => {
-	for (const callExpression of index.identifierCalls) {
-		const calleeSymbolId = resolveExactReadonlyCalleeSymbolId(callExpression, index);
-		if (calleeSymbolId !== null) addToSetIndex(index.callsByCalleeSymbolId, calleeSymbolId, callExpression);
-	}
-};
-const canNodeReachNormalFunctionExit = (node, functionNode, index) => {
-	const functionCfg = index.context.cfg.cfgFor(functionNode);
-	const sourceBlock = functionCfg?.blockOf(node);
-	if (!functionCfg || !sourceBlock) return false;
-	const visitedBlocks = /* @__PURE__ */ new Set();
-	const pendingBlocks = [sourceBlock];
-	while (pendingBlocks.length > 0) {
-		const block = pendingBlocks.pop();
-		if (!block || visitedBlocks.has(block)) continue;
-		visitedBlocks.add(block);
-		for (const edge of block.successors) {
-			if (edge.kind === "throw") continue;
-			if (edge.to === functionCfg.exit) return true;
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return false;
-};
-const canExecuteBeforeAsyncSuspension = (node, functionNode, index) => {
-	if (!isFunctionLike$1(functionNode) || !functionNode.async) return isNodeReachableWithinFunction(node, index.context);
-	const functionCfg = index.context.cfg.cfgFor(functionNode);
-	const targetBlock = functionCfg?.blockOf(node);
-	if (!functionCfg || !targetBlock) return false;
-	const awaitsByBlock = /* @__PURE__ */ new Map();
-	for (const awaitExpression of index.awaitExpressionsByOwner.get(functionNode) ?? []) {
-		const awaitBlock = functionCfg.blockOf(awaitExpression);
-		if (!awaitBlock) continue;
-		const blockAwaits = awaitsByBlock.get(awaitBlock) ?? [];
-		blockAwaits.push(awaitExpression);
-		awaitsByBlock.set(awaitBlock, blockAwaits);
-	}
-	const visitedBlocks = /* @__PURE__ */ new Set();
-	const pendingBlocks = [functionCfg.entry];
-	const targetStart = getRangeStart(node);
-	while (pendingBlocks.length > 0) {
-		const block = pendingBlocks.pop();
-		if (!block || visitedBlocks.has(block)) continue;
-		visitedBlocks.add(block);
-		const blockAwaits = awaitsByBlock.get(block) ?? [];
-		if (block === targetBlock) return !blockAwaits.some((awaitExpression) => {
-			if (isNodeOfType(awaitExpression, "AwaitExpression") && isDescendantWithoutFunctionBoundary(node, awaitExpression.argument)) return false;
-			if (isDescendantWithoutFunctionBoundary(awaitExpression, node)) return true;
-			const awaitStart = getRangeStart(awaitExpression);
-			return awaitStart !== null && targetStart !== null && awaitStart < targetStart;
-		});
-		if (blockAwaits.length > 0) continue;
-		for (const edge of block.successors) if (edge.kind !== "throw") pendingBlocks.push(edge.to);
-	}
-	return false;
-};
-const canReactBatchMutationAfterExecution = (executionNode, mutationNode, owner, index) => (isExclusiveIntrinsicReactEventHandler(owner, index) || index.effectCallbacks.has(owner)) && canNodeReachNode(executionNode, mutationNode, index) && canExecuteBeforeAsyncSuspension(mutationNode, owner, index) && canNodeReachNormalFunctionExit(mutationNode, owner, index);
-const functionMaySynchronouslyMutateLocation = (functionNode, index, visitingFunctions, cycleAffectedFunctions) => {
-	const cachedResult = index.synchronousMutationResultByFunction.get(functionNode);
-	if (cachedResult !== void 0) return cachedResult;
-	if (!isFunctionLike$1(functionNode) || functionNode.generator) return false;
-	if (visitingFunctions.has(functionNode)) {
-		let didReachCycleEntry = false;
-		for (const visitingFunction of visitingFunctions) {
-			if (visitingFunction === functionNode) didReachCycleEntry = true;
-			if (didReachCycleEntry) cycleAffectedFunctions.add(visitingFunction);
-		}
-		return false;
-	}
-	visitingFunctions.add(functionNode);
-	const doesMutateSynchronously = [...collectLocationMutationExecutions(functionNode, index, visitingFunctions, cycleAffectedFunctions)].some((mutationExecution) => canExecuteBeforeAsyncSuspension(mutationExecution, functionNode, index) && canNodeReachNormalFunctionExit(mutationExecution, functionNode, index));
-	visitingFunctions.delete(functionNode);
-	if (doesMutateSynchronously || !cycleAffectedFunctions.has(functionNode)) index.synchronousMutationResultByFunction.set(functionNode, doesMutateSynchronously);
-	return doesMutateSynchronously;
-};
-const collectLocationMutationExecutions = (functionNode, index, visitingFunctions = /* @__PURE__ */ new Set(), cycleAffectedFunctions = /* @__PURE__ */ new Set()) => {
-	const cachedExecutions = index.mutationExecutionsByOwner.get(functionNode);
-	if (cachedExecutions) return cachedExecutions;
-	const mutationExecutions = new Set(index.historyMutationsByOwner.get(functionNode) ?? []);
-	for (const expression of index.expressionsByOwner.get(functionNode) ?? []) {
-		const calledFunction = index.calledFunctionByExpression.get(expression);
-		if (calledFunction && functionMaySynchronouslyMutateLocation(calledFunction, index, visitingFunctions, cycleAffectedFunctions)) mutationExecutions.add(expression);
-		for (const callbackFunction of index.synchronousCallbacksByExpression.get(expression) ?? []) if (functionMaySynchronouslyMutateLocation(callbackFunction, index, visitingFunctions, cycleAffectedFunctions)) mutationExecutions.add(expression);
-	}
-	if (!cycleAffectedFunctions.has(functionNode)) index.mutationExecutionsByOwner.set(functionNode, mutationExecutions);
-	return mutationExecutions;
-};
-const isDefinitelyMatchingLocationListenerRemoval = (registration, removal) => registration.eventName === removal.eventName && registration.listenerFunction === removal.listenerFunction && registration.capture !== null && removal.capture !== null && registration.capture === removal.capture;
-const functionMustSynchronouslyRemoveLocationListener = (functionNode, registration, index, visitingFunctions) => {
-	if (!isFunctionLike$1(functionNode) || functionNode.generator) return false;
-	if (visitingFunctions.has(functionNode)) return false;
-	const nextVisitingFunctions = new Set(visitingFunctions);
-	nextVisitingFunctions.add(functionNode);
-	const removalExecutions = [];
-	for (const removal of index.listenerRemovals) {
-		if (!isDefinitelyMatchingLocationListenerRemoval(registration, removal)) continue;
-		if (index.context.cfg.enclosingFunction(removal.callExpression) !== functionNode) continue;
-		if (canExecuteBeforeAsyncSuspension(removal.callExpression, functionNode, index)) removalExecutions.push(removal.callExpression);
-	}
-	for (const expression of index.expressionsByOwner.get(functionNode) ?? []) {
-		const calledFunction = index.calledFunctionByExpression.get(expression);
-		if (calledFunction && canExecuteBeforeAsyncSuspension(expression, functionNode, index) && functionMustSynchronouslyRemoveLocationListener(calledFunction, registration, index, nextVisitingFunctions)) removalExecutions.push(expression);
-	}
-	return doNodesCoverEveryPathFromFunctionEntry(functionNode, removalExecutions, index.context);
-};
-const collectSynchronousLocationListenerRemovalExecutions = (functionNode, registration, index) => {
-	const removalExecutions = /* @__PURE__ */ new Set();
-	for (const removal of index.listenerRemovals) if (isDefinitelyMatchingLocationListenerRemoval(registration, removal) && index.context.cfg.enclosingFunction(removal.callExpression) === functionNode && canExecuteBeforeAsyncSuspension(removal.callExpression, functionNode, index)) removalExecutions.add(removal.callExpression);
-	for (const expression of index.expressionsByOwner.get(functionNode) ?? []) {
-		const calledFunction = index.calledFunctionByExpression.get(expression);
-		if (calledFunction && canExecuteBeforeAsyncSuspension(expression, functionNode, index) && functionMustSynchronouslyRemoveLocationListener(calledFunction, registration, index, /* @__PURE__ */ new Set())) removalExecutions.add(expression);
-	}
-	return removalExecutions;
-};
-const collectImpliedExpressionExecutionBoundaries = (node, owner) => {
-	const expressionBoundaries = [];
-	let currentChild = node;
-	let currentParent = currentChild.parent ?? null;
-	while (currentParent && currentParent !== owner) {
-		if (isNodeOfType(currentParent, "ConditionalExpression") && currentParent.test === currentChild) {
-			const staticTestValue = readStaticBoolean(getFinalSequenceExpressionValue(currentParent.test));
-			if (staticTestValue !== null) expressionBoundaries.push(staticTestValue ? currentParent.consequent : currentParent.alternate);
-		}
-		if (isNodeOfType(currentParent, "LogicalExpression") && currentParent.left === currentChild) {
-			const staticLeftValue = readStaticBoolean(getFinalSequenceExpressionValue(currentParent.left));
-			if (currentParent.operator === "&&" && staticLeftValue === true || currentParent.operator === "||" && staticLeftValue === false) expressionBoundaries.push(currentParent.right);
-		}
-		if (isNodeOfType(currentParent, "ConditionalExpression") && (currentParent.consequent === currentChild || currentParent.alternate === currentChild) || isNodeOfType(currentParent, "LogicalExpression") && currentParent.right === currentChild || isNodeOfType(currentParent, "AssignmentPattern") && currentParent.right === currentChild) expressionBoundaries.push(currentChild);
-		currentChild = currentParent;
-		currentParent = currentChild.parent ?? null;
-	}
-	return expressionBoundaries;
-};
-const canExecutionReachFunctionExitWithoutListenerRemoval = (executionNode, registration, index) => {
-	if (!isNodeReachableWithinFunction(executionNode, index.context)) return false;
-	const owner = index.context.cfg.enclosingFunction(executionNode);
-	if (!owner) return false;
-	const functionCfg = index.context.cfg.cfgFor(owner);
-	const sourceBlock = functionCfg?.blockOf(executionNode);
-	if (!functionCfg || !sourceBlock) return false;
-	const expressionBoundaries = collectImpliedExpressionExecutionBoundaries(executionNode, owner);
-	const matchingRemovalsByBlock = /* @__PURE__ */ new Map();
-	for (const removalExecution of collectSynchronousLocationListenerRemovalExecutions(owner, registration, index)) {
-		const removalBlock = functionCfg.blockOf(removalExecution);
-		if (!removalBlock) continue;
-		const blockRemovals = matchingRemovalsByBlock.get(removalBlock) ?? [];
-		blockRemovals.push(removalExecution);
-		matchingRemovalsByBlock.set(removalBlock, blockRemovals);
-	}
-	const sourceStart = getRangeStart(executionNode);
-	const hasRemovalAfterExecution = (block) => {
-		const removals = (matchingRemovalsByBlock.get(block) ?? []).filter((removal) => {
-			if (block !== sourceBlock) return true;
-			const removalStart = getRangeStart(removal);
-			return sourceStart !== null && removalStart !== null && sourceStart < removalStart;
-		});
-		if (collectExpressionPathCoverageNodes(owner, removals, index.context).size > 0) return true;
-		if (block !== sourceBlock) return false;
-		return expressionBoundaries.some((expressionBoundary) => collectExpressionPathCoverageNodes(owner, removals, index.context, expressionBoundary).size > 0);
-	};
-	const visitedBlocks = /* @__PURE__ */ new Set();
-	const pendingBlocks = [sourceBlock];
-	while (pendingBlocks.length > 0) {
-		const block = pendingBlocks.pop();
-		if (!block || visitedBlocks.has(block)) continue;
-		visitedBlocks.add(block);
-		if (hasRemovalAfterExecution(block)) continue;
-		for (const edge of block.successors) {
-			if (edge.kind === "throw") continue;
-			if (edge.to === functionCfg.exit) return true;
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return false;
-};
-const isListenerActiveAtMountedExit = (executionNode, registration, index, visitedExecutions = /* @__PURE__ */ new Set()) => {
-	if (visitedExecutions.has(executionNode)) return false;
-	if (!canExecutionReachFunctionExitWithoutListenerRemoval(executionNode, registration, index)) return false;
-	const owner = index.context.cfg.enclosingFunction(executionNode);
-	if (!owner) return false;
-	if (owner === index.componentFunction || index.effectCallbacks.has(owner)) return true;
-	const nextVisitedExecutions = new Set(visitedExecutions);
-	nextVisitedExecutions.add(executionNode);
-	for (const callSite of index.callSitesByFunction.get(owner) ?? []) if (isListenerActiveAtMountedExit(callSite, registration, index, nextVisitedExecutions)) return true;
-	for (const invocation of index.synchronousInvocationsByFunction.get(owner) ?? []) if (isListenerActiveAtMountedExit(invocation, registration, index, nextVisitedExecutions)) return true;
-	return false;
-};
-const collectMountedListenerFunctions = (index) => {
-	for (const registration of index.listenerRegistrations) if (isListenerActiveAtMountedExit(registration.callExpression, registration, index)) index.mountedListenerFunctions.add(registration.listenerFunction);
-};
-const setterArgumentMutatesLocation = (setterCall, index) => {
-	if (!isNodeOfType(setterCall, "CallExpression")) return false;
-	return (setterCall.arguments ?? []).some((argument) => {
-		if (isNodeOfType(argument, "SpreadElement")) return false;
-		const updaterFunction = resolveExactLocalFunction(argument, index.context.scopes);
-		return Boolean(isFunctionLike$1(updaterFunction) && functionMaySynchronouslyMutateLocation(updaterFunction, index, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()));
-	});
-};
-const executionAnchorInvalidatesLocationSnapshot = (executionAnchor, index, visitedExecutions = /* @__PURE__ */ new Set()) => {
-	if (visitedExecutions.has(executionAnchor)) return false;
-	if (!isNodeReachableWithinFunction(executionAnchor, index.context)) return false;
-	const owner = index.context.cfg.enclosingFunction(executionAnchor);
-	if (!owner) return false;
-	if (index.mountedListenerFunctions.has(owner)) return true;
-	if (setterArgumentMutatesLocation(executionAnchor, index) || [...collectLocationMutationExecutions(owner, index)].some((mutationExecution) => canNodeReachNode(mutationExecution, executionAnchor, index) || canReactBatchMutationAfterExecution(executionAnchor, mutationExecution, owner, index))) return true;
-	const nextVisitedExecutions = new Set(visitedExecutions);
-	nextVisitedExecutions.add(executionAnchor);
-	for (const callSite of index.callSitesByFunction.get(owner) ?? []) if (executionAnchorInvalidatesLocationSnapshot(callSite, index, nextVisitedExecutions)) return true;
-	for (const invocation of index.synchronousInvocationsByFunction.get(owner) ?? []) if (executionAnchorInvalidatesLocationSnapshot(invocation, index, nextVisitedExecutions)) return true;
-	return false;
-};
-const setterInvalidatesGlobalLocationSnapshot = (setterBindingIdentifier, index) => {
-	const setterSymbol = index.context.scopes.symbolFor(setterBindingIdentifier);
-	if (!setterSymbol) return false;
-	return [...index.callsByCalleeSymbolId.get(setterSymbol.id) ?? []].some((setterCall) => executionAnchorInvalidatesLocationSnapshot(setterCall, index));
-};
-const createExternalLocationInvalidationChecker = ({ componentBody, componentFunction, context, directRenderNames, renderReachableExpressions }) => {
-	if (!hasRenderReachableLocationSnapshotRead(componentBody, renderReachableExpressions, directRenderNames, context.scopes)) return () => false;
-	const locationInvalidationIndex = buildLocationInvalidationIndex(componentBody, componentFunction, context);
-	collectMountedListenerFunctions(locationInvalidationIndex);
-	collectExactReadonlyCalleeCalls(locationInvalidationIndex);
-	return (setterBindingIdentifier) => setterInvalidatesGlobalLocationSnapshot(setterBindingIdentifier, locationInvalidationIndex);
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/rerender-state-only-in-handlers.ts
 const isInsideConditionTest = (identifier, stopAt) => {
 	let current = identifier;
@@ -62068,8 +60289,7 @@ const rerenderStateOnlyInHandlers = defineRule({
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
 			const bindings = collectUseStateBindings(componentBody, context.scopes);
 			if (bindings.length === 0) return;
-			const renderReachableExpressions = collectRenderReachableExpressions(componentBody);
-			if (renderReachableExpressions.length === 0) return;
+			if (collectRenderReachableExpressions(componentBody).length === 0) return;
 			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody, context.scopes);
 			const dependencyGraph = buildLocalDependencyGraph(componentBody, eventHandlerReferenceNames);
 			const directRenderNames = collectRenderReachableNames(componentBody, context.scopes, eventHandlerReferenceNames);
@@ -62083,22 +60303,12 @@ const rerenderStateOnlyInHandlers = defineRule({
 			for (const effectInfo of effectInfos) for (const dependencyName of effectInfo.dependencyNames) if (!selfEchoValueNames.has(dependencyName)) effectConsumedNames.add(dependencyName);
 			for (const hookArgumentName of collectCustomHookArgumentNames(componentBody, context.scopes)) effectConsumedNames.add(hookArgumentName);
 			for (const reachableName of expandTransitiveDependencies(effectConsumedNames, dependencyGraph)) renderReachableNames.add(reachableName);
-			const componentFunction = context.cfg.enclosingFunction(componentBody);
-			const doesSetterInvalidateExternalLocation = isFunctionLike$1(componentFunction) ? createExternalLocationInvalidationChecker({
-				componentBody,
-				componentFunction,
-				context,
-				directRenderNames,
-				renderReachableExpressions
-			}) : () => false;
 			const calledSetterNames = /* @__PURE__ */ new Set();
 			walkAst(componentBody, (child) => {
 				if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && setterNames.has(child.callee.name)) calledSetterNames.add(child.callee.name);
 			});
 			for (const binding of bindings) {
 				if (renderReachableNames.has(binding.valueName)) continue;
-				const setterBindingIdentifier = isNodeOfType(binding.declarator.id, "ArrayPattern") ? binding.declarator.id.elements?.[1] : null;
-				if (setterBindingIdentifier && doesSetterInvalidateExternalLocation(setterBindingIdentifier)) continue;
 				if (binding.valueName === "_" || binding.valueName.startsWith("_")) continue;
 				const setterSuffix = binding.setterName.slice(3);
 				if (/^(TriggerRender|ForceUpdate|Rerender|ForceRender|Tick|Bump|BumpVersion|InvalidateRender|Refresh|Repaint)$/i.test(setterSuffix)) continue;
@@ -65005,66 +63215,6 @@ const roleHasRequiredAriaProps = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/constants/global-aria-properties.ts
-const GLOBAL_ARIA_PROPERTIES = new Set([
-	"aria-atomic",
-	"aria-braillelabel",
-	"aria-brailleroledescription",
-	"aria-busy",
-	"aria-controls",
-	"aria-current",
-	"aria-describedby",
-	"aria-description",
-	"aria-details",
-	"aria-disabled",
-	"aria-dropeffect",
-	"aria-errormessage",
-	"aria-flowto",
-	"aria-grabbed",
-	"aria-haspopup",
-	"aria-hidden",
-	"aria-invalid",
-	"aria-keyshortcuts",
-	"aria-label",
-	"aria-labelledby",
-	"aria-live",
-	"aria-owns",
-	"aria-relevant",
-	"aria-roledescription"
-]);
-//#endregion
-//#region src/plugin/constants/prohibited-aria-properties-by-role.ts
-const ACCESSIBLE_NAME_PROPERTIES = new Set([
-	"aria-braillelabel",
-	"aria-label",
-	"aria-labelledby"
-]);
-const PROHIBITED_ARIA_PROPERTIES_BY_ROLE = {
-	caption: ACCESSIBLE_NAME_PROPERTIES,
-	code: ACCESSIBLE_NAME_PROPERTIES,
-	definition: ACCESSIBLE_NAME_PROPERTIES,
-	deletion: ACCESSIBLE_NAME_PROPERTIES,
-	emphasis: ACCESSIBLE_NAME_PROPERTIES,
-	generic: new Set([
-		"aria-braillelabel",
-		"aria-brailleroledescription",
-		"aria-label",
-		"aria-labelledby",
-		"aria-roledescription"
-	]),
-	insertion: ACCESSIBLE_NAME_PROPERTIES,
-	mark: ACCESSIBLE_NAME_PROPERTIES,
-	none: ACCESSIBLE_NAME_PROPERTIES,
-	paragraph: ACCESSIBLE_NAME_PROPERTIES,
-	presentation: ACCESSIBLE_NAME_PROPERTIES,
-	strong: ACCESSIBLE_NAME_PROPERTIES,
-	subscript: ACCESSIBLE_NAME_PROPERTIES,
-	superscript: ACCESSIBLE_NAME_PROPERTIES,
-	term: ACCESSIBLE_NAME_PROPERTIES,
-	time: ACCESSIBLE_NAME_PROPERTIES,
-	tooltip: ACCESSIBLE_NAME_PROPERTIES
-};
-//#endregion
 //#region src/plugin/constants/role-supports-aria-props.ts
 const ROLE_SUPPORTS_ARIA_PROPS = {
 	alert: new Set([
@@ -68165,12 +66315,6 @@ const ROLE_SUPPORTS_ARIA_PROPS = {
 	])
 };
 //#endregion
-//#region src/plugin/utils/is-aria-property-supported-by-role.ts
-const isAriaPropertySupportedByRole = (role, property) => {
-	if (PROHIBITED_ARIA_PROPERTIES_BY_ROLE[role]?.has(property)) return false;
-	return ROLE_SUPPORTS_ARIA_PROPS[role]?.has(property) === true || GLOBAL_ARIA_PROPERTIES.has(property);
-};
-//#endregion
 //#region src/plugin/rules/a11y/role-supports-aria-props.ts
 const buildMessageDefault = (roles, propName) => {
 	return `Screen reader users get no help from \`${propName}\` because role ${roles.map((role) => `\`${role}\``).join(" / ")} ignores it, so remove it or change the role.`;
@@ -68207,10 +66351,16 @@ const roleSupportsAriaProps = defineRule({
 		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 		const roleCandidates = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : [getImplicitRole(node, elementType, context.scopes)].filter((role) => role !== null);
 		if (roleCandidates === null || roleCandidates.length === 0) return;
-		for (const role of roleCandidates) if (!VALID_ARIA_ROLES.has(role)) return;
+		const supportedSets = [];
+		for (const role of roleCandidates) {
+			if (!VALID_ARIA_ROLES.has(role)) return;
+			const supported = ROLE_SUPPORTS_ARIA_PROPS[role];
+			if (!supported) return;
+			supportedSets.push(supported);
+		}
 		const isImplicit = !roleAttribute;
 		for (const { attribute, propName } of ariaAttributes) {
-			if (roleCandidates.some((role) => isAriaPropertySupportedByRole(role, propName))) continue;
+			if (supportedSets.some((supported) => supported.has(propName))) continue;
 			context.report({
 				node: attribute,
 				message: isImplicit ? buildMessageImplicit(roleCandidates[0], propName, elementType) : buildMessageDefault(roleCandidates, propName)
@@ -76992,7 +75142,7 @@ const EXTERNAL_RULES = [
 	{
 		key: "react-hooks-js/set-state-in-effect",
 		source: "react-compiler",
-		severity: "warn"
+		severity: "error"
 	},
 	{
 		key: "react-hooks-js/globals",