oxlint-plugin-react-doctor 0.8.1-dev.fe241a9 → 0.8.1

package/dist/index.js

@@ -762,7 +762,7 @@ const EXTERNAL_SYNC_MEMBER_METHOD_NAMES = new Set([
 	"put",
 	"patch"
 ]);
-new Set([
+const EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS = new Set([
 	...FETCH_MEMBER_OBJECTS,
 	"api",
 	"client",
@@ -9008,16 +9008,6 @@ const hasVisibleBindingNamed = (node, bindingName, scopes) => {
 	}
 };
 //#endregion
-//#region src/plugin/utils/is-global-match-media-call.ts
-const isGlobalMatchMediaCall = (node, scopes) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (isNodeOfType(callee, "Identifier")) return callee.name === "matchMedia" && scopes.isGlobalReference(callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "matchMedia") return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && (receiver.name === "window" || receiver.name === "globalThis") && scopes.isGlobalReference(receiver);
-};
-//#endregion
 //#region src/plugin/utils/is-proven-browser-api-receiver.ts
 const DOM_EVENT_TARGET_TYPE_NAMES = new Set([
 	"AbortSignal",
@@ -9164,10 +9154,8 @@ const getProvenDomEventTargetPrototypeOwnerNames = (rawExpression, scopes, visit
 		if (memberName === "body" || memberName === "documentElement") return getDomPrototypeOwnerNamesForType("HTMLElement");
 	}
 	if (isNodeOfType(expression, "CallExpression")) {
-		if (isGlobalMatchMediaCall(expression, scopes)) return getDomPrototypeOwnerNamesForType("MediaQueryList");
 		const callee = stripParenExpression(expression.callee);
 		const methodName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : null;
-		if (methodName === "matchMedia" && isNodeOfType(callee, "MemberExpression") && getProvenDomEventTargetPrototypeOwnerNames(callee.object, scopes, visitedSymbolIds).includes("Window")) return getDomPrototypeOwnerNamesForType("MediaQueryList");
 		if (methodName === "createElement") return getDomPrototypeOwnerNamesForType("HTMLElement");
 		if (methodName === "createElementNS") return getDomPrototypeOwnerNamesForType("SVGElement");
 		if (methodName && DOM_EVENT_TARGET_FACTORY_METHOD_NAMES.has(methodName)) return getDomPrototypeOwnerNamesForType("Element");
@@ -13864,19 +13852,14 @@ const isAstDescendant = (inner, outer) => {
 };
 //#endregion
 //#region src/plugin/utils/react-ref-origin.ts
-const REACT_REF_API_NAMES = new Set(["createRef", "useRef"]);
-const resolveReactRefSymbol = (memberExpression, scopes, options = {}) => {
+const resolveReactRefSymbol = (memberExpression, scopes) => {
 	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
 	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticPropertyName(memberExpression) !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
 	const symbol = resolveConstIdentifierAlias(receiver, scopes);
 	if (!symbol?.initializer) return null;
 	const initializer = stripParenExpression(symbol.initializer);
 	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, options.includeCreateRef ? REACT_REF_API_NAMES : "useRef", scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: options.allowUnboundBareCalls,
-		resolveNamedAliases: options.resolveNamedAliases
-	}) ? symbol : null;
+	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
 };
 const resolveReactRefCurrentOriginSymbol = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(node);
@@ -13978,18 +13961,6 @@ const isNodeReachableWithinFunction = (node, context) => {
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
 const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
 const REPLAYABLE_ITERATOR_COLLECTION_CACHE = /* @__PURE__ */ new WeakMap();
-const REPLAY_ENTRY_DROPPING_ARRAY_METHOD_NAMES = new Set([
-	"pop",
-	"shift",
-	"splice",
-	"fill",
-	"copyWithin"
-]);
-const REPLAY_ENTRY_DROPPING_COLLECTION_METHOD_NAMES = new Set([
-	"clear",
-	"delete",
-	"set"
-]);
 const REACT_REF_EFFECT_ANALYSIS_CACHE = /* @__PURE__ */ new WeakMap();
 const RESOURCE_NOUN_BY_KIND = {
 	subscribe: "subscription",
@@ -14030,92 +14001,6 @@ const resolveExpressionKey = (expression, context, visitedSymbolIds = /* @__PURE
 	}
 	return null;
 };
-const resolveForEachProjection = (expression, context) => {
-	if (!expression) return null;
-	let currentExpression = stripParenExpression(expression);
-	const memberNames = [];
-	while (isNodeOfType(currentExpression, "MemberExpression") && !currentExpression.computed) {
-		if (!isNodeOfType(currentExpression.property, "Identifier")) return null;
-		memberNames.unshift(currentExpression.property.name);
-		currentExpression = stripParenExpression(currentExpression.object);
-	}
-	if (!isNodeOfType(currentExpression, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(currentExpression);
-	if (!symbol || symbol.kind !== "parameter") return null;
-	let callbackNode = symbol.bindingIdentifier.parent;
-	while (callbackNode && !isFunctionLike$1(callbackNode)) callbackNode = callbackNode.parent;
-	if (!callbackNode || !isFunctionLike$1(callbackNode)) return null;
-	const forEachCall = findEnclosingForEachCall(callbackNode);
-	if (!forEachCall) return null;
-	const forEachCallee = stripParenExpression(forEachCall.callee);
-	if (!isNodeOfType(forEachCallee, "MemberExpression")) return null;
-	const collectionKey = resolveExpressionKey(forEachCallee.object, context);
-	if (!collectionKey) return null;
-	const firstParameter = callbackNode.params[0];
-	const bindingProperty = symbol.bindingIdentifier.parent;
-	const propertyName = isNodeOfType(firstParameter, "ObjectPattern") && isNodeOfType(bindingProperty, "Property") && bindingProperty.parent === firstParameter && bindingProperty.value === symbol.bindingIdentifier ? getStaticPropertyKeyName(bindingProperty) : null;
-	const parameterProjection = firstParameter === symbol.bindingIdentifier ? "value" : propertyName;
-	if (!parameterProjection) return null;
-	return {
-		collectionKey,
-		projectionKey: [parameterProjection, ...memberNames].join(".")
-	};
-};
-const resolveForEachProjectionKey = (expression, context) => {
-	const projection = resolveForEachProjection(expression, context);
-	return projection ? `forEach:${projection.collectionKey}:${projection.projectionKey}` : null;
-};
-const resolveResourceIdentityKey = (expression, context) => resolveForEachProjectionKey(expression, context) ?? resolveExpressionKey(expression, context);
-const resolveEventListenerCaptureIdentityKey = (optionsNode, context, allowOpaqueOptionsIdentity) => {
-	const capture = resolveEventListenerCapture(optionsNode, { allowIndeterminateEntries: true });
-	if (capture !== null) return `capture:${String(capture)}`;
-	if (!optionsNode) return null;
-	const unwrappedOptions = stripParenExpression(optionsNode);
-	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) {
-		const optionsKey = allowOpaqueOptionsIdentity ? resolveResourceIdentityKey(unwrappedOptions, context) : null;
-		return optionsKey ? `options:${optionsKey}` : null;
-	}
-	let captureKey = "capture:false";
-	for (const property of unwrappedOptions.properties ?? []) {
-		if (!isNodeOfType(property, "Property")) {
-			captureKey = null;
-			continue;
-		}
-		const propertyName = getStaticPropertyKeyName(property);
-		if (propertyName === null || !property.computed && propertyName === "__proto__") {
-			captureKey = null;
-			continue;
-		}
-		if (propertyName === "capture") {
-			const propertyValueKey = resolveResourceIdentityKey(property.value, context);
-			captureKey = propertyValueKey ? `capture-value:${propertyValueKey}` : null;
-		}
-	}
-	return captureKey;
-};
-const resolveEventListenerCaptureProjection = (optionsNode, context) => {
-	if (!optionsNode) return null;
-	const unwrappedOptions = stripParenExpression(optionsNode);
-	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) return resolveForEachProjection(unwrappedOptions, context);
-	let captureProjection = null;
-	for (const property of unwrappedOptions.properties ?? []) {
-		if (!isNodeOfType(property, "Property")) {
-			captureProjection = null;
-			continue;
-		}
-		const propertyName = getStaticPropertyKeyName(property);
-		if (propertyName === null || !property.computed && propertyName === "__proto__") {
-			captureProjection = null;
-			continue;
-		}
-		if (propertyName === "capture") captureProjection = resolveForEachProjection(property.value, context);
-	}
-	return captureProjection;
-};
-const doEventListenerCapturesMatch = (registrationOptions, releaseOptions, context, allowOpaqueOptionsIdentity = false) => {
-	const registrationCaptureKey = resolveEventListenerCaptureIdentityKey(registrationOptions, context, allowOpaqueOptionsIdentity);
-	return registrationCaptureKey !== null && registrationCaptureKey === resolveEventListenerCaptureIdentityKey(releaseOptions, context, allowOpaqueOptionsIdentity);
-};
 const findAssignedResourceKey = (resourceNode, context) => {
 	let currentNode = resourceNode;
 	let parentNode = currentNode.parent;
@@ -14127,30 +14012,6 @@ const findAssignedResourceKey = (resourceNode, context) => {
 	if (isNodeOfType(parentNode, "AssignmentExpression") && parentNode.right === currentNode) return resolveExpressionKey(parentNode.left, context);
 	return null;
 };
-const resolveStableMediaQueryListenerIdentityKey = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const symbol = context.scopes.symbolFor(unwrappedExpression);
-		if (!symbol || visitedSymbolIds.has(symbol.id) || !symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier))) return null;
-		const initializer = getDirectUnreassignedInitializer(symbol);
-		if (!initializer) return `symbol:${symbol.id}`;
-		const unwrappedInitializer = stripParenExpression(initializer);
-		if (!isNodeOfType(unwrappedInitializer, "Identifier")) return `symbol:${symbol.id}`;
-		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-		nextVisitedSymbolIds.add(symbol.id);
-		return resolveStableMediaQueryListenerIdentityKey(unwrappedInitializer, context, nextVisitedSymbolIds) ?? `symbol:${symbol.id}`;
-	}
-	if (isFunctionLike$1(unwrappedExpression)) {
-		const rangeStart = getRangeStart(unwrappedExpression);
-		return rangeStart === null ? null : `function:${rangeStart}`;
-	}
-	return null;
-};
-const isProvenLegacyMediaQueryListMethodCall = (callNode, methodName, context) => {
-	const callee = stripParenExpression(callNode.callee);
-	return callNode.arguments?.length === 1 && isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName && getProvenDomEventTargetPrototypeOwnerNames(callee.object, context.scopes).includes("MediaQueryList");
-};
 const getCallRegistrationDetails = (callNode, context) => {
 	const callee = stripParenExpression(callNode.callee);
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return {
@@ -14159,17 +14020,11 @@ const getCallRegistrationDetails = (callNode, context) => {
 		eventKey: null,
 		handlerKey: null
 	};
-	if (isProvenLegacyMediaQueryListMethodCall(callNode, "addListener", context)) return {
-		receiverKey: resolveStableMediaQueryListenerIdentityKey(callee.object, context),
-		registrationVerbName: callee.property.name,
-		eventKey: null,
-		handlerKey: resolveStableMediaQueryListenerIdentityKey(callNode.arguments?.[0], context)
-	};
 	return {
-		receiverKey: resolveResourceIdentityKey(callee.object, context),
+		receiverKey: resolveExpressionKey(callee.object, context),
 		registrationVerbName: callee.property.name,
-		eventKey: resolveResourceIdentityKey(callNode.arguments?.[0], context),
-		handlerKey: resolveResourceIdentityKey(callNode.arguments?.[1], context)
+		eventKey: resolveExpressionKey(callNode.arguments?.[0], context),
+		handlerKey: resolveExpressionKey(callNode.arguments?.[1], context)
 	};
 };
 const findSubscribeLikeUsages = (callback, context) => {
@@ -14594,8 +14449,8 @@ const isSynchronousIteratorCallback = (functionNode) => {
 	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$2.has(callee.property.name) && callNode.arguments?.[0] === functionNode;
 };
 const findEnclosingForEachCall = (node) => {
-	const callbackNode = isFunctionLike$1(node) ? node : findEnclosingFunction$1(node);
-	if (!callbackNode || !isFunctionLike$1(callbackNode) || callbackNode.async || callbackNode.generator) return null;
+	const callbackNode = findEnclosingFunction$1(node);
+	if (!callbackNode) return null;
 	const callNode = callbackNode.parent;
 	if (!isNodeOfType(callNode, "CallExpression") || callNode.arguments?.[0] !== callbackNode) return null;
 	const callee = stripParenExpression(callNode.callee);
@@ -15244,7 +15099,9 @@ const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
 	const nodeParameterKey = resolveExpressionKey(usageFunction.params?.[0], context);
 	const releaseReceiverKey = resolveExpressionKey(releaseCallee.object, context);
 	if (registrationReceiverKey === null || registrationReceiverKey !== nodeParameterKey || releaseReceiverKey === null || usage.eventKey === null || usage.eventKey !== resolveExpressionKey(releaseCall.arguments?.[0], context) || usage.handlerKey === null || usage.handlerKey !== resolveExpressionKey(releaseCall.arguments?.[1], context)) return false;
-	if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], releaseCall.arguments?.[2], context)) return false;
+	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
+	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
+	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
 	const releaseStart = getRangeStart(releaseCall);
 	const matchingOwnershipAssignments = [];
 	const usageFunctionBody = usageFunction.body;
@@ -15256,126 +15113,6 @@ const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
 	const safeOwnershipAssignments = matchingOwnershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, [releaseAnchor], usageFunction, context));
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
 };
-const findDirectExhaustiveForEachCleanupFunction = (releaseNode, requiredCollectionKeys, context) => {
-	let currentNode = findTransparentExpressionRoot(releaseNode);
-	const visitedFunctions = /* @__PURE__ */ new Set();
-	const replayedCollectionKeys = /* @__PURE__ */ new Set();
-	while (true) {
-		const ownerFunction = findEnclosingFunction$1(currentNode);
-		if (!ownerFunction || !isFunctionLike$1(ownerFunction) || visitedFunctions.has(ownerFunction)) return null;
-		visitedFunctions.add(ownerFunction);
-		const isDirectConciseBody = ownerFunction.body === currentNode;
-		const statementNode = currentNode.parent;
-		const isDirectBlockStatement = isNodeOfType(ownerFunction.body, "BlockStatement") && isNodeOfType(statementNode, "ExpressionStatement") && statementNode.parent === ownerFunction.body;
-		if (!isDirectConciseBody && !isDirectBlockStatement || !doMatchingNodesCoverEveryPathFromFunctionEntry(ownerFunction, [isDirectBlockStatement ? statementNode : currentNode], context)) return null;
-		const forEachCall = findEnclosingForEachCall(ownerFunction);
-		if (!forEachCall) return replayedCollectionKeys.size === requiredCollectionKeys.size && isReturnedEffectCleanupFunction(ownerFunction, context) ? ownerFunction : null;
-		const forEachCallee = stripParenExpression(forEachCall.callee);
-		if (!isNodeOfType(forEachCallee, "MemberExpression")) return null;
-		const collectionKey = resolveExpressionKey(forEachCallee.object, context);
-		if (!collectionKey || !requiredCollectionKeys.has(collectionKey)) return null;
-		replayedCollectionKeys.add(collectionKey);
-		currentNode = findTransparentExpressionRoot(forEachCall);
-	}
-};
-const collectReplayOwnerFunctions = (usageNode) => {
-	const ownerFunctions = /* @__PURE__ */ new Set();
-	let currentNode = usageNode;
-	while (true) {
-		const ownerFunction = findEnclosingFunction$1(currentNode);
-		if (!ownerFunction || !isFunctionLike$1(ownerFunction) || ownerFunctions.has(ownerFunction)) break;
-		ownerFunctions.add(ownerFunction);
-		const forEachCall = findEnclosingForEachCall(ownerFunction);
-		if (!forEachCall) break;
-		currentNode = forEachCall;
-	}
-	return ownerFunctions;
-};
-const hasCollectionMutationBeforeRelease = (usageNode, releaseNode, collectionKeys, context) => {
-	const usageStart = getRangeStart(usageNode);
-	const releaseStart = getRangeStart(releaseNode);
-	if (usageStart === null || releaseStart === null) return true;
-	const setupOwnerFunctions = collectReplayOwnerFunctions(usageNode);
-	const cleanupOwnerFunctions = collectReplayOwnerFunctions(releaseNode);
-	let programNode = usageNode;
-	while (programNode.parent) programNode = programNode.parent;
-	let didFindMutation = false;
-	walkAst(programNode, (child) => {
-		if (didFindMutation) return false;
-		const childStart = getRangeStart(child);
-		if (childStart === null) return;
-		const ownerFunction = context.cfg.enclosingFunction(child);
-		if (!ownerFunction) return;
-		const isAfterRegistration = setupOwnerFunctions.has(ownerFunction) && childStart > usageStart;
-		const isBeforeRelease = cleanupOwnerFunctions.has(ownerFunction) && childStart < releaseStart;
-		if (!isAfterRegistration && !isBeforeRelease) return;
-		if (isNodeOfType(child, "AssignmentExpression")) {
-			const assignmentKey = resolveExpressionKey(child.left, context);
-			const assignmentTarget = stripParenExpression(child.left);
-			if (assignmentKey && [...collectionKeys].some((collectionKey) => assignmentKey === collectionKey || assignmentKey === `${collectionKey}.length`) || isNodeOfType(assignmentTarget, "MemberExpression") && assignmentTarget.computed && collectionKeys.has(resolveExpressionKey(assignmentTarget.object, context) ?? "")) {
-				didFindMutation = true;
-				return false;
-			}
-			return;
-		}
-		if (isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
-			const deletedMember = stripParenExpression(child.argument);
-			if (!isNodeOfType(deletedMember, "MemberExpression")) return;
-			if (collectionKeys.has(resolveExpressionKey(deletedMember.object, context) ?? "")) {
-				didFindMutation = true;
-				return false;
-			}
-			return;
-		}
-		if (isNodeOfType(child, "UpdateExpression")) {
-			const updatedKey = resolveExpressionKey(child.argument, context);
-			if (updatedKey && [...collectionKeys].some((collectionKey) => updatedKey === `${collectionKey}.length`)) {
-				didFindMutation = true;
-				return false;
-			}
-			return;
-		}
-		if (!isNodeOfType(child, "CallExpression")) return;
-		const callee = stripParenExpression(child.callee);
-		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || !REPLAY_ENTRY_DROPPING_ARRAY_METHOD_NAMES.has(callee.property.name) && !REPLAY_ENTRY_DROPPING_COLLECTION_METHOD_NAMES.has(callee.property.name) || !collectionKeys.has(resolveExpressionKey(callee.object, context) ?? "")) return;
-		didFindMutation = true;
-		return false;
-	});
-	return didFindMutation;
-};
-const usesUnaryListenerSignature = (registrationCall, releaseCall) => getCalleeName$1(registrationCall) === "addListener" && registrationCall.arguments?.length === 1 && releaseCall.arguments?.length === 1;
-const hasSafeForEachProjectionCleanup = (registrationCall, releaseCall, context) => {
-	const registrationCallee = stripParenExpression(registrationCall.callee);
-	const releaseCallee = stripParenExpression(releaseCall.callee);
-	if (!isNodeOfType(registrationCallee, "MemberExpression") || !isNodeOfType(releaseCallee, "MemberExpression")) return true;
-	const registrationVerbName = getCalleeName$1(registrationCall);
-	const releaseVerbName = getCalleeName$1(releaseCall);
-	const releaseHandler = releaseCall.arguments?.[usesUnaryListenerSignature(registrationCall, releaseCall) ? 0 : 1];
-	const releaseFunction = findEnclosingFunction$1(releaseCall);
-	const registrationEventKey = resolveResourceIdentityKey(registrationCall.arguments?.[0], context);
-	const releaseEventKey = resolveResourceIdentityKey(releaseCall.arguments?.[0], context);
-	const doesHandlerlessOffReleaseEveryRegistration = releaseVerbName === "off" && !releaseHandler && (releaseCall.arguments?.length === 0 || registrationEventKey !== null && registrationEventKey === releaseEventKey);
-	if (Boolean(releaseFunction && isFunctionLike$1(releaseFunction) && isReturnedEffectCleanupFunction(releaseFunction, context) && doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseCall], context)) && (releaseVerbName !== null && UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName) || doesHandlerlessOffReleaseEveryRegistration)) return true;
-	const projections = [
-		registrationCallee.object,
-		registrationCall.arguments?.[0],
-		registrationCall.arguments?.[1],
-		releaseCallee.object,
-		releaseCall.arguments?.[0],
-		releaseCall.arguments?.[1]
-	].flatMap((expression) => {
-		const projection = resolveForEachProjection(expression, context);
-		return projection ? [projection] : [];
-	});
-	if (registrationVerbName === "addEventListener" && releaseVerbName === "removeEventListener") for (const optionsNode of [registrationCall.arguments?.[2], releaseCall.arguments?.[2]]) {
-		const captureProjection = resolveEventListenerCaptureProjection(optionsNode, context);
-		if (captureProjection) projections.push(captureProjection);
-	}
-	if (projections.length === 0) return true;
-	const collectionKeys = new Set(projections.map((projection) => projection.collectionKey));
-	if (!findDirectExhaustiveForEachCleanupFunction(releaseCall, collectionKeys, context)) return false;
-	return !hasCollectionMutationBeforeRelease(registrationCall, releaseCall, collectionKeys, context);
-};
 const doesReleaseCallMatchUsage = (node, usage, context) => {
 	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
 	if (!isNodeOfType(callNode, "CallExpression")) return false;
@@ -15391,8 +15128,8 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	const releaseVerbName = getReleaseVerbName(callNode);
 	if (!releaseVerbName) return false;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return false;
-	const releaseReceiverKey = resolveResourceIdentityKey(callee.object, context);
-	const releaseEventKey = resolveResourceIdentityKey(callNode.arguments?.[0], context);
+	const releaseReceiverKey = resolveExpressionKey(callee.object, context);
+	const releaseEventKey = resolveExpressionKey(callNode.arguments?.[0], context);
 	const pairedReleaseVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
 	const pushedResourceCollectionKey = findPushedResourceCollectionKey(usage, context);
 	const releaseReceiverForOfStatement = findForOfStatementForIteratorExpression(callee.object, context);
@@ -15402,13 +15139,7 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (usage.kind === "socket") return usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (SOCKET_RELEASE_VERB_NAMES.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName));
 	if (usage.handleKey !== null && releaseReceiverKey === usage.handleKey && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub" || releaseVerbName === "close" || releaseVerbName === "unwatch" || releaseVerbName === "unlisten" || BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(releaseVerbName))) return true;
 	if (releaseVerbName === "abort" && releaseReceiverKey === getListenerAbortControllerKey(usage, context)) return true;
-	if (usage.registrationVerbName === "addListener" && isNodeOfType(usage.node, "CallExpression") && usage.node.arguments?.length === 1) return isProvenLegacyMediaQueryListMethodCall(usage.node, "addListener", context) && releaseVerbName === "removeListener" && isProvenLegacyMediaQueryListMethodCall(callNode, "removeListener", context) && usage.receiverKey !== null && resolveStableMediaQueryListenerIdentityKey(callee.object, context) === usage.receiverKey && usage.handlerKey !== null && resolveStableMediaQueryListenerIdentityKey(callNode.arguments?.[0], context) === usage.handlerKey;
 	if (releaseVerbName === "abort" && isRetainedAbortControllerRefRelease(callee.object, usage, context)) return true;
-	if (usage.registrationVerbName === "addEventListener" && releaseVerbName === "removeEventListener" && isNodeOfType(usage.node, "CallExpression")) {
-		if (!isNodeOfType(stripParenExpression(usage.node.callee), "MemberExpression")) return false;
-		if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], callNode.arguments?.[2], context, true)) return false;
-	}
-	if (isNodeOfType(usage.node, "CallExpression") && !hasSafeForEachProjectionCleanup(usage.node, callNode, context)) return false;
 	if (usage.receiverKey === null || releaseReceiverKey !== usage.receiverKey) return false;
 	if (usage.registrationVerbName === "subscribe" && (releaseVerbName === "unsubscribe" || releaseVerbName === "unsub") && usage.handleKey !== null && resolveExpressionKey(callNode.arguments?.[0], context) === usage.handleKey) return true;
 	const pairedVerbNames = usage.registrationVerbName ? PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(usage.registrationVerbName) : null;
@@ -15418,9 +15149,6 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 	if (isAssignmentFormForOfIteratorReference(usageEventArgument, context) || isAssignmentFormForOfIteratorReference(releaseEventArgument, context)) return false;
 	if (usage.eventKey !== null && releaseEventKey !== null && usage.eventKey !== releaseEventKey) {
 		if (!isNodeOfType(usage.node, "CallExpression")) return false;
-		const registrationEventProjectionKey = resolveForEachProjectionKey(usage.node.arguments?.[0], context);
-		const releaseEventProjectionKey = resolveForEachProjectionKey(callNode.arguments?.[0], context);
-		if ((registrationEventProjectionKey !== null || releaseEventProjectionKey !== null) && registrationEventProjectionKey !== releaseEventProjectionKey) return false;
 		const usageForOfStatement = findForOfStatementForIteratorExpression(usageEventArgument, context);
 		const releaseForOfStatement = findForOfStatementForIteratorExpression(releaseEventArgument, context);
 		if (usageForOfStatement === null !== (releaseForOfStatement === null)) return false;
@@ -15434,7 +15162,9 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 			const registrationCallee = stripParenExpression(usage.node.callee);
 			if (!isNodeOfType(registrationCallee, "MemberExpression")) return false;
 			if (!isStableLoopReceiver(registrationCallee.object, context) || !isStableLoopReceiver(callee.object, context) || registrationHandlerSymbolId === null || registrationHandlerSymbolId !== releaseHandlerSymbolId) return false;
-			if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], callNode.arguments?.[2], context)) return false;
+			const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
+			const releaseCapture = resolveEventListenerCapture(callNode.arguments?.[2], { allowIndeterminateEntries: true });
+			if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
 			if (!isDirectExhaustiveForOfRelease(callNode, releaseForOfStatement)) return false;
 		}
 	}
@@ -15443,28 +15173,27 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 		return isNodeOfType(handlerArgument, "Literal") && handlerArgument.value === null;
 	}
 	if (releaseVerbName === "removeEventListener" || releaseVerbName === "removeListener" || releaseVerbName === "off") {
-		const usesUnaryListenerSignatureForCalls = isNodeOfType(usage.node, "CallExpression") && usesUnaryListenerSignature(usage.node, callNode);
-		const releaseHandler = usesUnaryListenerSignatureForCalls ? callNode.arguments?.[0] : callNode.arguments?.[1];
+		const usesUnaryListenerSignature = usage.registrationVerbName === "addListener" && isNodeOfType(usage.node, "CallExpression") && usage.node.arguments?.length === 1 && callNode.arguments?.length === 1;
+		const releaseHandler = usesUnaryListenerSignature ? callNode.arguments?.[0] : callNode.arguments?.[1];
 		if (!releaseHandler) return releaseVerbName === "off";
-		const expectedHandlerKey = usesUnaryListenerSignatureForCalls ? usage.eventKey : usage.handlerKey;
-		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignatureForCalls ? 0 : 1] : null;
-		return expectedHandlerKey !== null && resolveResourceIdentityKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
+		const expectedHandlerKey = usesUnaryListenerSignature ? usage.eventKey : usage.handlerKey;
+		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignature ? 0 : 1] : null;
+		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
 	}
 	if (releaseVerbName === "unobserve" && usage.eventKey !== null) return releaseEventKey === usage.eventKey;
 	return true;
 };
 const matchesPairedReleaseVerb = (releaseVerbName, pairedVerbNames) => pairedVerbNames.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName);
 const isReturnedEffectCleanupFunction = (functionNode, context) => {
-	const effectCallback = findEnclosingFunction$1(functionNode);
-	if (!effectCallback || !isFunctionLike$1(effectCallback)) return false;
-	const effectCall = effectCallback.parent;
-	if (!isNodeOfType(effectCall, "CallExpression") || !isReactHookCall(effectCall, CLEANUP_EFFECT_HOOK_NAMES, context.scopes)) return false;
-	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return resolveStableValue(effectCallback.body, context) === functionNode;
-	let isReturned = false;
-	walkInsideStatementBlocks(effectCallback.body, (child) => {
-		if (isNodeOfType(child, "ReturnStatement") && child.argument && resolveStableValue(child.argument, context) === functionNode) isReturned = true;
-	});
-	return isReturned;
+	let currentNode = functionNode;
+	let parentNode = currentNode.parent;
+	while (isNodeOfType(parentNode, "ChainExpression") || isNodeOfType(parentNode, "TSAsExpression") || isNodeOfType(parentNode, "TSNonNullExpression")) {
+		currentNode = parentNode;
+		parentNode = currentNode.parent;
+	}
+	const effectCallback = isNodeOfType(parentNode, "ReturnStatement") && parentNode.argument === currentNode ? findEnclosingFunction$1(parentNode) : isNodeOfType(parentNode, "ArrowFunctionExpression") && parentNode.body === currentNode ? parentNode : null;
+	const effectCall = effectCallback?.parent;
+	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isReactHookCall(effectCall, CLEANUP_EFFECT_HOOK_NAMES, context.scopes));
 };
 const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode, context)) return true;
@@ -15607,9 +15336,11 @@ const isRetainedDisposerRefRelease = (releaseNode, usage, context) => {
 };
 const isSelfReleasingListenerRelease = (releaseNode, releaseFunction, usage, context) => {
 	if (usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.receiverKey === null || usage.eventKey === null || !isNodeOfType(usage.node, "CallExpression") || !isFunctionLike$1(releaseFunction) || releaseFunction.async || releaseFunction.generator || !isNodeOfType(releaseFunction.body, "BlockStatement") || !doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
+	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
 	const releaseCall = isNodeOfType(releaseNode, "ChainExpression") ? releaseNode.expression : releaseNode;
 	if (!isNodeOfType(releaseCall, "CallExpression")) return false;
-	if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], releaseCall.arguments?.[2], context)) return false;
+	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
+	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
 	const ownerFunction = findEnclosingFunction$1(releaseFunction);
 	if (!ownerFunction || !isFunctionLike$1(ownerFunction)) return false;
 	const triggerRegistrations = [];
@@ -19079,12 +18810,11 @@ const forbidDomProps = defineRule({
 * carrying their own near-identical inlined implementation.
 */
 const flattenCalleeName = (callee) => {
-	const unwrappedCallee = stripParenExpression(callee);
-	if (isNodeOfType(unwrappedCallee, "Identifier")) return unwrappedCallee.name;
-	if (isNodeOfType(unwrappedCallee, "MemberExpression") && !unwrappedCallee.computed) {
-		const objectName = flattenCalleeName(unwrappedCallee.object);
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
+		const objectName = flattenCalleeName(callee.object);
 		if (!objectName) return null;
-		if (isNodeOfType(unwrappedCallee.property, "Identifier")) return `${objectName}.${unwrappedCallee.property.name}`;
+		if (isNodeOfType(callee.property, "Identifier")) return `${objectName}.${callee.property.name}`;
 	}
 	return null;
 };
@@ -22484,49 +22214,25 @@ const jsLengthCheckFirst = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/is-proven-global-namespace-reference.ts
-const GLOBAL_SELF_PROPERTY_NAMES = new Set([
-	"global",
-	"globalThis",
-	"self",
-	"window"
-]);
 const isProvenGlobalObjectReference = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	let currentExpression = expression;
-	while (true) {
-		const strippedExpression = stripParenExpression(currentExpression);
-		if (!isNodeOfType(strippedExpression, "Identifier")) return false;
-		if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
-		const symbol = scopes.symbolFor(strippedExpression);
-		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
-		const declaration = symbol.declarationNode;
-		const initializer = declaration.init;
-		if (!initializer) return false;
-		const isDirectIdentifierAlias = isNodeOfType(declaration.id, "Identifier") && declaration.id === symbol.bindingIdentifier && initializer === symbol.initializer;
-		const bindingProperty = symbol.bindingIdentifier.parent;
-		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
-		const isDirectGlobalSelfAlias = isNodeOfType(declaration.id, "ObjectPattern") && isNodeOfType(bindingProperty, "Property") && bindingProperty.value === symbol.bindingIdentifier && bindingProperty.parent === declaration.id && destructuredPropertyName !== null && GLOBAL_SELF_PROPERTY_NAMES.has(destructuredPropertyName);
-		if (!isDirectIdentifierAlias && !isDirectGlobalSelfAlias) return false;
-		visitedSymbolIds.add(symbol.id);
-		currentExpression = initializer;
-	}
+	const strippedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
+	if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
+	const symbol = scopes.symbolFor(strippedExpression);
+	if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isProvenGlobalObjectReference(symbol.initializer, scopes, visitedSymbolIds);
 };
 const isProvenGlobalNamespaceReference = (expression, namespaceName, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	let currentExpression = expression;
-	while (true) {
-		const strippedExpression = stripParenExpression(currentExpression);
-		if (!isNodeOfType(strippedExpression, "Identifier")) return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
 		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
 		const symbol = scopes.symbolFor(strippedExpression);
-		if (!symbol || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
 		visitedSymbolIds.add(symbol.id);
-		const declaration = symbol.declarationNode;
-		const bindingIdentifier = symbol.bindingIdentifier;
-		const bindingProperty = bindingIdentifier.parent;
-		if (getDestructuredBindingPropertyName(bindingIdentifier) === namespaceName && isNodeOfType(declaration, "VariableDeclarator") && isNodeOfType(declaration.id, "ObjectPattern") && isNodeOfType(bindingProperty, "Property") && bindingProperty.value === bindingIdentifier && bindingProperty.parent === declaration.id && declaration.init) return isProvenGlobalObjectReference(declaration.init, scopes);
-		const directInitializer = getDirectConstInitializer(symbol);
-		if (!directInitializer) return false;
-		currentExpression = directInitializer;
+		return isProvenGlobalNamespaceReference(symbol.initializer, namespaceName, scopes, visitedSymbolIds);
 	}
+	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
 };
 //#endregion
 //#region src/plugin/rules/js-performance/js-min-max-loop.ts
@@ -24881,14 +24587,9 @@ const collectContextBindings = (programRoot) => {
 	}
 	return bindings;
 };
-const isCreateContextBindingJsxName = (node, contextBindings, scopes) => {
+const isCreateContextBindingJsxName = (node, contextBindings) => {
 	if (!isNodeOfType(node, "JSXIdentifier")) return false;
-	if (!contextBindings.has(node.name)) {
-		const symbol = scopes.symbolFor(node);
-		if (!symbol || symbol.kind !== "import") return false;
-		const importedName = getImportedName(symbol.declarationNode);
-		return getImportSourceForName(node, node.name)?.toLowerCase().includes("context") === true && (node.name.endsWith("Context") || importedName?.endsWith("Context") === true);
-	}
+	if (!contextBindings.has(node.name)) return false;
 	const binding = findVariableInitializer(node, node.name);
 	if (!binding) return false;
 	return binding.scopeOwner.type === "Program";
@@ -24912,7 +24613,7 @@ const jsxNoConstructedContextValues = defineRule({
 				if (isTestlikeFile) return;
 				const nameNode = node.name;
 				const isLegacyProvider = isProviderMemberName(nameNode);
-				const isReact19Shorthand = isCreateContextBindingJsxName(nameNode, contextBindings, context.scopes);
+				const isReact19Shorthand = isCreateContextBindingJsxName(nameNode, contextBindings);
 				if (!isLegacyProvider && !isReact19Shorthand) return;
 				if (!isInsideFunctionScope(node)) return;
 				for (const attribute of node.attributes) {
@@ -25183,29 +24884,6 @@ const buildSameFileJsxSlotPropRegistry = (program, memoRegistry, scopes) => {
 	return registry;
 };
 //#endregion
-//#region src/plugin/utils/has-custom-memo-comparator.ts
-const MEMO_CALLEE_NAMES$1 = new Set(["memo", "React.memo"]);
-const isIdentitySensitiveMemoComparator = (comparatorNode, scopes) => {
-	if (isNodeOfType(comparatorNode, "Identifier")) {
-		if (comparatorNode.name === "undefined") return scopes.isGlobalReference(comparatorNode);
-		return getImportedNameFromModule(comparatorNode, comparatorNode.name, "react-redux") === "shallowEqual";
-	}
-	if (!isNodeOfType(comparatorNode, "MemberExpression") || comparatorNode.computed || !isNodeOfType(comparatorNode.object, "Identifier") || !isNodeOfType(comparatorNode.property, "Identifier") || comparatorNode.property.name !== "shallowEqual") return false;
-	return isNamespaceImportFromModule$1(comparatorNode, comparatorNode.object.name, "react-redux");
-};
-const hasCustomMemoComparator = (openingName, scopes) => {
-	if (!openingName || !isNodeOfType(openingName, "JSXIdentifier")) return false;
-	const binding = findVariableInitializer(openingName, openingName.name);
-	if (!binding || !binding.initializer) return false;
-	const initializer = binding.initializer;
-	if (!isNodeOfType(initializer, "CallExpression")) return false;
-	const calleeName = flattenCalleeName(initializer.callee);
-	if (calleeName === null || !MEMO_CALLEE_NAMES$1.has(calleeName)) return false;
-	const comparatorNode = (initializer.arguments ?? [])[1];
-	if (!comparatorNode) return false;
-	return !isIdentitySensitiveMemoComparator(comparatorNode, scopes);
-};
-//#endregion
 //#region src/plugin/utils/is-on-intrinsic-html-element.ts
 const isJsxAttributeOnIntrinsicHtmlElement = (attribute) => {
 	const openingElement = attribute.parent;
@@ -25491,7 +25169,6 @@ const jsxNoJsxAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
-				if (hasCustomMemoComparator(openingName, context.scopes)) return;
 				const openingSymbol = openingName && isNodeOfType(openingName, "JSXIdentifier") ? context.scopes.symbolFor(openingName) : null;
 				if (openingSymbol && isNodeOfType(node.name, "JSXIdentifier") && jsxSlotPropRegistry?.get(openingSymbol.id)?.has(node.name.name)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier") && isSlotPropName(node.name.name)) return;
@@ -25511,6 +25188,19 @@ const jsxNoJsxAsProp = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/has-custom-memo-comparator.ts
+const MEMO_CALLEE_NAMES = new Set(["memo", "React.memo"]);
+const hasCustomMemoComparator = (openingName) => {
+	if (!openingName || !isNodeOfType(openingName, "JSXIdentifier")) return false;
+	const binding = findVariableInitializer(openingName, openingName.name);
+	if (!binding || !binding.initializer) return false;
+	const initializer = binding.initializer;
+	if (!isNodeOfType(initializer, "CallExpression")) return false;
+	const calleeName = flattenCalleeName(initializer.callee);
+	if (calleeName === null || !MEMO_CALLEE_NAMES.has(calleeName)) return false;
+	return (initializer.arguments ?? []).length >= 2;
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-array-as-prop-tables.ts
 const DATA_ARRAY_PROP_NAMES = new Set([
 	"data",
@@ -25869,7 +25559,7 @@ const jsxNoNewArrayAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
-				if (hasCustomMemoComparator(openingName, context.scopes)) return;
+				if (hasCustomMemoComparator(openingName)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier") && isDataArrayPropName(node.name.name)) return;
 				if (!isInsideFunctionScope(node)) return;
 				const value = node.value;
@@ -26333,7 +26023,6 @@ const jsxNoNewFunctionAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
-				if (hasCustomMemoComparator(openingName, context.scopes)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier") && isOneShotHandlerName(node.name.name)) return;
 				if (!isInsideFunctionScope(node)) return;
 				const value = node.value;
@@ -26641,7 +26330,7 @@ const jsxNoNewObjectAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
-				if (hasCustomMemoComparator(openingName, context.scopes)) return;
+				if (hasCustomMemoComparator(openingName)) return;
 				if (!isInsideFunctionScope(node)) return;
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
 				if (ALWAYS_FRESH_OBJECT_PROPS.has(node.name.name)) return;
@@ -29673,14 +29362,6 @@ const nextjsNoImgElement = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-no-native-script.ts
-const hasEnabledBooleanAttribute = (attributes, attributeName) => {
-	const attribute = findJsxAttribute(attributes, attributeName);
-	if (!attribute) return false;
-	if (attribute.value === null) return true;
-	if (isNodeOfType(attribute.value, "Literal")) return true;
-	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return false;
-	return isNodeOfType(attribute.value.expression, "Literal") && Boolean(attribute.value.expression.value);
-};
 const nextjsNoNativeScript = defineRule({
 	id: "nextjs-no-native-script",
 	title: "Plain script can block Next.js rendering",
@@ -29693,9 +29374,6 @@ const nextjsNoNativeScript = defineRule({
 		const typeAttribute = findJsxAttribute(node.attributes ?? [], "type");
 		const typeValue = isNodeOfType(typeAttribute?.value, "Literal") ? typeAttribute.value.value : null;
 		if (typeof typeValue === "string" && !EXECUTABLE_SCRIPT_TYPES.has(typeValue)) return;
-		if (hasEnabledBooleanAttribute(node.attributes ?? [], "async")) return;
-		if (hasEnabledBooleanAttribute(node.attributes ?? [], "defer")) return;
-		if (typeValue === "module") return;
 		const hasSrcAttribute = Boolean(findJsxAttribute(node.attributes ?? [], "src"));
 		if (Boolean(findJsxAttribute(node.attributes ?? [], "dangerouslySetInnerHTML")) && !hasSrcAttribute) return;
 		context.report({
@@ -34788,19 +34466,6 @@ const noCascadingSetState = defineRetiredRule({
 	recommendation: "Retired: React batches synchronous state updates from one effect into the same follow-up commit, so setter count does not prove repeated redraws."
 });
 //#endregion
-//#region src/plugin/utils/get-react-use-callback-call.ts
-const getReactUseCallbackCall = (expression, scopes) => {
-	const identifier = stripParenExpression(expression);
-	if (!isNodeOfType(identifier, "Identifier")) return null;
-	const symbol = resolveConstIdentifierAlias(identifier, scopes);
-	if (symbol?.kind !== "const" || !symbol.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	return isNodeOfType(initializer, "CallExpression") && isReactApiCall(initializer, "useCallback", scopes, {
-		allowGlobalReactNamespace: true,
-		resolveNamedAliases: true
-	}) ? initializer : null;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/create-state-trigger-reachability.ts
 const getRefCurrentSymbol = (node, context) => {
 	const expression = stripParenExpression(node);
@@ -35329,8 +34994,19 @@ const isBuiltinNamespaceCallee = (callee) => {
 	}
 	return false;
 };
+const getReactUseCallbackSource = (reference, context) => {
+	const identifier = reference.identifier;
+	const symbol = resolveConstIdentifierAlias(identifier, context.scopes);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	if (isNodeOfType(initializer, "CallExpression") && isReactApiCall(initializer, "useCallback", context.scopes, {
+		allowGlobalReactNamespace: true,
+		resolveNamedAliases: true
+	})) return initializer;
+	return null;
+};
 const getDependencyStateRefs = (analysis, context, dependencyReference) => {
-	const useCallbackCall = getReactUseCallbackCall(dependencyReference.identifier, context.scopes);
+	const useCallbackCall = getReactUseCallbackSource(dependencyReference, context);
 	if (!useCallbackCall) return getUpstreamRefs(analysis, dependencyReference).filter((reference) => isState(analysis, reference));
 	const dependencyList = useCallbackCall.arguments?.[1];
 	if (!dependencyList || !isNodeOfType(dependencyList, "ArrayExpression")) return getUpstreamRefs(analysis, dependencyReference).filter((reference) => isState(analysis, reference));
@@ -38844,17 +38520,6 @@ const noDynamicImportPath = defineRule({
 	})
 });
 //#endregion
-//#region src/plugin/utils/get-require-call-source.ts
-const getRequireCallSource = (expression) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return getRequireCallSource(unwrappedExpression.object);
-	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
-	if (!isNodeOfType(unwrappedExpression.callee, "Identifier") || unwrappedExpression.callee.name !== "require") return null;
-	const [firstArgument] = unwrappedExpression.arguments ?? [];
-	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
-	return typeof firstArgument.value === "string" ? firstArgument.value : null;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/is-cleanup-return.ts
 const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
 	"each",
@@ -38999,16 +38664,7 @@ const collectDependencyStateSymbolIds = (effectNode, stateSymbolIds, scopes) =>
 	}
 	return dependencyStateSymbolIds;
 };
-const resolveSynchronouslyInvokedFunction = (expression, scopes) => {
-	const localFunction = resolveExactLocalFunction(expression, scopes);
-	if (localFunction) return localFunction;
-	const useCallbackCall = getReactUseCallbackCall(expression, scopes);
-	if (!useCallbackCall) return null;
-	const callback = useCallbackCall.arguments[0];
-	if (!callback || isNodeOfType(callback, "SpreadElement")) return null;
-	return resolveExactLocalFunction(callback, scopes);
-};
-const collectSynchronouslyInvokedFunctions = (effectCallback, scopes, includeStableCallbacks = true) => {
+const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
 	const analysisFunctions = new Set([effectCallback]);
 	const pendingFunctions = [effectCallback];
 	while (pendingFunctions.length > 0) {
@@ -39016,9 +38672,9 @@ const collectSynchronouslyInvokedFunctions = (effectCallback, scopes, includeSta
 		if (!currentFunction || !isFunctionLike$1(currentFunction)) continue;
 		walkInsideStatementBlocks(currentFunction.body, (child) => {
 			if (!isNodeOfType(child, "CallExpression")) return;
-			const invokedFunction = includeStableCallbacks ? resolveSynchronouslyInvokedFunction(child.callee, scopes) : resolveExactLocalFunction(child.callee, scopes);
+			const invokedFunction = resolveExactLocalFunction(child.callee, scopes);
 			if (!invokedFunction || analysisFunctions.has(invokedFunction)) return;
-			if (isFunctionLike$1(invokedFunction) && (invokedFunction.async || invokedFunction.generator)) return;
+			if (isFunctionLike$1(invokedFunction) && invokedFunction.async) return;
 			analysisFunctions.add(invokedFunction);
 			pendingFunctions.push(invokedFunction);
 		});
@@ -39031,51 +38687,7 @@ const visitSynchronousFunctionBodies = (analysisFunctions, visitor) => {
 		walkInsideStatementBlocks(analysisFunction.body, visitor);
 	}
 };
-const getStateNameForSetterCall = (node, setterSymbolIdToStateName, scopes) => {
-	if (!isNodeOfType(node, "CallExpression") || !isNodeOfType(node.callee, "Identifier")) return null;
-	const setterSymbol = resolveConstIdentifierAlias(node.callee, scopes, true);
-	return setterSymbol ? setterSymbolIdToStateName.get(setterSymbol.id) ?? null : null;
-};
-const collectStateWriteAnalysisFunctions = (effectCallback, scopes, setterSymbolIdToStateName) => {
-	const ordinaryAnalysisFunctions = collectSynchronouslyInvokedFunctions(effectCallback, scopes, false);
-	const fullAnalysisFunctions = collectSynchronouslyInvokedFunctions(effectCallback, scopes);
-	const stableAnalysisFunctions = [...fullAnalysisFunctions].filter((analysisFunction) => !ordinaryAnalysisFunctions.has(analysisFunction));
-	if (stableAnalysisFunctions.length === 0) return ordinaryAnalysisFunctions;
-	let hasUnprovenObservableWork = stableAnalysisFunctions.some((analysisFunction) => {
-		if (!isFunctionLike$1(analysisFunction)) return false;
-		let hasExecutableDefault = false;
-		for (const parameter of analysisFunction.params) {
-			walkInsideStatementBlocks(parameter, (child) => {
-				if (isNodeOfType(child, "CallExpression") || isNodeOfType(child, "AssignmentExpression") || isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "ImportExpression") || isNodeOfType(child, "NewExpression") || isNodeOfType(child, "TaggedTemplateExpression") || isNodeOfType(child, "ThrowStatement") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") hasExecutableDefault = true;
-			});
-			if (hasExecutableDefault) return true;
-		}
-		return false;
-	});
-	const stableWrittenStateNames = /* @__PURE__ */ new Set();
-	const allWrittenStateNames = /* @__PURE__ */ new Set();
-	visitSynchronousFunctionBodies(fullAnalysisFunctions, (child) => {
-		const writtenStateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
-		if (writtenStateName) allWrittenStateNames.add(writtenStateName);
-	});
-	visitSynchronousFunctionBodies(new Set(stableAnalysisFunctions), (child) => {
-		if (hasUnprovenObservableWork) return;
-		if (isNodeOfType(child, "CallExpression")) {
-			const writtenStateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
-			if (writtenStateName) {
-				stableWrittenStateNames.add(writtenStateName);
-				return;
-			}
-			const invokedFunction = resolveSynchronouslyInvokedFunction(child.callee, scopes);
-			if (invokedFunction && fullAnalysisFunctions.has(invokedFunction)) return;
-			hasUnprovenObservableWork = true;
-			return;
-		}
-		if (isNodeOfType(child, "AssignmentExpression") || isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "ImportExpression") || isNodeOfType(child, "NewExpression") || isNodeOfType(child, "TaggedTemplateExpression") || isNodeOfType(child, "ThrowStatement") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") hasUnprovenObservableWork = true;
-	});
-	return !hasUnprovenObservableWork && stableWrittenStateNames.size === 1 && allWrittenStateNames.size === 1 ? fullAnalysisFunctions : ordinaryAnalysisFunctions;
-};
-const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, visitedSymbolIds = /* @__PURE__ */ new Set(), additionalStateValues = /* @__PURE__ */ new Map()) => {
+const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	if (isNodeOfType(unwrappedExpression, "Literal")) {
 		const literalValue = unwrappedExpression.value;
@@ -39083,49 +38695,46 @@ const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, vi
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const symbol = scopes.symbolFor(unwrappedExpression);
-		if (symbol?.id === stateSymbolId) return stateValue;
-		if (symbol && additionalStateValues.has(symbol.id)) return additionalStateValues.get(symbol.id) ?? null;
+		if (scopes.symbolFor(unwrappedExpression)?.id === stateSymbolId) return stateValue;
 		if (unwrappedExpression.name === "undefined" && scopes.isGlobalReference(unwrappedExpression)) return { value: void 0 };
-		if (unwrappedExpression.name === "NaN" && scopes.isGlobalReference(unwrappedExpression)) return { value: NaN };
 		const immutableSymbol = scopes.symbolFor(unwrappedExpression);
 		if (immutableSymbol?.kind !== "const" || !immutableSymbol.initializer || !isNodeOfType(immutableSymbol.declarationNode, "VariableDeclarator") || immutableSymbol.declarationNode.id !== immutableSymbol.bindingIdentifier || immutableSymbol.declarationNode.init !== immutableSymbol.initializer || immutableSymbol.references.some((reference) => reference.flag !== "read") || visitedSymbolIds.has(immutableSymbol.id)) return null;
-		return readStaticEffectValue(immutableSymbol.initializer, scopes, stateSymbolId, stateValue, new Set(visitedSymbolIds).add(immutableSymbol.id), additionalStateValues);
+		return readStaticEffectValue(immutableSymbol.initializer, scopes, stateSymbolId, stateValue, new Set(visitedSymbolIds).add(immutableSymbol.id));
 	}
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression")) {
 		if (unwrappedExpression.operator === "void") return { value: void 0 };
 		if (unwrappedExpression.operator !== "!") return null;
-		const argumentValue = readStaticEffectValue(unwrappedExpression.argument, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const argumentValue = readStaticEffectValue(unwrappedExpression.argument, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		return argumentValue ? { value: !argumentValue.value } : null;
 	}
 	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
 		if (isNodeOfType(unwrappedExpression.callee, "Identifier") && unwrappedExpression.callee.name === "Boolean" && scopes.isGlobalReference(unwrappedExpression.callee) && unwrappedExpression.arguments.length === 1 && unwrappedExpression.arguments[0] && !isNodeOfType(unwrappedExpression.arguments[0], "SpreadElement")) {
-			const argumentValue = readStaticEffectValue(unwrappedExpression.arguments[0], scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+			const argumentValue = readStaticEffectValue(unwrappedExpression.arguments[0], scopes, stateSymbolId, stateValue, visitedSymbolIds);
 			return argumentValue ? { value: Boolean(argumentValue.value) } : null;
 		}
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		if (!leftValue) return null;
 		if (unwrappedExpression.operator === "&&" && !leftValue.value) return leftValue;
 		if (unwrappedExpression.operator === "||" && leftValue.value) return leftValue;
 		if (unwrappedExpression.operator === "??" && leftValue.value !== null && leftValue.value !== void 0) return leftValue;
-		return readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		return readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 	}
 	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
-		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		if (!testValue) return null;
-		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 	}
 	if (isNodeOfType(unwrappedExpression, "MemberExpression") && unwrappedExpression.optional) {
-		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		if (objectValue?.value === null || objectValue?.value === void 0) return { value: void 0 };
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "BinaryExpression")) {
-		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
-		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
 		if (!leftValue || !rightValue) return null;
 		if (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "!==") {
 			const areEqual = leftValue.value === rightValue.value;
@@ -39164,7 +38773,8 @@ const collectStateWritesInEffect = (analysisFunctions, setterSymbolIdToStateName
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
-		const stateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
+		const setterSymbol = resolveConstIdentifierAlias(child.callee, scopes, true);
+		const stateName = setterSymbol ? setterSymbolIdToStateName.get(setterSymbol.id) : void 0;
 		if (!stateName) return;
 		const writeInfo = stateWrites.get(stateName) ?? {
 			values: /* @__PURE__ */ new Set(),
@@ -39180,27 +38790,27 @@ const collectStateWritesInEffect = (analysisFunctions, setterSymbolIdToStateName
 const isGlobalBooleanCall = (node, scopes) => {
 	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Boolean" && scopes.isGlobalReference(node.callee);
 };
-const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map()) => {
+const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, scopes) => {
 	let currentNode = workNode;
 	while (currentNode.parent) {
 		const parentNode = currentNode.parent;
 		if (isFunctionLike$1(parentNode)) break;
 		if (isNodeOfType(parentNode, "IfStatement")) {
-			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
 			if (testValue) {
 				if (currentNode === parentNode.consequent && !testValue.value) return false;
 				if (currentNode === parentNode.alternate && testValue.value) return false;
 			}
 		}
 		if (isNodeOfType(parentNode, "ConditionalExpression")) {
-			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
 			if (testValue) {
 				if (currentNode === parentNode.consequent && !testValue.value) return false;
 				if (currentNode === parentNode.alternate && testValue.value) return false;
 			}
 		}
 		if (isNodeOfType(parentNode, "LogicalExpression") && currentNode === parentNode.right) {
-			const leftValue = readStaticEffectValue(parentNode.left, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
+			const leftValue = readStaticEffectValue(parentNode.left, scopes, stateSymbolId, stateValue);
 			if (leftValue) {
 				if (parentNode.operator === "&&" && !leftValue.value) return false;
 				if (parentNode.operator === "||" && leftValue.value) return false;
@@ -39212,7 +38822,7 @@ const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, s
 			if (statementIndex >= 0) for (let index = 0; index < statementIndex; index += 1) {
 				const earlierStatement = parentNode.body[index];
 				if (!isNodeOfType(earlierStatement, "IfStatement") || earlierStatement.alternate || !statementAlwaysExits(earlierStatement.consequent)) continue;
-				if (readStaticEffectValue(earlierStatement.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues)?.value) return false;
+				if (readStaticEffectValue(earlierStatement.test, scopes, stateSymbolId, stateValue)?.value) return false;
 			}
 		}
 		currentNode = parentNode;
@@ -39222,93 +38832,24 @@ const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, s
 const isReaderWorkNode = (node, analysisFunctions, scopes) => {
 	if (isNodeOfType(node, "CallExpression")) {
 		if (isGlobalBooleanCall(node, scopes)) return false;
-		const invokedFunction = resolveSynchronouslyInvokedFunction(node.callee, scopes);
+		const invokedFunction = resolveExactLocalFunction(node.callee, scopes);
 		return !invokedFunction || !analysisFunctions.has(invokedFunction);
 	}
 	return isNodeOfType(node, "AssignmentExpression") || isNodeOfType(node, "UpdateExpression") || isNodeOfType(node, "NewExpression") || isNodeOfType(node, "TaggedTemplateExpression") || isNodeOfType(node, "ThrowStatement") || isNodeOfType(node, "UnaryExpression") && node.operator === "delete";
 };
-const mergeKnownStateValues = (additionalStateValues, parameterStateValues) => {
-	if (parameterStateValues.size === 0) return additionalStateValues;
-	const knownStateValues = new Map(additionalStateValues);
-	for (const [symbolId, value] of parameterStateValues) knownStateValues.set(symbolId, value);
-	return knownStateValues;
-};
-const buildInvokedFunctionParameterStateValues = (invokedFunction, invocation, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map(), callerParameterStateValues = /* @__PURE__ */ new Map()) => {
-	if (!isFunctionLike$1(invokedFunction)) return /* @__PURE__ */ new Map();
-	const parameterStateValues = /* @__PURE__ */ new Map();
-	const callerKnownStateValues = mergeKnownStateValues(additionalStateValues, callerParameterStateValues);
-	for (let parameterIndex = 0; parameterIndex < invokedFunction.params.length; parameterIndex += 1) {
-		const rawParameter = invokedFunction.params[parameterIndex];
-		const rawArgument = invocation.arguments[parameterIndex];
-		if (rawArgument && isNodeOfType(rawArgument, "SpreadElement")) break;
-		const parameter = isNodeOfType(rawParameter, "AssignmentPattern") ? rawParameter.left : rawParameter;
-		if (!isNodeOfType(parameter, "Identifier")) continue;
-		const parameterSymbol = scopes.symbolFor(parameter);
-		if (!parameterSymbol) continue;
-		let argumentValue = null;
-		if (rawArgument) {
-			argumentValue = readStaticEffectValue(rawArgument, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), callerKnownStateValues);
-			if (argumentValue !== null && argumentValue.value === void 0 && isNodeOfType(rawParameter, "AssignmentPattern")) {
-				const defaultKnownStateValues = mergeKnownStateValues(callerKnownStateValues, parameterStateValues);
-				argumentValue = readStaticEffectValue(rawParameter.right, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), defaultKnownStateValues);
-			}
-		} else if (isNodeOfType(rawParameter, "AssignmentPattern")) {
-			const defaultKnownStateValues = mergeKnownStateValues(callerKnownStateValues, parameterStateValues);
-			argumentValue = readStaticEffectValue(rawParameter.right, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), defaultKnownStateValues);
-		} else argumentValue = { value: void 0 };
-		if (argumentValue) parameterStateValues.set(parameterSymbol.id, argumentValue);
-	}
-	return parameterStateValues;
-};
-const haveEqualParameterStateValues = (leftValues, rightValues) => {
-	if (leftValues.size !== rightValues.size) return false;
-	for (const [symbolId, leftValue] of leftValues) {
-		const rightValue = rightValues.get(symbolId);
-		if (!rightValue || !Object.is(leftValue.value, rightValue.value)) return false;
-	}
-	return true;
-};
-const canReaderWorkRunForStateValues = (readerEffect, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map()) => {
-	const pendingFrames = [{
-		functionNode: readerEffect.callback,
-		parameterStateValues: /* @__PURE__ */ new Map()
-	}];
-	const visitedParameterStateValues = /* @__PURE__ */ new Map();
-	while (pendingFrames.length > 0) {
-		const frame = pendingFrames.pop();
-		if (!frame || !isFunctionLike$1(frame.functionNode)) continue;
-		const functionParameterStateValues = visitedParameterStateValues.get(frame.functionNode) ?? [];
-		if (functionParameterStateValues.some((previousValues) => haveEqualParameterStateValues(previousValues, frame.parameterStateValues))) continue;
-		functionParameterStateValues.push(frame.parameterStateValues);
-		visitedParameterStateValues.set(frame.functionNode, functionParameterStateValues);
-		const knownStateValues = mergeKnownStateValues(additionalStateValues, frame.parameterStateValues);
+const canStateWriteReachReaderWork = (writeInfo, readerEffect, stateSymbolId, scopes) => {
+	if (writeInfo.hasUnknownValue || stateSymbolId === null) return true;
+	for (const writtenValue of writeInfo.values) {
+		const stateValue = { value: writtenValue };
 		let didFindReachableWork = false;
-		walkInsideStatementBlocks(frame.functionNode.body, (child) => {
-			if (didFindReachableWork) return;
-			if (isNodeOfType(child, "CallExpression")) {
-				const invokedFunction = resolveSynchronouslyInvokedFunction(child.callee, scopes);
-				if (invokedFunction && readerEffect.analysisFunctions.has(invokedFunction)) {
-					if (isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes, knownStateValues)) pendingFrames.push({
-						functionNode: invokedFunction,
-						parameterStateValues: buildInvokedFunctionParameterStateValues(invokedFunction, child, stateSymbolId, stateValue, scopes, additionalStateValues, frame.parameterStateValues)
-					});
-					return;
-				}
-			}
-			if (isReaderWorkNode(child, readerEffect.analysisFunctions, scopes) && isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes, knownStateValues)) didFindReachableWork = true;
+		visitSynchronousFunctionBodies(readerEffect.analysisFunctions, (child) => {
+			if (didFindReachableWork || !isReaderWorkNode(child, readerEffect.analysisFunctions, scopes)) return;
+			if (isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes)) didFindReachableWork = true;
 		});
 		if (didFindReachableWork) return true;
 	}
 	return false;
 };
-const canStateWriteReachReaderWork = (writtenStateName, writerEffect, readerEffect, stateSymbolIds, scopes) => {
-	const writeInfo = writerEffect.stateWrites.get(writtenStateName);
-	const stateSymbolId = stateSymbolIds.get(writtenStateName);
-	if (!writeInfo || stateSymbolId === void 0) return true;
-	if (writeInfo.hasUnknownValue) return true;
-	for (const writtenValue of writeInfo.values) if (canReaderWorkRunForStateValues(readerEffect, stateSymbolId, { value: writtenValue }, scopes)) return true;
-	return false;
-};
 const EMPTY_CLEANUP_NAME_SET = /* @__PURE__ */ new Set();
 const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
 	"clear",
@@ -39319,499 +38860,26 @@ const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
 	"keys",
 	"values"
 ]);
-const EXTERNAL_SYNC_DIRECT_IMPORT_SOURCES = new Map([
-	["fetch", new Set([
-		"cross-fetch",
-		"node-fetch",
-		"undici"
-	])],
-	["ky", new Set(["ky"])],
-	["got", new Set(["got"])],
-	["wretch", new Set(["wretch"])],
-	["ofetch", new Set(["ofetch"])],
-	["setTimeout", new Set([
-		"node:timers",
-		"node:timers/promises",
-		"timers",
-		"timers/promises"
-	])],
-	["setInterval", new Set([
-		"node:timers",
-		"node:timers/promises",
-		"timers",
-		"timers/promises"
-	])]
-]);
-const EXTERNAL_SYNC_DEFAULT_IMPORT_NAMES = new Map([
-	["axios", "axios"],
-	["cross-fetch", "fetch"],
-	["got", "got"],
-	["ky", "ky"],
-	["node-fetch", "fetch"],
-	["wretch", "wretch"]
-]);
-const EXTERNAL_SYNC_HTTP_CLIENT_MODULE_SOURCES = new Set([
-	"axios",
-	"cross-fetch",
-	"got",
-	"ky",
-	"node-fetch",
-	"ofetch",
-	"undici",
-	"wretch"
-]);
-const EXTERNAL_SYNC_GLOBAL_HTTP_CLIENT_NAMES = new Set([
-	"axios",
-	"got",
-	"ky",
-	"ofetch",
-	"wretch"
-]);
-const EXTERNAL_SYNC_HTTP_METHOD_NAMES = new Set([
-	...EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES,
-	"fetch",
-	"patch",
-	"post",
-	"put",
-	"request"
-]);
-const TANSTACK_QUERY_CLIENT_MODULE_SOURCES = new Set(["@tanstack/query-core", "@tanstack/react-query"]);
-const TANSTACK_QUERY_EXTERNAL_SYNC_METHOD_NAMES = new Set(["fetchQuery", "prefetchQuery"]);
-const EXTERNAL_SYNC_RESOURCE_CONSTRUCTOR_NAMES = new Set([
-	...EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS,
-	...SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP,
-	"EventTarget",
-	"XMLHttpRequest"
-]);
-const getDestructuredBindingDepth = (bindingIdentifier) => {
-	let bindingNode = bindingIdentifier;
-	let depth = 0;
-	while (true) {
-		if (isNodeOfType(bindingNode.parent, "AssignmentPattern") && bindingNode.parent.left === bindingNode) bindingNode = bindingNode.parent;
-		const property = bindingNode.parent;
-		if (!property || !isNodeOfType(property, "Property") || property.value !== bindingNode || !property.parent || !isNodeOfType(property.parent, "ObjectPattern")) return depth;
-		depth += 1;
-		bindingNode = property.parent;
-	}
-};
-const isMutatedMemberExpression = (rawMemberExpression) => {
-	let expression = findTransparentExpressionRoot(rawMemberExpression);
-	while (expression.parent) {
-		const parent = expression.parent;
-		if (isNodeOfType(parent, "MemberExpression") && parent.object === expression) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "Property") && parent.value === expression && isNodeOfType(parent.parent, "ObjectPattern")) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "ObjectPattern") && parent.properties.some((property) => property === expression)) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "ArrayPattern") && parent.elements.some((element) => element === expression)) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		if (isNodeOfType(parent, "RestElement") && parent.argument === expression || isNodeOfType(parent, "AssignmentPattern") && parent.left === expression) {
-			expression = findTransparentExpressionRoot(parent);
-			continue;
-		}
-		break;
-	}
-	const parent = expression.parent;
-	return Boolean(isNodeOfType(parent, "AssignmentExpression") && parent.left === expression || isNodeOfType(parent, "UpdateExpression") && parent.argument === expression || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === expression || (isNodeOfType(parent, "ForInStatement") || isNodeOfType(parent, "ForOfStatement")) && parent.left === expression);
-};
-const isReactHookDependencyArgument = (expression, scopes) => {
-	const call = expression.parent;
-	return Boolean(isNodeOfType(call, "CallExpression") && call.arguments[1] === expression && isReactApiCall(call, HOOKS_WITH_DEPS, scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true,
-		resolveNamedAliases: true
-	}));
-};
-const isPlainDependencyObjectExpression = (expression) => isNodeOfType(expression, "ObjectExpression") && expression.properties.every((property) => isNodeOfType(property, "Property") && property.kind === "init" && !property.computed && !property.method);
-const getContainingReactDependencyValue = (rawExpression, containerKind) => {
-	const expression = findTransparentExpressionRoot(rawExpression);
-	const parent = expression.parent;
-	if (isNodeOfType(parent, "ArrayExpression")) return {
-		expression: parent,
-		containerKind: "array"
-	};
-	if (containerKind === "array" && isNodeOfType(parent, "SpreadElement") && parent.argument === expression && isNodeOfType(parent.parent, "ArrayExpression")) return {
-		expression: parent.parent,
-		containerKind: "array"
-	};
-	if (isNodeOfType(parent, "Property") && (parent.value === expression || parent.shorthand && parent.key === expression) && parent.parent && isPlainDependencyObjectExpression(parent.parent)) return {
-		expression: parent.parent,
-		containerKind: "object"
-	};
-	return null;
-};
-const getFullArrayRestCopySymbol = (initializer, scopes) => {
-	const declaration = initializer.parent;
-	if (!isNodeOfType(declaration, "VariableDeclarator") || declaration.init !== initializer || !isNodeOfType(declaration.id, "ArrayPattern") || declaration.id.elements.length !== 1) return null;
-	const restElement = declaration.id.elements[0];
-	if (!isNodeOfType(restElement, "RestElement") || !isNodeOfType(restElement.argument, "Identifier")) return null;
-	const symbol = scopes.symbolFor(restElement.argument);
-	return symbol?.kind === "const" && symbol.declarationNode === declaration && symbol.references.every((reference) => reference.flag === "read") ? symbol : null;
-};
-const isReactDependencyArrayReference = (initialExpression, scopes) => {
-	const pendingPaths = [{
-		expression: initialExpression,
-		containerKind: null
-	}];
-	const visitedExpressions = /* @__PURE__ */ new Set();
-	let didFindReactDependencyArgument = false;
-	while (pendingPaths.length > 0) {
-		const pendingPath = pendingPaths.pop();
-		if (!pendingPath) continue;
-		const expression = findTransparentExpressionRoot(pendingPath.expression);
-		if (visitedExpressions.has(expression)) continue;
-		visitedExpressions.add(expression);
-		if (pendingPath.containerKind === "array" && isReactHookDependencyArgument(expression, scopes)) {
-			didFindReactDependencyArgument = true;
-			continue;
-		}
-		const containingValue = getContainingReactDependencyValue(expression, pendingPath.containerKind);
-		if (containingValue) {
-			pendingPaths.push(containingValue);
-			continue;
-		}
-		const declaration = expression.parent;
-		if (isNodeOfType(declaration, "VariableDeclarator") && declaration.init === expression && isNodeOfType(declaration.id, "Identifier")) {
-			const symbol = scopes.symbolFor(declaration.id);
-			if (!symbol || getDirectUnreassignedInitializer(symbol) !== expression) return false;
-			if (symbol.references.length === 0) return false;
-			for (const reference of symbol.references) pendingPaths.push({
-				expression: reference.identifier,
-				containerKind: pendingPath.containerKind
-			});
-			continue;
-		}
-		if (pendingPath.containerKind === "array") {
-			const restCopySymbol = getFullArrayRestCopySymbol(expression, scopes);
-			if (restCopySymbol) {
-				if (restCopySymbol.references.length === 0) return false;
-				for (const reference of restCopySymbol.references) pendingPaths.push({
-					expression: reference.identifier,
-					containerKind: "array"
-				});
-				continue;
-			}
-		}
-		return false;
-	}
-	return didFindReactDependencyArgument;
-};
-const hasSafeReceiverAliases = (rootSymbols, scopes) => {
-	const pendingSymbols = [...rootSymbols];
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	while (pendingSymbols.length > 0) {
-		const symbol = pendingSymbols.pop();
-		if (!symbol || visitedSymbolIds.has(symbol.id)) continue;
-		visitedSymbolIds.add(symbol.id);
-		for (const reference of symbol.references) {
-			const expression = findTransparentExpressionRoot(reference.identifier);
-			const container = expression.parent;
-			if (isReactDependencyArrayReference(expression, scopes)) continue;
-			if (isNodeOfType(container, "MemberExpression") && container.object === expression) {
-				if (isMutatedMemberExpression(container)) return false;
-				continue;
-			}
-			if (isNodeOfType(container, "CallExpression") && container.callee === expression) continue;
-			if (isNodeOfType(container, "VariableDeclarator") && container.init === expression && isNodeOfType(container.id, "ObjectPattern")) continue;
-			if (isNodeOfType(container, "AssignmentExpression") && container.right === expression && isNodeOfType(container.left, "ObjectPattern")) continue;
-			if (isNodeOfType(container, "VariableDeclarator") && container.init === expression && isNodeOfType(container.id, "Identifier")) {
-				const aliasSymbol = scopes.symbolFor(container.id);
-				const aliasInitializer = aliasSymbol && getDirectUnreassignedInitializer(aliasSymbol);
-				if (!aliasSymbol || aliasInitializer !== expression) return false;
-				pendingSymbols.push(aliasSymbol);
-				continue;
-			}
-			return false;
+const isFunctionShapedReturn = (returnedValue, setterToStateName, setterSymbolIdToStateName, scopes, isExplicitReturnStatement) => {
+	if (isNodeOfType(returnedValue, "ArrowFunctionExpression") || isNodeOfType(returnedValue, "FunctionExpression")) return true;
+	if (isNodeOfType(returnedValue, "CallExpression")) {
+		if (isNodeOfType(returnedValue.callee, "Identifier")) {
+			const setterSymbol = resolveConstIdentifierAlias(returnedValue.callee, scopes, true);
+			if (setterToStateName.has(returnedValue.callee.name) || setterSymbol && setterSymbolIdToStateName.has(setterSymbol.id)) return false;
+			if (isSetterIdentifier(returnedValue.callee.name)) return true;
 		}
+		return isCleanupReturn(returnedValue, EMPTY_CLEANUP_NAME_SET, EMPTY_CLEANUP_NAME_SET, { allowOpaqueReturn: isExplicitReturnStatement });
 	}
-	return true;
-};
-const hasProvenGlobalNamespaceReference = (expression, namespaceNames, scopes) => {
-	for (const namespaceName of namespaceNames) if (isProvenGlobalNamespaceReference(expression, namespaceName, scopes)) return true;
+	if (isNodeOfType(returnedValue, "Identifier")) return true;
 	return false;
 };
-const getTypeScriptImportEqualsSource = (symbol) => {
-	if (symbol.kind !== "ts-import-equals" || !isNodeOfType(symbol.declarationNode, "TSImportEqualsDeclaration")) return null;
-	const moduleReference = symbol.declarationNode.moduleReference;
-	if (!isNodeOfType(moduleReference, "TSExternalModuleReference") || !isNodeOfType(moduleReference.expression, "Literal")) return null;
-	return typeof moduleReference.expression.value === "string" ? moduleReference.expression.value : null;
-};
-const getUnshadowedRequireSource = (rawExpression, scopes) => {
-	let expression = stripParenExpression(rawExpression);
-	while (isNodeOfType(expression, "MemberExpression")) expression = stripParenExpression(expression.object);
-	if (!isNodeOfType(expression, "CallExpression") || !isNodeOfType(expression.callee, "Identifier") || expression.callee.name !== "require" || !scopes.isGlobalReference(expression.callee)) return null;
-	return getRequireCallSource(rawExpression);
-};
-const resolveExternalModuleBinding = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set(), ignoreCommonJsMutation = false) => {
-	let expression = stripParenExpression(rawExpression);
-	let outermostExportedName = null;
-	let exportedPropertyDepth = 0;
-	let resolvedBinding = null;
-	let isCommonJsModuleObject = false;
-	const traversedSymbolIds = new Set(visitedSymbolIds);
-	const commonJsModuleObjectSymbols = /* @__PURE__ */ new Set();
-	while (true) {
-		if (isNodeOfType(expression, "MemberExpression")) {
-			const propertyName = getStaticPropertyName(expression);
-			if (propertyName === null) return null;
-			outermostExportedName ??= propertyName;
-			exportedPropertyDepth += 1;
-			expression = stripParenExpression(expression.object);
-			continue;
-		}
-		const requireSource = getUnshadowedRequireSource(expression, scopes);
-		if (requireSource !== null) {
-			resolvedBinding = {
-				source: requireSource,
-				exportedName: null,
-				isModuleObject: true
-			};
-			isCommonJsModuleObject = true;
-			break;
-		}
-		if (!isNodeOfType(expression, "Identifier")) return null;
-		const symbol = scopes.symbolFor(expression);
-		if (!symbol || traversedSymbolIds.has(symbol.id)) return null;
-		if (symbol.kind === "import") {
-			const importDeclaration = symbol.declarationNode.parent;
-			if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration") || typeof importDeclaration.source.value !== "string") return null;
-			if (isNodeOfType(symbol.declarationNode, "ImportSpecifier")) resolvedBinding = {
-				source: importDeclaration.source.value,
-				exportedName: getImportedName(symbol.declarationNode) ?? null,
-				isModuleObject: false
-			};
-			else if (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier")) resolvedBinding = {
-				source: importDeclaration.source.value,
-				exportedName: "default",
-				isModuleObject: false
-			};
-			else if (isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")) resolvedBinding = {
-				source: importDeclaration.source.value,
-				exportedName: null,
-				isModuleObject: true
-			};
-			break;
-		}
-		const importEqualsSource = getTypeScriptImportEqualsSource(symbol);
-		if (importEqualsSource !== null) {
-			resolvedBinding = {
-				source: importEqualsSource,
-				exportedName: null,
-				isModuleObject: true
-			};
-			isCommonJsModuleObject = true;
-			commonJsModuleObjectSymbols.add(symbol);
-			break;
-		}
-		const directInitializer = getDirectUnreassignedInitializer(symbol);
-		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
-		const initializer = directInitializer ?? (destructuredPropertyName !== null && symbol.kind === "const" && isNodeOfType(symbol.declarationNode, "VariableDeclarator") ? symbol.declarationNode.init : null);
-		if (!initializer) return null;
-		traversedSymbolIds.add(symbol.id);
-		outermostExportedName ??= destructuredPropertyName;
-		if (destructuredPropertyName !== null) exportedPropertyDepth += getDestructuredBindingDepth(symbol.bindingIdentifier);
-		const unwrappedInitializer = stripParenExpression(initializer);
-		if (destructuredPropertyName === null && !isNodeOfType(unwrappedInitializer, "MemberExpression")) commonJsModuleObjectSymbols.add(symbol);
-		expression = unwrappedInitializer;
-	}
-	if (!resolvedBinding) return null;
-	if (!ignoreCommonJsMutation && isCommonJsModuleObject && !hasSafeReceiverAliases(commonJsModuleObjectSymbols, scopes)) return null;
-	if (outermostExportedName === null) return resolvedBinding;
-	if (!resolvedBinding.isModuleObject || exportedPropertyDepth !== 1) return null;
-	return {
-		source: resolvedBinding.source,
-		exportedName: outermostExportedName,
-		isModuleObject: false
-	};
-};
-const getCanonicalExternalSyncExportName = (binding) => {
-	if (binding.exportedName && binding.exportedName !== "default") return binding.exportedName;
-	return EXTERNAL_SYNC_DEFAULT_IMPORT_NAMES.get(binding.source) ?? null;
-};
-const isKnownExternalSyncDirectModuleBinding = (binding) => {
-	const exportedName = getCanonicalExternalSyncExportName(binding);
-	return Boolean(exportedName && EXTERNAL_SYNC_DIRECT_IMPORT_SOURCES.get(exportedName)?.has(binding.source));
-};
-const DEFINITELY_NON_FUNCTION_GLOBAL_CALL_NAMES = new Set([
-	"Array",
-	"BigInt",
-	"Boolean",
-	"Date",
-	"Number",
-	"String",
-	"Symbol"
-]);
-const DEFINITELY_NON_FUNCTION_GLOBAL_CONSTRUCTOR_NAMES = new Set([
-	"Array",
-	"Boolean",
-	"Date",
-	"Map",
-	"Number",
-	"Promise",
-	"RegExp",
-	"Set",
-	"String",
-	"URL",
-	"URLSearchParams",
-	"WeakMap",
-	"WeakSet"
-]);
-const PROMISE_STATIC_RESULT_METHOD_NAMES = new Set([
-	"all",
-	"allSettled",
-	"any",
-	"race",
-	"reject",
-	"resolve",
-	"withResolvers"
-]);
-const returnsOnlyNonCleanupValues = (functionNode, setterToStateName, scopes, visitedFunctions = /* @__PURE__ */ new Set()) => {
-	if (!isFunctionLike$1(functionNode) || functionNode.async || functionNode.generator || visitedFunctions.has(functionNode)) return false;
-	const nextVisitedFunctions = new Set(visitedFunctions).add(functionNode);
-	const isNonCleanupValue = (returnValue) => {
-		const expression = stripParenExpression(returnValue);
-		if (isNodeOfType(expression, "Identifier") && expression.name === "undefined" && scopes.isGlobalReference(expression)) return true;
-		if (isNodeOfType(expression, "Literal") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "JSXElement") || isNodeOfType(expression, "JSXFragment") || isNodeOfType(expression, "TemplateLiteral") || isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return true;
-		if (isNodeOfType(expression, "ConditionalExpression")) return isNonCleanupValue(expression.consequent) && isNonCleanupValue(expression.alternate);
-		if (isNodeOfType(expression, "LogicalExpression")) return isNonCleanupValue(expression.left) && isNonCleanupValue(expression.right);
-		if (isNodeOfType(expression, "SequenceExpression")) {
-			const finalExpression = expression.expressions.at(-1);
-			return Boolean(finalExpression && isNonCleanupValue(finalExpression));
-		}
-		if (isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && DEFINITELY_NON_FUNCTION_GLOBAL_CONSTRUCTOR_NAMES.has(expression.callee.name) && scopes.isGlobalReference(expression.callee)) return true;
-		if (!isNodeOfType(expression, "CallExpression")) return false;
-		if (isNodeOfType(expression.callee, "Identifier") && DEFINITELY_NON_FUNCTION_GLOBAL_CALL_NAMES.has(expression.callee.name) && scopes.isGlobalReference(expression.callee)) return true;
-		if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.object, "Identifier") && expression.callee.object.name === "Promise" && scopes.isGlobalReference(expression.callee.object) && PROMISE_STATIC_RESULT_METHOD_NAMES.has(getStaticPropertyName(expression.callee) ?? "")) return true;
-		if (isNodeOfType(expression.callee, "Identifier") && setterToStateName.has(expression.callee.name)) return true;
-		const invokedFunction = resolveSynchronouslyInvokedFunction(expression.callee, scopes);
-		return Boolean(invokedFunction && returnsOnlyNonCleanupValues(invokedFunction, setterToStateName, scopes, nextVisitedFunctions));
-	};
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isNonCleanupValue(functionNode.body);
-	let returnsOnlyNonCleanup = true;
-	walkAst(functionNode.body, (child) => {
-		if (!returnsOnlyNonCleanup) return false;
-		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "ReturnStatement")) return;
-		if (child.argument && !isNonCleanupValue(child.argument)) {
-			returnsOnlyNonCleanup = false;
-			return false;
-		}
-	});
-	return returnsOnlyNonCleanup;
-};
-const getResolvedFunctionCleanupReturnProof = (functionNode, scopes, visitedFunctions = /* @__PURE__ */ new Set()) => {
-	if (!isFunctionLike$1(functionNode) || functionNode.async || functionNode.generator || visitedFunctions.has(functionNode)) return {
-		hasCleanup: false,
-		isValid: false
-	};
-	const nextVisitedFunctions = new Set(visitedFunctions).add(functionNode);
-	const getCleanupReturnProof = (returnValue) => {
-		const expression = stripParenExpression(returnValue);
-		if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression")) return {
-			hasCleanup: true,
-			isValid: true
-		};
-		if (isNodeOfType(expression, "Identifier")) {
-			if (expression.name === "undefined" && scopes.isGlobalReference(expression)) return {
-				hasCleanup: false,
-				isValid: true
-			};
-			const localFunction = resolveExactLocalFunction(expression, scopes);
-			return {
-				hasCleanup: Boolean(localFunction),
-				isValid: Boolean(localFunction)
-			};
-		}
-		if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return {
-			hasCleanup: false,
-			isValid: true
-		};
-		if (isNodeOfType(expression, "ConditionalExpression")) {
-			const consequentProof = getCleanupReturnProof(expression.consequent);
-			const alternateProof = getCleanupReturnProof(expression.alternate);
-			return {
-				hasCleanup: consequentProof.hasCleanup || alternateProof.hasCleanup,
-				isValid: consequentProof.isValid && alternateProof.isValid
-			};
-		}
-		if (isNodeOfType(expression, "LogicalExpression")) {
-			const leftProof = getCleanupReturnProof(expression.left);
-			const rightProof = getCleanupReturnProof(expression.right);
-			return {
-				hasCleanup: leftProof.hasCleanup || rightProof.hasCleanup,
-				isValid: leftProof.isValid && rightProof.isValid
-			};
-		}
-		if (isNodeOfType(expression, "SequenceExpression")) {
-			const finalExpression = expression.expressions.at(-1);
-			return finalExpression ? getCleanupReturnProof(finalExpression) : {
-				hasCleanup: false,
-				isValid: false
-			};
-		}
-		if (!isNodeOfType(expression, "CallExpression")) return {
-			hasCleanup: false,
-			isValid: false
-		};
-		const invokedFunction = resolveSynchronouslyInvokedFunction(expression.callee, scopes);
-		return invokedFunction ? getResolvedFunctionCleanupReturnProof(invokedFunction, scopes, nextVisitedFunctions) : {
-			hasCleanup: false,
-			isValid: false
-		};
-	};
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) return getCleanupReturnProof(functionNode.body);
-	let cleanupReturnProof = {
-		hasCleanup: false,
-		isValid: true
-	};
-	walkAst(functionNode.body, (child) => {
-		if (!cleanupReturnProof.isValid) return false;
-		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
-		if (!isNodeOfType(child, "ReturnStatement")) return;
-		if (!child.argument) return;
-		const returnProof = getCleanupReturnProof(child.argument);
-		if (!returnProof.isValid) {
-			cleanupReturnProof = {
-				hasCleanup: false,
-				isValid: false
-			};
-			return false;
-		}
-		cleanupReturnProof.hasCleanup ||= returnProof.hasCleanup;
-	});
-	return cleanupReturnProof;
-};
-const isFunctionShapedReturn = (returnedValue, setterToStateName, setterSymbolIdToStateName, scopes, isExplicitReturnStatement) => {
-	const unwrappedReturnedValue = stripParenExpression(returnedValue);
-	if (isNodeOfType(unwrappedReturnedValue, "ArrowFunctionExpression") || isNodeOfType(unwrappedReturnedValue, "FunctionExpression")) return true;
-	if (isNodeOfType(unwrappedReturnedValue, "CallExpression")) {
-		if (isNodeOfType(unwrappedReturnedValue.callee, "Identifier")) {
-			const setterSymbol = resolveConstIdentifierAlias(unwrappedReturnedValue.callee, scopes, true);
-			if (setterToStateName.has(unwrappedReturnedValue.callee.name) || setterSymbol && setterSymbolIdToStateName.has(setterSymbol.id)) return false;
-		}
-		const invokedFunction = resolveSynchronouslyInvokedFunction(unwrappedReturnedValue.callee, scopes);
-		if (invokedFunction && returnsOnlyNonCleanupValues(invokedFunction, setterToStateName, scopes)) return false;
-		if (invokedFunction) {
-			const cleanupReturnProof = getResolvedFunctionCleanupReturnProof(invokedFunction, scopes);
-			if (cleanupReturnProof.isValid) return cleanupReturnProof.hasCleanup;
-		}
-		if (!invokedFunction && isNodeOfType(unwrappedReturnedValue.callee, "Identifier") && isSetterIdentifier(unwrappedReturnedValue.callee.name)) return true;
-		return isCleanupReturn(unwrappedReturnedValue, EMPTY_CLEANUP_NAME_SET, EMPTY_CLEANUP_NAME_SET, { allowOpaqueReturn: isExplicitReturnStatement });
-	}
-	if (isNodeOfType(unwrappedReturnedValue, "Identifier")) return true;
+const STORAGE_GLOBAL_NAMES = new Set(["localStorage", "sessionStorage"]);
+const isBrowserStorageReceiver = (receiver) => {
+	if (!receiver) return false;
+	if (isNodeOfType(receiver, "Identifier")) return STORAGE_GLOBAL_NAMES.has(receiver.name);
+	if (isNodeOfType(receiver, "MemberExpression")) return isNodeOfType(receiver.property, "Identifier") && STORAGE_GLOBAL_NAMES.has(receiver.property.name);
 	return false;
 };
-const STORAGE_GLOBAL_NAMES = ["localStorage", "sessionStorage"];
-const isBrowserStorageReceiver = (receiver, scopes) => Boolean(receiver && STORAGE_GLOBAL_NAMES.some((storageName) => isProvenGlobalNamespaceReference(receiver, storageName, scopes)));
 const STORAGE_HOOK_PATTERN = /^use\w*Storage/i;
 const collectStorageHookSetterNames = (componentBody) => {
 	const setterNames = /* @__PURE__ */ new Set();
@@ -39843,16 +38911,23 @@ const callsOpaqueExternalSetter = (analysisFunctions, setterToStateName) => {
 	});
 	return didFindOpaqueSetterCall;
 };
-const isReactUseRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && isReactApiCall(expression, "useRef", scopes, {
+const isReactRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && (isReactApiCall(expression, "useRef", scopes, {
 	allowGlobalReactNamespace: true,
 	allowUnboundBareCalls: true,
 	resolveNamedAliases: true
-});
-const isReactRefCall = (expression, scopes) => isReactUseRefCall(expression, scopes) || isNodeOfType(expression, "CallExpression") && isReactApiCall(expression, "createRef", scopes, {
+}) || isReactApiCall(expression, "createRef", scopes, {
 	allowGlobalReactNamespace: true,
 	allowUnboundBareCalls: true,
 	resolveNamedAliases: true
-});
+}));
+const getDirectReactRefSymbol = (rawExpression, scopes) => {
+	const expression = stripParenExpression(rawExpression);
+	if (!isNodeOfType(expression, "Identifier")) return null;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol) return null;
+	const initializer = getDirectUnreassignedInitializer(symbol);
+	return initializer && isReactRefCall(stripParenExpression(initializer), scopes) ? symbol : null;
+};
 const isReactNativeJsxElement = (openingElement, scopes) => {
 	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
 	const symbol = scopes.symbolFor(openingElement.name);
@@ -39860,33 +38935,19 @@ const isReactNativeJsxElement = (openingElement, scopes) => {
 	return Boolean(symbol?.kind === "import" && importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react-native");
 };
 const isDirectHostJsxRef = (symbol, scopes) => {
-	let didFindHostRef = false;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	const pendingSymbols = [symbol];
-	while (pendingSymbols.length > 0) {
-		const currentSymbol = pendingSymbols.pop();
-		if (!currentSymbol || visitedSymbolIds.has(currentSymbol.id)) continue;
-		visitedSymbolIds.add(currentSymbol.id);
-		for (const reference of currentSymbol.references) {
-			const expression = findTransparentExpressionRoot(reference.identifier);
-			const container = expression.parent;
-			if (isNodeOfType(container, "MemberExpression") && container.object === expression && getStaticPropertyName(container) === "current") continue;
-			if (isNodeOfType(container, "VariableDeclarator") && container.init === expression && isNodeOfType(container.id, "Identifier")) {
-				const aliasSymbol = scopes.symbolFor(container.id);
-				const aliasInitializer = aliasSymbol && getDirectUnreassignedInitializer(aliasSymbol);
-				if (!aliasSymbol || aliasInitializer !== expression) return false;
-				pendingSymbols.push(aliasSymbol);
-				continue;
-			}
-			if (!container || !isNodeOfType(container, "JSXExpressionContainer") || container.expression !== expression) return false;
-			const attribute = container.parent;
-			if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
-			const openingElement = attribute.parent;
-			if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement") || !isProvenIntrinsicJsxElement(openingElement, scopes) && !isReactNativeJsxElement(openingElement, scopes)) return false;
-			didFindHostRef = true;
-		}
-	}
-	return didFindHostRef;
+	let hostRefCount = 0;
+	for (const reference of symbol.references) {
+		const expression = findTransparentExpressionRoot(reference.identifier);
+		const container = expression.parent;
+		if (isNodeOfType(container, "MemberExpression") && container.object === expression && getStaticPropertyName(container) === "current") continue;
+		if (!container || !isNodeOfType(container, "JSXExpressionContainer") || container.expression !== expression) return false;
+		const attribute = container.parent;
+		if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
+		const openingElement = attribute.parent;
+		if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement") || !isProvenIntrinsicJsxElement(openingElement, scopes) && !isReactNativeJsxElement(openingElement, scopes)) return false;
+		hostRefCount += 1;
+	}
+	return hostRefCount > 0;
 };
 const isIntrinsicRefCallbackParameter = (expression, scopes) => {
 	const identifier = stripParenExpression(expression);
@@ -39896,18 +38957,7 @@ const isIntrinsicRefCallbackParameter = (expression, scopes) => {
 	const rawFirstParameter = callback.params?.[0];
 	const firstParameter = isNodeOfType(rawFirstParameter, "AssignmentPattern") ? rawFirstParameter.left : rawFirstParameter;
 	const symbol = scopes.symbolFor(identifier);
-	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter && symbol.references.every((reference) => {
-		if (reference.flag !== "read") return false;
-		let referenceRoot = reference.identifier;
-		while (referenceRoot.parent) {
-			const parent = referenceRoot.parent;
-			if (isNodeOfType(parent, "AssignmentExpression")) return parent.left !== referenceRoot;
-			if (isNodeOfType(parent, "UpdateExpression")) return parent.argument !== referenceRoot;
-			if (isNodeOfType(parent, "ForInStatement") || isNodeOfType(parent, "ForOfStatement")) return parent.left !== referenceRoot;
-			referenceRoot = parent;
-		}
-		return true;
-	}));
+	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter);
 };
 const getDirectReactRefCall = (symbol, scopes) => {
 	const initializer = getDirectUnreassignedInitializer(symbol);
@@ -39915,38 +38965,15 @@ const getDirectReactRefCall = (symbol, scopes) => {
 	const expression = stripParenExpression(initializer);
 	return isNodeOfType(expression, "CallExpression") && isReactRefCall(expression, scopes) ? expression : null;
 };
-const isEmptyGlobalMapConstruction = (rawExpression, scopes) => {
-	const expression = stripParenExpression(rawExpression);
-	return isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Map" && scopes.isGlobalReference(expression.callee) && expression.arguments.length === 0;
-};
-const hasEmptyRefSentinelInitializer = (refCall, scopes) => {
-	if (!isReactUseRefCall(refCall, scopes) || refCall.arguments.length > 1) return false;
-	const [initialValue] = refCall.arguments;
-	return !initialValue || isNodeOfType(initialValue, "Literal") && initialValue.value === null || isNodeOfType(initialValue, "Identifier") && initialValue.name === "undefined" && scopes.isGlobalReference(initialValue);
-};
-const isDirectLazyEmptyMapInitialization = (currentExpression, symbol, scopes) => {
-	const assignment = currentExpression.parent;
-	if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.left !== currentExpression || assignment.operator !== "??=" || !isEmptyGlobalMapConstruction(assignment.right, scopes)) return false;
-	const refOwner = findEnclosingFunction$1(symbol.bindingIdentifier);
-	return refOwner !== null && findEnclosingFunction$1(assignment) === refOwner;
-};
 const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
-	const refCall = getDirectReactRefCall(symbol, scopes);
-	const initialValue = refCall?.arguments[0];
-	const hasDirectEmptyMapInitializer = Boolean(initialValue && isEmptyGlobalMapConstruction(initialValue, scopes));
-	const hasLazyEmptyMapInitializer = Boolean(refCall && hasEmptyRefSentinelInitializer(refCall, scopes));
-	if (!hasDirectEmptyMapInitializer && !hasLazyEmptyMapInitializer) return false;
+	const initialValue = getDirectReactRefCall(symbol, scopes)?.arguments?.[0];
+	if (!initialValue || !isNodeOfType(initialValue, "NewExpression") || !isNodeOfType(initialValue.callee, "Identifier") || initialValue.callee.name !== "Map" || !scopes.isGlobalReference(initialValue.callee) || initialValue.arguments.length !== 0) return false;
 	let intrinsicValueWriteCount = 0;
-	let lazyEmptyMapInitializationCount = 0;
 	for (const reference of symbol.references) {
 		const identifier = findTransparentExpressionRoot(reference.identifier);
 		const currentMember = identifier.parent;
 		if (!isNodeOfType(currentMember, "MemberExpression") || currentMember.object !== identifier || getStaticPropertyName(currentMember) !== "current") return false;
 		const currentExpression = findTransparentExpressionRoot(currentMember);
-		if (hasLazyEmptyMapInitializer && isDirectLazyEmptyMapInitialization(currentExpression, symbol, scopes)) {
-			lazyEmptyMapInitializationCount += 1;
-			continue;
-		}
 		const methodMember = currentExpression.parent;
 		if (!isNodeOfType(methodMember, "MemberExpression") || methodMember.object !== currentExpression) return false;
 		const methodName = getStaticPropertyName(methodMember);
@@ -39959,7 +38986,7 @@ const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
 		if (!storedValue || isNodeOfType(storedValue, "SpreadElement") || !isIntrinsicRefCallbackParameter(storedValue, scopes)) return false;
 		intrinsicValueWriteCount += 1;
 	}
-	return intrinsicValueWriteCount > 0 && (hasDirectEmptyMapInitializer || lazyEmptyMapInitializationCount === 1);
+	return intrinsicValueWriteCount > 0;
 };
 const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollectionValue = false, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(rawExpression);
@@ -39973,11 +39000,7 @@ const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollecti
 	}
 	if (isNodeOfType(expression, "MemberExpression")) {
 		if (getStaticPropertyName(expression) === "current") {
-			const symbol = resolveReactRefSymbol(expression, scopes, {
-				allowUnboundBareCalls: true,
-				includeCreateRef: true,
-				resolveNamedAliases: true
-			});
+			const symbol = getDirectReactRefSymbol(expression.object, scopes);
 			return Boolean(symbol && (isDirectHostJsxRef(symbol, scopes) || didReadCollectionValue && storesOnlyIntrinsicRefCallbackValues(symbol, scopes)));
 		}
 		return isDerivedFromProvenDomRefCurrent(expression.object, scopes, didReadCollectionValue, visitedSymbolIds);
@@ -39995,80 +39018,19 @@ const isCommittedDomSyncNode = (node, scopes) => {
 	if (propertyName === null || !EXTERNAL_SYNC_DOM_MEMBER_METHOD_NAMES.has(propertyName)) return false;
 	return isDerivedFromProvenDomRefCurrent(callee.object, scopes) || isProvenBrowserApiReceiver(callee.object, "dom-event-target", scopes);
 };
-const isProvenHttpClientReceiver = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isNodeOfType(expression, "Identifier")) {
-		const receiverSymbol = scopes.symbolFor(expression);
-		if (receiverSymbol && !hasSafeReceiverAliases(new Set([receiverSymbol]), scopes)) return false;
-	}
-	if (hasProvenGlobalNamespaceReference(expression, EXTERNAL_SYNC_GLOBAL_HTTP_CLIENT_NAMES, scopes)) return true;
-	const moduleBinding = resolveExternalModuleBinding(expression, scopes);
-	if (moduleBinding && EXTERNAL_SYNC_HTTP_CLIENT_MODULE_SOURCES.has(moduleBinding.source) && (moduleBinding.isModuleObject || moduleBinding.exportedName === "default" && EXTERNAL_SYNC_DEFAULT_IMPORT_NAMES.has(moduleBinding.source) || isKnownExternalSyncDirectModuleBinding(moduleBinding))) return true;
-	if (isNodeOfType(expression, "CallExpression")) {
-		const callee = stripParenExpression(expression.callee);
-		return Boolean(isNodeOfType(callee, "MemberExpression") && getStaticPropertyName(callee) === "create" && isProvenHttpClientReceiver(callee.object, scopes, visitedSymbolIds));
-	}
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	if (resolveExternalModuleBinding(expression, scopes, /* @__PURE__ */ new Set(), true)) return false;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	return Boolean(initializer && isProvenHttpClientReceiver(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id)));
-};
-const isProvenTanStackQueryClientReceiver = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isNodeOfType(expression, "Identifier")) {
-		const receiverSymbol = scopes.symbolFor(expression);
-		if (receiverSymbol && !hasSafeReceiverAliases(new Set([receiverSymbol]), scopes)) return false;
-	}
-	if (isNodeOfType(expression, "CallExpression")) {
-		const binding = resolveExternalModuleBinding(expression.callee, scopes);
-		return Boolean(binding && binding.source === "@tanstack/react-query" && binding.exportedName === "useQueryClient");
-	}
-	if (isNodeOfType(expression, "NewExpression")) {
-		const binding = resolveExternalModuleBinding(expression.callee, scopes);
-		return Boolean(binding && TANSTACK_QUERY_CLIENT_MODULE_SOURCES.has(binding.source) && binding.exportedName === "QueryClient");
-	}
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	return Boolean(initializer && isProvenTanStackQueryClientReceiver(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id)));
-};
-const isProvenExternalResourceReceiver = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isDerivedFromProvenDomRefCurrent(expression, scopes) || isProvenBrowserApiReceiver(expression, "dom-event-target", scopes) || isProvenBrowserApiReceiver(expression, "xml-http-request", scopes) || isProvenHttpClientReceiver(expression, scopes)) return true;
-	if (isNodeOfType(expression, "NewExpression")) return hasProvenGlobalNamespaceReference(expression.callee, EXTERNAL_SYNC_RESOURCE_CONSTRUCTOR_NAMES, scopes);
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	return Boolean(initializer && isProvenExternalResourceReceiver(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id)));
-};
-const isProvenExternalSyncDirectCallee = (callee, scopes) => {
-	if (hasProvenGlobalNamespaceReference(callee, EXTERNAL_SYNC_DIRECT_CALLEE_NAMES, scopes)) return true;
-	const moduleBinding = resolveExternalModuleBinding(callee, scopes);
-	return Boolean(moduleBinding && isKnownExternalSyncDirectModuleBinding(moduleBinding));
-};
-const isExternalSyncNode = (node, scopes) => {
-	if (isNodeOfType(node, "NewExpression")) return hasProvenGlobalNamespaceReference(node.callee, EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS, scopes);
-	if (isNodeOfType(node, "AssignmentExpression") || isNodeOfType(node, "UpdateExpression")) {
-		const mutationTarget = isNodeOfType(node, "AssignmentExpression") ? node.left : node.argument;
-		return isNodeOfType(mutationTarget, "MemberExpression") && getStaticPropertyName(mutationTarget) === "current" && Boolean(resolveReactRefSymbol(mutationTarget, scopes, {
-			allowUnboundBareCalls: true,
-			includeCreateRef: true,
-			resolveNamedAliases: true
-		}));
-	}
+const isExternalSyncNode = (node) => {
+	if (isNodeOfType(node, "NewExpression")) return isNodeOfType(node.callee, "Identifier") && EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS.has(node.callee.name);
+	if (isNodeOfType(node, "AssignmentExpression")) return isNodeOfType(node.left, "MemberExpression") && isNodeOfType(node.left.property, "Identifier") && node.left.property.name === "current";
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	if (isProvenExternalSyncDirectCallee(node.callee, scopes)) return true;
+	if (isNodeOfType(node.callee, "Identifier")) return EXTERNAL_SYNC_DIRECT_CALLEE_NAMES.has(node.callee.name);
 	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
 	const propertyName = getStaticPropertyName(node.callee);
 	if (propertyName === null) return false;
-	if (isBrowserStorageReceiver(node.callee.object, scopes)) return true;
-	if (TANSTACK_QUERY_EXTERNAL_SYNC_METHOD_NAMES.has(propertyName)) return isProvenTanStackQueryClientReceiver(node.callee.object, scopes);
-	if (EXTERNAL_SYNC_HTTP_METHOD_NAMES.has(propertyName)) return isProvenHttpClientReceiver(node.callee.object, scopes);
-	return EXTERNAL_SYNC_MEMBER_METHOD_NAMES.has(propertyName) && isProvenExternalResourceReceiver(node.callee.object, scopes);
+	if (EXTERNAL_SYNC_MEMBER_METHOD_NAMES.has(propertyName)) return true;
+	if (isBrowserStorageReceiver(node.callee.object)) return true;
+	if (!EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES.has(propertyName)) return false;
+	const receiverRootName = getRootIdentifierName(node.callee.object);
+	return receiverRootName !== null && EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS.has(receiverRootName);
 };
 const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, setterSymbolIdToStateName, scopes, allowCommittedDomSync) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
@@ -40077,7 +39039,7 @@ const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateNa
 	} else for (const statement of effectCallback.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument && isFunctionShapedReturn(statement.argument, setterToStateName, setterSymbolIdToStateName, scopes, true)) return true;
 	let didFindExternalCall = false;
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
-		if (isExternalSyncNode(child, scopes) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
+		if (isExternalSyncNode(child) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
 	});
 	return didFindExternalCall;
 };
@@ -40099,11 +39061,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);
@@ -40116,11 +39078,10 @@ const noEffectChain = defineRule({
 				const callback = getEffectCallback(effectCall, context.scopes);
 				if (!callback || !isFunctionLike$1(callback) || callback.async) continue;
 				const analysisFunctions = collectSynchronouslyInvokedFunctions(callback, context.scopes);
-				const stateWrites = collectStateWritesInEffect(collectStateWriteAnalysisFunctions(callback, context.scopes, setterSymbolIdToStateName), setterSymbolIdToStateName, context.scopes);
+				const stateWrites = collectStateWritesInEffect(analysisFunctions, setterSymbolIdToStateName, context.scopes);
 				const writtenStateNames = new Set(stateWrites.keys());
 				effectInfos.push({
 					node: effectCall,
-					callback,
 					dependencyStateSymbolIds: collectDependencyStateSymbolIds(effectCall, stateSymbolIdSet, context.scopes),
 					stateWrites,
 					analysisFunctions,
@@ -40137,10 +39098,10 @@ const noEffectChain = defineRule({
 					if (readerEffect.isExternalSync) continue;
 					if (readerEffect.dependencyStateSymbolIds.size === 0) continue;
 					let chainedStateName = null;
-					for (const writtenName of writerEffect.stateWrites.keys()) {
+					for (const [writtenName, writeInfo] of writerEffect.stateWrites) {
 						const writtenStateSymbolId = stateSymbolIds.get(writtenName);
 						if (writtenStateSymbolId === void 0 || !readerEffect.dependencyStateSymbolIds.has(writtenStateSymbolId)) continue;
-						if (!canStateWriteReachReaderWork(writtenName, writerEffect, readerEffect, stateSymbolIds, context.scopes)) continue;
+						if (!canStateWriteReachReaderWork(writeInfo, readerEffect, stateSymbolIds.get(writtenName) ?? null, context.scopes)) continue;
 						chainedStateName = writtenName;
 						break;
 					}
@@ -40529,7 +39490,7 @@ const noEffectEventInDeps = defineRule({
 	title: "Effect Event listed in effect deps",
 	tags: ["test-noise"],
 	severity: "error",
-	recommendation: "Call the useEffectEvent function inside the effect body and don't list it in the deps. It's non-reactive on purpose, so it must be omitted.",
+	recommendation: "Call the useEffectEvent function inside the effect body and don't list it in the deps. It changes on every render on purpose.",
 	create: (context) => {
 		const componentBindings = createComponentBindingStackTracker({ onVariableDeclarator: (declaratorNode) => {
 			if (!isNodeOfType(declaratorNode, "VariableDeclarator")) return;
@@ -40551,7 +39512,7 @@ const noEffectEventInDeps = defineRule({
 					if (!isNodeOfType(element, "Identifier")) continue;
 					if (componentBindings.isBoundName(element.name)) context.report({
 						node: element,
-						message: `Listing "${element.name}" in the deps defeats useEffectEvent — Effect Events are non-reactive and must be omitted from deps.`
+						message: `Listing "${element.name}" in the deps re-runs your effect every render & defeats useEffectEvent.`
 					});
 				}
 			}
@@ -40594,7 +39555,6 @@ const noEffectWithFreshDeps = defineRule({
 	title: "Effect dependency recreated every render",
 	severity: "error",
 	category: "State & Effects",
-	disabledWhen: ["react-compiler"],
 	recommendation: "Move the value inside the hook body and depend on its simple inputs instead, or wrap it in useMemo / useCallback so it stays the same between renders.",
 	create: (context) => ({ CallExpression(node) {
 		for (const finding of findForwardedFreshHookDependencies(node, context, EFFECT_HOOK_NAMES$1)) context.report({
@@ -43535,13 +42495,14 @@ const noInlineExhaustiveStyle = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/performance/no-inline-prop-on-memo-component.ts
-const MEMO_CALLEE_NAMES = new Set(["memo", "React.memo"]);
-const isMemoCall = (node) => isNodeOfType(node, "CallExpression") && MEMO_CALLEE_NAMES.has(flattenCalleeName(node.callee) ?? "");
-const hasCustomComparator = (node, scopes) => {
+const isMemoCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	const comparator = node.arguments?.[1];
-	return comparator ? !isIdentitySensitiveMemoComparator(comparator, scopes) : false;
+	if (isNodeOfType(node.callee, "Identifier") && node.callee.name === "memo") return true;
+	if (isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && node.callee.object.name === "React" && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "memo") return true;
+	return false;
 };
+const isDefaultEquivalentComparator = (comparator) => isNodeOfType(comparator, "Identifier") && (comparator.name === "undefined" || comparator.name === "shallowEqual");
+const hasCustomComparator = (node) => isNodeOfType(node, "CallExpression") && (node.arguments?.length ?? 0) >= 2 && !isDefaultEquivalentComparator(node.arguments?.[1]);
 const isInlineReference = (node, scopes) => {
 	const referenceNode = unwrapObjectIntegrityExpression(node, scopes);
 	if (isNodeOfType(referenceNode, "ArrowFunctionExpression") || isNodeOfType(referenceNode, "FunctionExpression") || isNodeOfType(referenceNode, "CallExpression") && isNodeOfType(referenceNode.callee, "MemberExpression") && isNodeOfType(referenceNode.callee.property, "Identifier") && referenceNode.callee.property.name === "bind") return "functions";
@@ -43555,17 +42516,16 @@ const noInlinePropOnMemoComponent = defineRule({
 	title: "Inline prop defeats memo()",
 	tags: ["test-noise"],
 	severity: "warn",
-	disabledWhen: ["react-compiler"],
 	recommendation: "Move the inline `() => ...` / `[]` / `{}` to a stable value with useMemo, useCallback, or module scope, so the memoized child stops redrawing on every parent render",
 	create: (context) => {
 		const memoizedComponentNames = /* @__PURE__ */ new Set();
 		return {
 			VariableDeclarator(node) {
 				if (!isNodeOfType(node.id, "Identifier") || !node.init) return;
-				if (isMemoCall(node.init) && !hasCustomComparator(node.init, context.scopes)) memoizedComponentNames.add(node.id.name);
+				if (isMemoCall(node.init) && !hasCustomComparator(node.init)) memoizedComponentNames.add(node.id.name);
 			},
 			ExportDefaultDeclaration(node) {
-				if (node.declaration && isNodeOfType(node.declaration, "CallExpression") && isMemoCall(node.declaration) && !hasCustomComparator(node.declaration, context.scopes)) {
+				if (node.declaration && isNodeOfType(node.declaration, "CallExpression") && isMemoCall(node.declaration) && !hasCustomComparator(node.declaration)) {
 					const innerArgument = node.declaration.arguments?.[0];
 					if (isNodeOfType(innerArgument, "Identifier")) memoizedComponentNames.add(innerArgument.name);
 				}
@@ -44925,6 +43885,16 @@ const noManyBooleanProps = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-global-match-media-call.ts
+const isGlobalMatchMediaCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (isNodeOfType(callee, "Identifier")) return callee.name === "matchMedia" && scopes.isGlobalReference(callee);
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "matchMedia") return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && (receiver.name === "window" || receiver.name === "globalThis") && scopes.isGlobalReference(receiver);
+};
+//#endregion
 //#region src/plugin/rules/performance/no-match-media-in-state-initializer.ts
 const REACT_USE_STATE_OPTIONS = {
 	allowGlobalReactNamespace: true,
@@ -56410,7 +55380,6 @@ const preferModuleScopePureFunction = defineRule({
 	tags: ["test-noise"],
 	severity: "warn",
 	category: "Architecture",
-	disabledWhen: ["react-compiler"],
 	recommendation: "Move the function above the component, at the top of the file. It doesn't use local state, so rebuilding it each update is wasted work.",
 	create: (context) => {
 		const report = (functionNode, name, componentName) => {
@@ -56450,6 +55419,17 @@ const preferModuleScopePureFunction = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-require-call-source.ts
+const getRequireCallSource = (expression) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return getRequireCallSource(unwrappedExpression.object);
+	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
+	if (!isNodeOfType(unwrappedExpression.callee, "Identifier") || unwrappedExpression.callee.name !== "require") return null;
+	const [firstArgument] = unwrappedExpression.arguments ?? [];
+	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
+	return typeof firstArgument.value === "string" ? firstArgument.value : null;
+};
+//#endregion
 //#region src/plugin/utils/is-proven-node-crypto-namespace-reference.ts
 const NODE_CRYPTO_MODULE_SOURCES = new Set(["crypto", "node:crypto"]);
 const isProvenNodeCryptoNamespaceReference = (expression, scopes) => {
@@ -57041,10 +56021,10 @@ const classifyCallableReadsInsideEffect = (callableIdentifier, effectCallback, c
 const preferUseEffectEvent = defineRule({
 	id: "prefer-use-effect-event",
 	title: "Effect re-subscribes on a changing callback",
-	requires: ["react:19.2"],
+	requires: ["react:19"],
 	tags: ["test-noise"],
 	severity: "warn",
-	recommendation: "Wrap the callback with `useEffectEvent(callback)` (React 19.2+) and call it inside the sub-handler. An Effect Event always sees the latest props and state but isn't a dependency, so the effect won't re-subscribe every time the parent redraws. See https://react.dev/reference/react/useEffectEvent",
+	recommendation: "Wrap the callback with `useEffectEvent(callback)` (React 19+) and call it inside the sub-handler. An Effect Event always sees the latest props and state but isn't a dependency, so the effect won't re-subscribe every time the parent redraws. See https://react.dev/reference/react/useEffectEvent",
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
@@ -58649,6 +57629,7 @@ const reduxUseselectorInlineDerivation = defineRule({
 	title: "useSelector derives data inline",
 	severity: "warn",
 	category: "Performance",
+	disabledWhen: ["react-compiler"],
 	recommendation: "Select the raw slice and memoize derivation so Redux actions do not rebuild a collection and redraw this component.",
 	create: (context) => {
 		let aliases = /* @__PURE__ */ new Set();
@@ -58708,6 +57689,7 @@ const reduxUseselectorReturnsNewCollection = defineRule({
 	title: "useSelector returns a new collection",
 	severity: "warn",
 	category: "Performance",
+	disabledWhen: ["react-compiler"],
 	recommendation: "Return a stable selected value, split selectors, or pass `shallowEqual` so every Redux action does not redraw this component.",
 	create: (context) => {
 		let aliases = /* @__PURE__ */ new Set();
@@ -58833,7 +57815,6 @@ const renderingHoistJsx = defineRule({
 	title: "Constant JSX rebuilt each render",
 	tags: ["test-noise"],
 	severity: "warn",
-	disabledWhen: ["react-compiler"],
 	recommendation: "Move the static JSX out to the top of the file: `const ICON = <svg>...</svg>`, so it isn't rebuilt on every render",
 	create: (context) => {
 		let componentDepth = 0;
@@ -59280,9 +58261,8 @@ const renderingHydrationNoFlicker = defineRule({
 	id: "rendering-hydration-no-flicker",
 	title: "useEffect setState flashes on mount",
 	tags: ["test-noise"],
-	requires: ["ssr"],
 	severity: "warn",
-	recommendation: "Read the value with `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)` inside a reusable hook, or add `suppressHydrationWarning` to the element",
+	recommendation: "Use `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)` or add `suppressHydrationWarning` to the element",
 	create: (context) => ({ CallExpression(node) {
 		if (!isHookCall$2(node, USE_EFFECT_ONLY) || (node.arguments?.length ?? 0) < 2) return;
 		const depsNode = node.arguments[1];
@@ -59735,7 +58715,7 @@ const renderingUsetransitionLoading = defineRule({
 	title: "Loading useState forces extra render",
 	tags: ["test-noise"],
 	severity: "warn",
-	recommendation: "Replace with `const [isPending, startTransition] = useTransition()`, which marks the update as non-urgent and interruptible so the input stays responsive",
+	recommendation: "Replace with `const [isPending, startTransition] = useTransition()`, which skips the extra render for the loading flag",
 	create: (context) => ({ VariableDeclarator(node) {
 		if (!isNodeOfType(node.id, "ArrayPattern") || !node.id.elements?.length) return;
 		if (!node.init || !isHookCall$2(node.init, "useState")) return;
@@ -59767,7 +58747,7 @@ const renderingUsetransitionLoading = defineRule({
 		}
 		context.report({
 			node: node.init,
-			message: `This makes the "${stateVariableName}" update urgent and blocking because it's a plain useState flag, so if it's a state change & not a data fetch, use useTransition to keep the UI responsive while it runs`
+			message: `This adds an extra render because useState for "${stateVariableName}" re-renders just for the loading flag, so if it's a state change & not a data fetch, use useTransition instead`
 		});
 	} })
 });
@@ -60082,7 +59062,6 @@ const rerenderDependencies = defineRule({
 	title: "Unstable value recreated every render",
 	tags: ["test-noise"],
 	severity: "error",
-	disabledWhen: ["react-compiler"],
 	recommendation: "Move it into a useMemo, useRef, or a constant outside the component so it stays the same between renders.",
 	create: (context) => ({ CallExpression(node) {
 		if (!isReactHookCall(node, HOOKS_WITH_DEPS, context.scopes) || node.arguments.length < 2) return;
@@ -60495,7 +59474,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 	title: "useMemo before an early return",
 	tags: ["test-noise"],
 	severity: "warn",
-	recommendation: "Move the JSX into a child component rendered after the early return, so renders that take the early return never build it",
+	recommendation: "Move the JSX into a child component wrapped in memo, so the parent's early return skips it",
 	create: (context) => {
 		const inspectFunctionBody = (statements) => {
 			let memoNode = null;
@@ -60521,7 +59500,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 					if (callbackGuardTests.some((guardTest) => areConditionsStructurallyEqual(stmt.test, guardTest))) continue;
 					context.report({
 						node: memoNode,
-						message: "This rebuilds the JSX whenever its dependencies change even on renders that take the early return, so move the JSX into a child component rendered after the early return to skip it"
+						message: "This runs even when the component bails out because the useMemo builds JSX before an early return, so move the JSX into a child wrapped in memo to skip it on the early return"
 					});
 					return;
 				}
@@ -61024,7 +60003,6 @@ const rerenderMemoWithDefaultValue = defineRule({
 	title: "Empty default prop breaks memo",
 	tags: ["test-noise"],
 	severity: "warn",
-	disabledWhen: ["react-compiler"],
 	recommendation: "Move it to the top of the file: `const EMPTY_ITEMS: Item[] = []`, then use that as the default value",
 	create: (context) => {
 		let memoRegistry = /* @__PURE__ */ new Map();
@@ -61850,7 +60828,6 @@ const rnListDataMapped = defineRule({
 	title: "List data rebuilt every render",
 	tags: ["test-noise"],
 	requires: ["react-native"],
-	disabledWhen: ["react-compiler"],
 	severity: "warn",
 	recommendation: "This builds a new array each time the parent redraws, so every row redraws too. Wrap it in `useMemo(() => items.map(...), [items])` to keep the same array.",
 	create: (context) => ({ JSXOpeningElement(node) {
@@ -64204,66 +63181,6 @@ const roleHasRequiredAriaProps = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/constants/global-aria-properties.ts
-const GLOBAL_ARIA_PROPERTIES = new Set([
-	"aria-atomic",
-	"aria-braillelabel",
-	"aria-brailleroledescription",
-	"aria-busy",
-	"aria-controls",
-	"aria-current",
-	"aria-describedby",
-	"aria-description",
-	"aria-details",
-	"aria-disabled",
-	"aria-dropeffect",
-	"aria-errormessage",
-	"aria-flowto",
-	"aria-grabbed",
-	"aria-haspopup",
-	"aria-hidden",
-	"aria-invalid",
-	"aria-keyshortcuts",
-	"aria-label",
-	"aria-labelledby",
-	"aria-live",
-	"aria-owns",
-	"aria-relevant",
-	"aria-roledescription"
-]);
-//#endregion
-//#region src/plugin/constants/prohibited-aria-properties-by-role.ts
-const ACCESSIBLE_NAME_PROPERTIES = new Set([
-	"aria-braillelabel",
-	"aria-label",
-	"aria-labelledby"
-]);
-const PROHIBITED_ARIA_PROPERTIES_BY_ROLE = {
-	caption: ACCESSIBLE_NAME_PROPERTIES,
-	code: ACCESSIBLE_NAME_PROPERTIES,
-	definition: ACCESSIBLE_NAME_PROPERTIES,
-	deletion: ACCESSIBLE_NAME_PROPERTIES,
-	emphasis: ACCESSIBLE_NAME_PROPERTIES,
-	generic: new Set([
-		"aria-braillelabel",
-		"aria-brailleroledescription",
-		"aria-label",
-		"aria-labelledby",
-		"aria-roledescription"
-	]),
-	insertion: ACCESSIBLE_NAME_PROPERTIES,
-	mark: ACCESSIBLE_NAME_PROPERTIES,
-	none: ACCESSIBLE_NAME_PROPERTIES,
-	paragraph: ACCESSIBLE_NAME_PROPERTIES,
-	presentation: ACCESSIBLE_NAME_PROPERTIES,
-	strong: ACCESSIBLE_NAME_PROPERTIES,
-	subscript: ACCESSIBLE_NAME_PROPERTIES,
-	superscript: ACCESSIBLE_NAME_PROPERTIES,
-	term: ACCESSIBLE_NAME_PROPERTIES,
-	time: ACCESSIBLE_NAME_PROPERTIES,
-	tooltip: ACCESSIBLE_NAME_PROPERTIES
-};
-//#endregion
 //#region src/plugin/constants/role-supports-aria-props.ts
 const ROLE_SUPPORTS_ARIA_PROPS = {
 	alert: new Set([
@@ -67364,12 +66281,6 @@ const ROLE_SUPPORTS_ARIA_PROPS = {
 	])
 };
 //#endregion
-//#region src/plugin/utils/is-aria-property-supported-by-role.ts
-const isAriaPropertySupportedByRole = (role, property) => {
-	if (PROHIBITED_ARIA_PROPERTIES_BY_ROLE[role]?.has(property)) return false;
-	return ROLE_SUPPORTS_ARIA_PROPS[role]?.has(property) === true || GLOBAL_ARIA_PROPERTIES.has(property);
-};
-//#endregion
 //#region src/plugin/rules/a11y/role-supports-aria-props.ts
 const buildMessageDefault = (roles, propName) => {
 	return `Screen reader users get no help from \`${propName}\` because role ${roles.map((role) => `\`${role}\``).join(" / ")} ignores it, so remove it or change the role.`;
@@ -67406,10 +66317,16 @@ const roleSupportsAriaProps = defineRule({
 		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 		const roleCandidates = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : [getImplicitRole(node, elementType, context.scopes)].filter((role) => role !== null);
 		if (roleCandidates === null || roleCandidates.length === 0) return;
-		for (const role of roleCandidates) if (!VALID_ARIA_ROLES.has(role)) return;
+		const supportedSets = [];
+		for (const role of roleCandidates) {
+			if (!VALID_ARIA_ROLES.has(role)) return;
+			const supported = ROLE_SUPPORTS_ARIA_PROPS[role];
+			if (!supported) return;
+			supportedSets.push(supported);
+		}
 		const isImplicit = !roleAttribute;
 		for (const { attribute, propName } of ariaAttributes) {
-			if (roleCandidates.some((role) => isAriaPropertySupportedByRole(role, propName))) continue;
+			if (supportedSets.some((supported) => supported.has(propName))) continue;
 			context.report({
 				node: attribute,
 				message: isImplicit ? buildMessageImplicit(roleCandidates[0], propName, elementType) : buildMessageDefault(roleCandidates, propName)
@@ -76191,7 +75108,7 @@ const EXTERNAL_RULES = [
 	{
 		key: "react-hooks-js/set-state-in-effect",
 		source: "react-compiler",
-		severity: "warn"
+		severity: "error"
 	},
 	{
 		key: "react-hooks-js/globals",