oxlint-plugin-react-doctor 0.8.1-dev.a2f9bf4 → 0.8.1-dev.a667b45

package/dist/index.js

@@ -762,7 +762,7 @@ const EXTERNAL_SYNC_MEMBER_METHOD_NAMES = new Set([
 	"put",
 	"patch"
 ]);
-const EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS = new Set([
+new Set([
 	...FETCH_MEMBER_OBJECTS,
 	"api",
 	"client",
@@ -9008,6 +9008,16 @@ 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",
@@ -9154,8 +9164,10 @@ 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");
@@ -13815,6 +13827,116 @@ 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;
@@ -13852,14 +13974,19 @@ const isAstDescendant = (inner, outer) => {
 };
 //#endregion
 //#region src/plugin/utils/react-ref-origin.ts
-const resolveReactRefSymbol = (memberExpression, scopes) => {
+const REACT_REF_API_NAMES = new Set(["createRef", "useRef"]);
+const resolveReactRefSymbol = (memberExpression, scopes, options = {}) => {
 	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
 	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticPropertyName(memberExpression) !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
 	const symbol = resolveConstIdentifierAlias(receiver, scopes);
 	if (!symbol?.initializer) return null;
 	const initializer = stripParenExpression(symbol.initializer);
 	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
+	return isReactApiCall(initializer, options.includeCreateRef ? REACT_REF_API_NAMES : "useRef", scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: options.allowUnboundBareCalls,
+		resolveNamedAliases: options.resolveNamedAliases
+	}) ? symbol : null;
 };
 const resolveReactRefCurrentOriginSymbol = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(node);
@@ -13958,6 +14085,20 @@ 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();
@@ -14110,6 +14251,30 @@ 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 {
@@ -14118,6 +14283,12 @@ 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),
 		registrationVerbName: callee.property.name,
@@ -14222,30 +14393,6 @@ 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;
@@ -14488,18 +14635,6 @@ 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);
@@ -14623,7 +14758,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 || doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, matchingLoopOrHelperAnchors, context);
+	return didCleanupFunctionMatch || doNodesCoverEveryPathFromFunctionEntry(cleanupFunction, matchingLoopOrHelperAnchors, context);
 };
 const doesBoundCleanupReleaseUsage = (expression, usage, context) => {
 	const callExpression = stripParenExpression(expression);
@@ -14652,7 +14787,7 @@ const callbackReturnsCleanupForUsage = (callback, usage, context) => {
 	walkInsideStatementBlocks(callback.body, (child) => {
 		if (isNodeOfType(child, "ReturnStatement") && child.argument && doesReturnedValueReleaseUsage(stripParenExpression(child.argument))) matchingCleanupReturns.push(child);
 	});
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
+	return doNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
 };
 const doesTestRequireLiveExpressionKey = (test, expressionKey, context) => {
 	if (resolveExpressionKey(test, context) === expressionKey) return true;
@@ -14695,7 +14830,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 doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
+	return doNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
 };
 const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	const componentFunction = findEnclosingFunction$1(callback);
@@ -14946,7 +15081,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) || !doMatchingNodesCoverEveryPathFromFunctionEntry(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) || !doNodesCoverEveryPathFromFunctionEntry(callback, cleanupReturns, context)) return false;
 	const cleanupFunctions = cleanupReturns.flatMap((cleanupReturn) => {
 		if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return [];
 		const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
@@ -14994,7 +15129,7 @@ const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) =>
 				});
 			}
 		});
-		if (!doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, globalReleaseProofs.map((releaseProof) => releaseProof.anchor), context)) return false;
+		if (!doNodesCoverEveryPathFromFunctionEntry(cleanupFunction, globalReleaseProofs.map((releaseProof) => releaseProof.anchor), context)) return false;
 		globalReleaseProofsByCleanup.set(cleanupFunction, globalReleaseProofs);
 	}
 	const handleAssignments = handleSymbol.references.filter((reference) => isWithinAssignmentTarget(reference.identifier));
@@ -15207,7 +15342,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 doMatchingNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
+	return doNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
 };
 const findDirectExhaustiveForEachCleanupFunction = (releaseNode, requiredCollectionKeys, context) => {
 	let currentNode = findTransparentExpressionRoot(releaseNode);
@@ -15220,7 +15355,7 @@ const findDirectExhaustiveForEachCleanupFunction = (releaseNode, requiredCollect
 		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 || !doMatchingNodesCoverEveryPathFromFunctionEntry(ownerFunction, [isDirectBlockStatement ? statementNode : currentNode], context)) return null;
+		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);
@@ -15308,7 +15443,7 @@ const hasSafeForEachProjectionCleanup = (registrationCall, releaseCall, context)
 	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) && doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseCall], context)) && (releaseVerbName !== null && UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName) || doesHandlerlessOffReleaseEveryRegistration)) return true;
+	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],
@@ -15355,6 +15490,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;
@@ -15506,7 +15642,7 @@ const hasEffectCleanupInvocation = (storage, usage, context) => {
 			if (!cleanupFunction || !cleanupFunctionInvokesRef(cleanupFunction)) return;
 			matchingReturns.push(child);
 		});
-		return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+		return doNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
 	};
 	let didFindInvocation = false;
 	walkAst(componentFunction.body, (child) => {
@@ -15558,7 +15694,7 @@ 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") || !doMatchingNodesCoverEveryPathFromFunctionEntry(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") || !doNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
 	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;
@@ -15786,7 +15922,7 @@ const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retaine
 	walkInsideStatementBlocks(effectCallback.body, (child) => {
 		if (isNodeOfType(child, "ReturnStatement") && child.argument && matchesReturnedCleanup(stripParenExpression(child.argument))) matchingReturns.push(child);
 	});
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+	return doNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
 };
 const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) => {
 	const componentFunction = findEnclosingFunction$1(retainedFunction);
@@ -15829,15 +15965,6 @@ 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;
@@ -16086,7 +16213,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 doMatchingNodesCoverEveryPathFromFunctionEntry(returnedCleanupFunction, matchingCalls, context);
+		return doNodesCoverEveryPathFromFunctionEntry(returnedCleanupFunction, matchingCalls, context);
 	};
 	const matchingReturns = [];
 	walkInsideStatementBlocks(retainedFunction.body, (child) => {
@@ -22436,25 +22563,49 @@ 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()) => {
-	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);
+	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 isProvenGlobalNamespaceReference = (expression, namespaceName, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const strippedExpression = stripParenExpression(expression);
-	if (isNodeOfType(strippedExpression, "Identifier")) {
+	let currentExpression = expression;
+	while (true) {
+		const strippedExpression = stripParenExpression(currentExpression);
+		if (!isNodeOfType(strippedExpression, "Identifier")) return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
 		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
 		const symbol = scopes.symbolFor(strippedExpression);
-		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+		if (!symbol || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
 		visitedSymbolIds.add(symbol.id);
-		return isProvenGlobalNamespaceReference(symbol.initializer, namespaceName, scopes, visitedSymbolIds);
+		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 isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
 };
 //#endregion
 //#region src/plugin/rules/js-performance/js-min-max-loop.ts
@@ -34716,6 +34867,19 @@ 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);
@@ -35244,19 +35408,8 @@ 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 = getReactUseCallbackSource(dependencyReference, context);
+	const useCallbackCall = getReactUseCallbackCall(dependencyReference.identifier, context.scopes);
 	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));
@@ -38770,6 +38923,17 @@ 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",
@@ -38914,7 +39078,16 @@ const collectDependencyStateSymbolIds = (effectNode, stateSymbolIds, scopes) =>
 	}
 	return dependencyStateSymbolIds;
 };
-const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
+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 analysisFunctions = new Set([effectCallback]);
 	const pendingFunctions = [effectCallback];
 	while (pendingFunctions.length > 0) {
@@ -38922,9 +39095,9 @@ const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
 		if (!currentFunction || !isFunctionLike$1(currentFunction)) continue;
 		walkInsideStatementBlocks(currentFunction.body, (child) => {
 			if (!isNodeOfType(child, "CallExpression")) return;
-			const invokedFunction = resolveExactLocalFunction(child.callee, scopes);
+			const invokedFunction = includeStableCallbacks ? resolveSynchronouslyInvokedFunction(child.callee, scopes) : resolveExactLocalFunction(child.callee, scopes);
 			if (!invokedFunction || analysisFunctions.has(invokedFunction)) return;
-			if (isFunctionLike$1(invokedFunction) && invokedFunction.async) return;
+			if (isFunctionLike$1(invokedFunction) && (invokedFunction.async || invokedFunction.generator)) return;
 			analysisFunctions.add(invokedFunction);
 			pendingFunctions.push(invokedFunction);
 		});
@@ -38937,7 +39110,51 @@ const visitSynchronousFunctionBodies = (analysisFunctions, visitor) => {
 		walkInsideStatementBlocks(analysisFunction.body, visitor);
 	}
 };
-const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+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 unwrappedExpression = stripParenExpression(expression);
 	if (isNodeOfType(unwrappedExpression, "Literal")) {
 		const literalValue = unwrappedExpression.value;
@@ -38945,46 +39162,49 @@ const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, vi
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		if (scopes.symbolFor(unwrappedExpression)?.id === stateSymbolId) return stateValue;
+		const symbol = scopes.symbolFor(unwrappedExpression);
+		if (symbol?.id === stateSymbolId) return stateValue;
+		if (symbol && additionalStateValues.has(symbol.id)) return additionalStateValues.get(symbol.id) ?? null;
 		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));
+		return readStaticEffectValue(immutableSymbol.initializer, scopes, stateSymbolId, stateValue, new Set(visitedSymbolIds).add(immutableSymbol.id), additionalStateValues);
 	}
 	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);
+		const argumentValue = readStaticEffectValue(unwrappedExpression.argument, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		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);
+			const argumentValue = readStaticEffectValue(unwrappedExpression.arguments[0], scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 			return argumentValue ? { value: Boolean(argumentValue.value) } : null;
 		}
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		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);
+		return readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 	}
 	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
-		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		if (!testValue) return null;
-		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 	}
 	if (isNodeOfType(unwrappedExpression, "MemberExpression") && unwrappedExpression.optional) {
-		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		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);
-		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		if (!leftValue || !rightValue) return null;
 		if (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "!==") {
 			const areEqual = leftValue.value === rightValue.value;
@@ -39023,8 +39243,7 @@ const collectStateWritesInEffect = (analysisFunctions, setterSymbolIdToStateName
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
-		const setterSymbol = resolveConstIdentifierAlias(child.callee, scopes, true);
-		const stateName = setterSymbol ? setterSymbolIdToStateName.get(setterSymbol.id) : void 0;
+		const stateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
 		if (!stateName) return;
 		const writeInfo = stateWrites.get(stateName) ?? {
 			values: /* @__PURE__ */ new Set(),
@@ -39040,27 +39259,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) => {
+const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map()) => {
 	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);
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
 			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);
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
 			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);
+			const leftValue = readStaticEffectValue(parentNode.left, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
 			if (leftValue) {
 				if (parentNode.operator === "&&" && !leftValue.value) return false;
 				if (parentNode.operator === "||" && leftValue.value) return false;
@@ -39072,7 +39291,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)?.value) return false;
+				if (readStaticEffectValue(earlierStatement.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues)?.value) return false;
 			}
 		}
 		currentNode = parentNode;
@@ -39082,24 +39301,93 @@ const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, s
 const isReaderWorkNode = (node, analysisFunctions, scopes) => {
 	if (isNodeOfType(node, "CallExpression")) {
 		if (isGlobalBooleanCall(node, scopes)) return false;
-		const invokedFunction = resolveExactLocalFunction(node.callee, scopes);
+		const invokedFunction = resolveSynchronouslyInvokedFunction(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 canStateWriteReachReaderWork = (writeInfo, readerEffect, stateSymbolId, scopes) => {
-	if (writeInfo.hasUnknownValue || stateSymbolId === null) return true;
-	for (const writtenValue of writeInfo.values) {
-		const stateValue = { value: writtenValue };
+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);
 		let didFindReachableWork = false;
-		visitSynchronousFunctionBodies(readerEffect.analysisFunctions, (child) => {
-			if (didFindReachableWork || !isReaderWorkNode(child, readerEffect.analysisFunctions, scopes)) return;
-			if (isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes)) didFindReachableWork = true;
+		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;
 		});
 		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",
@@ -39110,26 +39398,499 @@ const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
 	"keys",
 	"values"
 ]);
-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;
+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;
 		}
-		return isCleanupReturn(returnedValue, EMPTY_CLEANUP_NAME_SET, EMPTY_CLEANUP_NAME_SET, { allowOpaqueReturn: isExplicitReturnStatement });
+		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;
 	}
-	if (isNodeOfType(returnedValue, "Identifier")) return true;
+	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;
+		}
+	}
+	return true;
+};
+const hasProvenGlobalNamespaceReference = (expression, namespaceNames, scopes) => {
+	for (const namespaceName of namespaceNames) if (isProvenGlobalNamespaceReference(expression, namespaceName, scopes)) return true;
 	return false;
 };
-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);
+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;
 	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();
@@ -39161,23 +39922,16 @@ const callsOpaqueExternalSetter = (analysisFunctions, setterToStateName) => {
 	});
 	return didFindOpaqueSetterCall;
 };
-const isReactRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && (isReactApiCall(expression, "useRef", scopes, {
+const isReactUseRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && isReactApiCall(expression, "useRef", scopes, {
 	allowGlobalReactNamespace: true,
 	allowUnboundBareCalls: true,
 	resolveNamedAliases: true
-}) || isReactApiCall(expression, "createRef", scopes, {
+});
+const isReactRefCall = (expression, scopes) => isReactUseRefCall(expression, scopes) || isNodeOfType(expression, "CallExpression") && 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);
@@ -39185,19 +39939,33 @@ const isReactNativeJsxElement = (openingElement, scopes) => {
 	return Boolean(symbol?.kind === "import" && importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react-native");
 };
 const isDirectHostJsxRef = (symbol, scopes) => {
-	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;
+	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;
 };
 const isIntrinsicRefCallbackParameter = (expression, scopes) => {
 	const identifier = stripParenExpression(expression);
@@ -39207,7 +39975,18 @@ 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);
+	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;
+	}));
 };
 const getDirectReactRefCall = (symbol, scopes) => {
 	const initializer = getDirectUnreassignedInitializer(symbol);
@@ -39215,15 +39994,38 @@ 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 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;
+	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;
 	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);
@@ -39236,7 +40038,7 @@ const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
 		if (!storedValue || isNodeOfType(storedValue, "SpreadElement") || !isIntrinsicRefCallbackParameter(storedValue, scopes)) return false;
 		intrinsicValueWriteCount += 1;
 	}
-	return intrinsicValueWriteCount > 0;
+	return intrinsicValueWriteCount > 0 && (hasDirectEmptyMapInitializer || lazyEmptyMapInitializationCount === 1);
 };
 const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollectionValue = false, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(rawExpression);
@@ -39250,7 +40052,11 @@ const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollecti
 	}
 	if (isNodeOfType(expression, "MemberExpression")) {
 		if (getStaticPropertyName(expression) === "current") {
-			const symbol = getDirectReactRefSymbol(expression.object, scopes);
+			const symbol = resolveReactRefSymbol(expression, scopes, {
+				allowUnboundBareCalls: true,
+				includeCreateRef: true,
+				resolveNamedAliases: true
+			});
 			return Boolean(symbol && (isDirectHostJsxRef(symbol, scopes) || didReadCollectionValue && storesOnlyIntrinsicRefCallbackValues(symbol, scopes)));
 		}
 		return isDerivedFromProvenDomRefCurrent(expression.object, scopes, didReadCollectionValue, visitedSymbolIds);
@@ -39268,19 +40074,80 @@ 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 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";
+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
+		}));
+	}
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	if (isNodeOfType(node.callee, "Identifier")) return EXTERNAL_SYNC_DIRECT_CALLEE_NAMES.has(node.callee.name);
+	if (isProvenExternalSyncDirectCallee(node.callee, scopes)) return true;
 	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
 	const propertyName = getStaticPropertyName(node.callee);
 	if (propertyName === null) return false;
-	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);
+	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);
 };
 const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, setterSymbolIdToStateName, scopes, allowCommittedDomSync) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
@@ -39289,7 +40156,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) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
+		if (isExternalSyncNode(child, scopes) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
 	});
 	return didFindExternalCall;
 };
@@ -39311,11 +40178,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);
@@ -39328,10 +40195,11 @@ 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(analysisFunctions, setterSymbolIdToStateName, context.scopes);
+				const stateWrites = collectStateWritesInEffect(collectStateWriteAnalysisFunctions(callback, context.scopes, setterSymbolIdToStateName), setterSymbolIdToStateName, context.scopes);
 				const writtenStateNames = new Set(stateWrites.keys());
 				effectInfos.push({
 					node: effectCall,
+					callback,
 					dependencyStateSymbolIds: collectDependencyStateSymbolIds(effectCall, stateSymbolIdSet, context.scopes),
 					stateWrites,
 					analysisFunctions,
@@ -39348,10 +40216,10 @@ const noEffectChain = defineRule({
 					if (readerEffect.isExternalSync) continue;
 					if (readerEffect.dependencyStateSymbolIds.size === 0) continue;
 					let chainedStateName = null;
-					for (const [writtenName, writeInfo] of writerEffect.stateWrites) {
+					for (const writtenName of writerEffect.stateWrites.keys()) {
 						const writtenStateSymbolId = stateSymbolIds.get(writtenName);
 						if (writtenStateSymbolId === void 0 || !readerEffect.dependencyStateSymbolIds.has(writtenStateSymbolId)) continue;
-						if (!canStateWriteReachReaderWork(writeInfo, readerEffect, stateSymbolIds.get(writtenName) ?? null, context.scopes)) continue;
+						if (!canStateWriteReachReaderWork(writtenName, writerEffect, readerEffect, stateSymbolIds, context.scopes)) continue;
 						chainedStateName = writtenName;
 						break;
 					}
@@ -44136,16 +45004,6 @@ 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,
@@ -46535,6 +47393,103 @@ const EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1 = new Set([
 	"useVisibility",
 	"useWindowSize"
 ]);
+const EXTERNAL_SUBSCRIPTION_PRIMITIVE_RESULT_HOOK_NAMES = new Set([
+	"useMatchMedia",
+	"useMediaQuery",
+	"useVisibility"
+]);
+const isImportBindingRef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "ImportBinding"));
+const getImportedExternalSubscriptionHookName = (analysis, rawCallee) => {
+	const callee = stripParenExpression(rawCallee);
+	if (isNodeOfType(callee, "Identifier")) {
+		const calleeRef = getRef(analysis, callee);
+		if (!calleeRef || !isImportBindingRef(calleeRef)) return null;
+		const importBinding = getImportBindingForName(callee, callee.name);
+		if (!importBinding || importBinding.isNamespace) return null;
+		if (importBinding.exportedName && EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(importBinding.exportedName)) return importBinding.exportedName;
+		return importBinding.exportedName === "default" && EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(callee.name) ? callee.name : null;
+	}
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	const hookName = getStaticMemberPropertyName(callee);
+	const namespaceIdentifier = stripParenExpression(callee.object);
+	if (!hookName || !EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(hookName) || !isNodeOfType(namespaceIdentifier, "Identifier")) return null;
+	const namespaceRef = getRef(analysis, namespaceIdentifier);
+	if (!namespaceRef || !isImportBindingRef(namespaceRef)) return null;
+	return getImportBindingForName(namespaceIdentifier, namespaceIdentifier.name)?.isNamespace ? hookName : null;
+};
+const isSafeExternalSubscriptionResultBinding = (bindingIdentifier, bindingPattern) => {
+	let current = bindingIdentifier;
+	let didCrossDestructuringBoundary = false;
+	while (current !== bindingPattern) {
+		const parent = current.parent;
+		if (!parent || isNodeOfType(parent, "AssignmentPattern") || isNodeOfType(parent, "RestElement")) return false;
+		if (isNodeOfType(parent, "Property")) {
+			if (parent.value !== current) return false;
+			didCrossDestructuringBoundary = true;
+		}
+		if (isNodeOfType(parent, "ArrayPattern")) didCrossDestructuringBoundary = true;
+		current = parent;
+	}
+	return didCrossDestructuringBoundary;
+};
+const getVariablesDefinedByDeclarator = (analysis, declarator) => analysis.scopeManager.scopes.flatMap((scope) => scope.variables).filter((variable) => variable.defs.some((definition) => definition.node === declarator));
+const hasUnsafeExternalSubscriptionBindingUse = (analysis, variable, visitedVariables = /* @__PURE__ */ new Set()) => {
+	if (visitedVariables.has(variable)) return false;
+	visitedVariables.add(variable);
+	return variable.references.some((candidateReference) => {
+		if (candidateReference.init) return false;
+		if (candidateReference.isWrite()) return true;
+		let usageRoot = findTransparentExpressionRoot(candidateReference.identifier);
+		while (isNodeOfType(usageRoot.parent, "MemberExpression") && usageRoot.parent.object === usageRoot) usageRoot = findTransparentExpressionRoot(usageRoot.parent);
+		const usageParent = usageRoot.parent;
+		if (isNodeOfType(usageParent, "AssignmentExpression") && usageParent.left === usageRoot || isNodeOfType(usageParent, "UpdateExpression") && usageParent.argument === usageRoot || isNodeOfType(usageParent, "UnaryExpression") && usageParent.operator === "delete" && usageParent.argument === usageRoot) return true;
+		let usageAncestor = usageRoot.parent;
+		while (usageAncestor && !isNodeOfType(usageAncestor, "VariableDeclarator") && !isFunctionLike$1(usageAncestor) && !isNodeOfType(usageAncestor, "Program")) usageAncestor = usageAncestor.parent;
+		if (isNodeOfType(usageAncestor, "VariableDeclarator") && usageAncestor.init) {
+			const aliasVariables = getVariablesDefinedByDeclarator(analysis, usageAncestor);
+			return aliasVariables.length === 0 || aliasVariables.some((aliasVariable) => hasUnsafeExternalSubscriptionBindingUse(analysis, aliasVariable, visitedVariables));
+		}
+		return false;
+	});
+};
+const hasOnlySafeExternalSubscriptionResultBindings = (analysis, declarator, variables = getVariablesDefinedByDeclarator(analysis, declarator)) => {
+	return variables.length > 0 && variables.every((variable) => {
+		const bindingIdentifier = variable.defs.find((candidateDefinition) => candidateDefinition.node === declarator)?.name;
+		return Boolean(bindingIdentifier && isNodeOfType(bindingIdentifier, "Identifier") && isSafeExternalSubscriptionResultBinding(bindingIdentifier, declarator.id) && !hasUnsafeExternalSubscriptionBindingUse(analysis, variable));
+	});
+};
+const hasImmutableExternalSubscriptionCallResult = (analysis, rawCallee, relatedRefs, allowWholeResult) => {
+	const callee = stripParenExpression(rawCallee);
+	const callExpression = callee.parent;
+	if (!callExpression || !isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== callee) return false;
+	const initializer = findTransparentExpressionRoot(callExpression);
+	const declarator = initializer.parent;
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== initializer || !isNodeOfType(declarator.parent, "VariableDeclaration") || declarator.parent.kind !== "const") return false;
+	const relatedVariables = getVariablesDefinedByDeclarator(analysis, declarator).filter((variable) => relatedRefs.some((relatedRef) => relatedRef.resolved === variable));
+	if (relatedVariables.length === 0) return false;
+	return isNodeOfType(declarator.id, "Identifier") ? allowWholeResult && relatedVariables.every((variable) => !hasUnsafeExternalSubscriptionBindingUse(analysis, variable)) : hasOnlySafeExternalSubscriptionResultBindings(analysis, declarator, relatedVariables);
+};
+const isImmutableImportedExternalSubscriptionHookCallee = (analysis, rawCallee, relatedRefs) => {
+	const hookName = getImportedExternalSubscriptionHookName(analysis, rawCallee);
+	return Boolean(hookName && hasImmutableExternalSubscriptionCallResult(analysis, rawCallee, relatedRefs, EXTERNAL_SUBSCRIPTION_PRIMITIVE_RESULT_HOOK_NAMES.has(hookName)));
+};
+const isExternalSubscriptionHookResultRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
+	const declarator = def.node;
+	if (!isNodeOfType(declarator, "VariableDeclarator") || !declarator.init || !isNodeOfType(declarator.parent, "VariableDeclaration") || declarator.parent.kind !== "const") return false;
+	const initializer = stripParenExpression(declarator.init);
+	if (!isNodeOfType(initializer, "CallExpression")) return false;
+	const hookName = getImportedExternalSubscriptionHookName(analysis, initializer.callee);
+	if (!hookName) return false;
+	if (isNodeOfType(declarator.id, "Identifier")) return EXTERNAL_SUBSCRIPTION_PRIMITIVE_RESULT_HOOK_NAMES.has(hookName) && ref.resolved && !hasUnsafeExternalSubscriptionBindingUse(analysis, ref.resolved);
+	const bindingIdentifier = def.name;
+	return isNodeOfType(bindingIdentifier, "Identifier") && isSafeExternalSubscriptionResultBinding(bindingIdentifier, declarator.id) && ref.resolved && !hasUnsafeExternalSubscriptionBindingUse(analysis, ref.resolved);
+}));
+const isExternalSubscriptionHookResultArgument = (analysis, argument) => {
+	const unwrappedArgument = stripParenExpression(argument);
+	if (!isNodeOfType(unwrappedArgument, "Identifier")) return false;
+	const argumentRef = getRef(analysis, unwrappedArgument);
+	return Boolean(argumentRef && isExternalSubscriptionHookResultRef(analysis, argumentRef));
+};
 const isCallbackPropReference = (analysis, ref) => {
 	if (!isProp(analysis, ref)) return false;
 	const identifier = ref.identifier;
@@ -46567,8 +47522,9 @@ const isParentWiredHookCalleeRef = (analysis, ref) => {
 	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier) return false;
 	return (parent.arguments ?? []).some((hookArgument) => getDownstreamRefs(analysis, hookArgument).some((downstreamRef) => isCallbackPropReference(analysis, downstreamRef)));
 };
-const getLocalHookExternalStateProof = (analysis, ref) => {
+const getLocalHookExternalStateProof = (analysis, ref, scopes) => {
 	let hookFunction = resolveToFunction(ref);
+	let didResolveThroughResultBinding = false;
 	if (!hookFunction) for (const definition of ref.resolved?.defs ?? []) {
 		const definitionNode = definition.node;
 		if (!isNodeOfType(definitionNode, "VariableDeclarator") || !definitionNode.init) continue;
@@ -46579,29 +47535,27 @@ const getLocalHookExternalStateProof = (analysis, ref) => {
 		const calleeReference = getRef(analysis, callee);
 		if (!calleeReference) continue;
 		hookFunction = resolveToFunction(calleeReference);
-		if (hookFunction) break;
+		if (hookFunction) {
+			didResolveThroughResultBinding = true;
+			break;
+		}
 	}
 	if (!hookFunction) return null;
-	const returnedReferences = collectFunctionReturnStatements(hookFunction).flatMap((returnStatement) => returnStatement.argument ? getDownstreamRefs(analysis, returnStatement.argument) : []);
+	if (didResolveThroughResultBinding && (!ref.resolved || hasUnsafeExternalSubscriptionBindingUse(analysis, ref.resolved))) return false;
+	if (isNodeOfType(hookFunction, "ArrowFunctionExpression") && !isNodeOfType(hookFunction.body, "BlockStatement") && isReactHookCall(stripParenExpression(hookFunction.body), "useSyncExternalStore", scopes)) return true;
+	const returnStatements = collectFunctionReturnStatements(hookFunction);
+	if (returnStatements.length > 0 && returnStatements.every((returnStatement) => returnStatement.argument && isReactHookCall(stripParenExpression(returnStatement.argument), "useSyncExternalStore", scopes))) return true;
+	const returnedReferences = returnStatements.flatMap((returnStatement) => returnStatement.argument ? getDownstreamRefs(analysis, returnStatement.argument) : []);
 	if (returnedReferences.length === 0) return null;
 	return returnedReferences.every((returnedReference) => isState(analysis, returnedReference) && isExternallyDrivenState(analysis, returnedReference));
 };
-const isExternalSubscriptionHookRef = (analysis, ref) => {
-	const identifier = ref.identifier;
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const localHookProof = getLocalHookExternalStateProof(analysis, ref);
-	if (localHookProof !== null) return localHookProof;
-	if (EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(identifier.name) && isCalleePosition(identifier)) return true;
-	return Boolean(ref.resolved?.defs.some((def) => {
-		const node = def.node;
-		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-		const initializer = stripParenExpression(node.init);
-		if (!isNodeOfType(initializer, "CallExpression")) return false;
-		const callee = stripParenExpression(initializer.callee);
-		return isNodeOfType(callee, "Identifier") && EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(callee.name);
-	}));
+const isImmutableLocalExternalStoreHookCallee = (analysis, rawCallee, relatedRefs, scopes) => {
+	const callee = stripParenExpression(rawCallee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const calleeReference = getRef(analysis, callee);
+	if (!calleeReference || getLocalHookExternalStateProof(analysis, calleeReference, scopes) !== true) return false;
+	return hasImmutableExternalSubscriptionCallResult(analysis, callee, relatedRefs, true);
 };
-const isImportBindingRef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "ImportBinding"));
 const isCalleePosition = (identifier) => {
 	const parent = identifier.parent;
 	return Boolean(parent && (isNodeOfType(parent, "CallExpression") || isNodeOfType(parent, "NewExpression")) && parent.callee === identifier);
@@ -46662,25 +47616,35 @@ const noPassDataToParent = defineRule({
 						return getFunctionalUpdaterDataRefs(analysis, argument);
 					}
 					if (isHandlerBagArgument(analysis, argument)) return [];
+					if (isExternalSubscriptionHookResultArgument(analysis, argument)) return [];
 					if (isParentWiredHookResultArgument(analysis, argument)) return [];
 					if (isNodeOfType(argument, "Identifier")) {
 						const argumentRef = getRef(analysis, argument);
 						if (argumentRef && resolveToFunction(argumentRef)) return [];
 					}
 					return getDownstreamRefs(analysis, argument);
-				}).flatMap((argumentRef) => isExternallyDrivenState(analysis, argumentRef) || isExternalSubscriptionHookRef(analysis, argumentRef) ? [] : getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
-				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref, context.scopes)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
+				}).flatMap((argumentRef) => {
+					if (isExternallyDrivenState(analysis, argumentRef) || getLocalHookExternalStateProof(analysis, argumentRef, context.scopes) === true) return [];
+					const upstreamRefs = getUpstreamRefs(analysis, argumentRef);
+					return upstreamRefs.filter((upstreamRef) => {
+						if (!isLeafRef(upstreamRef)) return false;
+						return !isImmutableImportedExternalSubscriptionHookCallee(analysis, upstreamRef.identifier, upstreamRefs) && !isImmutableLocalExternalStoreHookCallee(analysis, upstreamRef.identifier, upstreamRefs, context.scopes);
+					});
+				});
+				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref, context.scopes)) {
+					const wrapperUpstreamRefs = getArgsUpstreamRefs(analysis, ref);
+					argsUpstreamRefs.push(...wrapperUpstreamRefs.filter((upstreamRef) => isLeafRef(upstreamRef) && !isImmutableImportedExternalSubscriptionHookCallee(analysis, upstreamRef.identifier, wrapperUpstreamRefs) && !isImmutableLocalExternalStoreHookCallee(analysis, upstreamRef.identifier, wrapperUpstreamRefs, context.scopes)));
+				}
 				if (!argsUpstreamRefs.some((argRef) => {
-					if (isUseStateIdentifier(argRef.identifier)) return false;
-					if (isExternalSubscriptionHookRef(analysis, argRef)) return false;
+					const argIdentifier = argRef.identifier;
+					if (isUseStateIdentifier(argIdentifier)) return false;
 					if (isProp(analysis, argRef)) return false;
-					if (isUseRefIdentifier(argRef.identifier)) return false;
+					if (isUseRefIdentifier(argIdentifier)) return false;
 					if (isRefCurrent(argRef)) return false;
 					if (isConstant(argRef)) return false;
 					if (isParentWiredHookResultRef(analysis, argRef)) return false;
 					if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
 					if (resolveToFunction(argRef)) return false;
-					const argIdentifier = argRef.identifier;
 					if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
 					if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
 					return true;
@@ -55671,17 +56635,6 @@ 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) => {
@@ -60389,6 +61342,717 @@ 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;
@@ -60510,7 +62174,8 @@ const rerenderStateOnlyInHandlers = defineRule({
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
 			const bindings = collectUseStateBindings(componentBody, context.scopes);
 			if (bindings.length === 0) return;
-			if (collectRenderReachableExpressions(componentBody).length === 0) return;
+			const renderReachableExpressions = collectRenderReachableExpressions(componentBody);
+			if (renderReachableExpressions.length === 0) return;
 			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody, context.scopes);
 			const dependencyGraph = buildLocalDependencyGraph(componentBody, eventHandlerReferenceNames);
 			const directRenderNames = collectRenderReachableNames(componentBody, context.scopes, eventHandlerReferenceNames);
@@ -60524,12 +62189,22 @@ 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;