oxlint-plugin-react-doctor 0.8.1-dev.7818922 → 0.8.1-dev.7c9dbed

package/dist/index.js

@@ -762,7 +762,7 @@ const EXTERNAL_SYNC_MEMBER_METHOD_NAMES = new Set([
 	"put",
 	"patch"
 ]);
-const EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS = new Set([
+new Set([
 	...FETCH_MEMBER_OBJECTS,
 	"api",
 	"client",
@@ -2622,7 +2622,7 @@ const PREFER_ALT = "Screen readers skip a decorative image more reliably with `a
 const MESSAGE_OBJECT = "Screen reader users cannot use this `<object>` because assistive tech cannot describe it, so add `alt`, `aria-label`, `aria-labelledby`, `title`, or inner fallback text.";
 const MESSAGE_AREA = "Blind users can't use this `<area>` of the image map because screen readers can't describe it, so add `alt`, `aria-label`, or `aria-labelledby`.";
 const MESSAGE_INPUT_IMAGE = "Blind users can't use this image button because screen readers can't describe it, so add `alt`, `aria-label`, or `aria-labelledby`.";
-const resolveSettings$53 = (settings) => {
+const resolveSettings$52 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.altText ?? {} : {};
 };
@@ -2745,7 +2745,7 @@ const altText = defineRule({
 	category: "Accessibility",
 	create: (context) => {
 		if (isGeneratedImageRenderContext(context)) return {};
-		const settings = resolveSettings$53(context.settings);
+		const settings = resolveSettings$52(context.settings);
 		const checkImg = !settings.elements || settings.elements.includes("img");
 		const checkObject = !settings.elements || settings.elements.includes("object");
 		const checkArea = !settings.elements || settings.elements.includes("area");
@@ -2807,7 +2807,7 @@ const DEFAULT_AMBIGUOUS = [
 	"a link",
 	"learn more"
 ];
-const resolveSettings$52 = (settings) => {
+const resolveSettings$51 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { words: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.anchorAmbiguousText ?? {} : {}).words ?? DEFAULT_AMBIGUOUS };
 };
@@ -2857,7 +2857,7 @@ const anchorAmbiguousText = defineRule({
 	category: "Accessibility",
 	create: (context) => {
 		if (isTestlikeFilename(context.filename)) return {};
-		const settings = resolveSettings$52(context.settings);
+		const settings = resolveSettings$51(context.settings);
 		const ambiguousSet = new Set(settings.words.map((word) => word.toLowerCase()));
 		return { JSXElement(node) {
 			if (getElementType(node.openingElement, context.settings) !== "a") return;
@@ -3225,7 +3225,7 @@ const anchorHasContent = defineRule({
 const MESSAGE_MISSING_HREF = "Keyboard users can't reach this link because it has no `href`, so add a real `href` (or use `<button>` for actions).";
 const MESSAGE_INCORRECT_HREF = "Keyboard users can't reach this link because its `href` goes nowhere (`#`, `javascript:`, or empty), so point it at a real destination.";
 const MESSAGE_CANT_BE_ANCHOR = "Keyboard users can't trigger this link because it's a click handler with no real `href`, so use `<button>` instead.";
-const resolveSettings$51 = (settings) => {
+const resolveSettings$50 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.anchorIsValid ?? {} : {};
 	const jsxA11y = settings?.["jsx-a11y"];
@@ -3268,7 +3268,7 @@ const anchorIsValid = defineRule({
 	recommendation: "Give links a real destination. Use `<button>` for in-page actions.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$51(context.settings);
+		const settings = resolveSettings$50(context.settings);
 		const fileHasJsxA11ySettings = hasJsxA11ySettings(context.settings);
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return { JSXOpeningElement(node) {
@@ -4181,7 +4181,7 @@ const ariaProptypes = defineRule({
 //#endregion
 //#region src/plugin/rules/a11y/aria-role.ts
 const buildBaseMessage = (suffix) => `This \`role\` is not a valid ARIA role, so assistive tech cannot expose it correctly. Use a real, non-abstract role.${suffix}`;
-const resolveSettings$50 = (settings) => {
+const resolveSettings$49 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.ariaRole ?? {} : {};
 	return {
@@ -4197,7 +4197,7 @@ const ariaRole = defineRule({
 	recommendation: "Use a real, non-abstract ARIA role so assistive tech can expose the element correctly.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$50(context.settings);
+		const settings = resolveSettings$49(context.settings);
 		return { JSXOpeningElement(node) {
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 			if (!roleAttribute) return;
@@ -7115,7 +7115,7 @@ const FORM_CONTROL_TAGS = new Set([
 	"select",
 	"form"
 ]);
-const resolveSettings$49 = (settings) => {
+const resolveSettings$48 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.autocompleteValid ?? {} : {};
 	return { inputComponents: new Set(ruleSettings.inputComponents ?? []) };
@@ -7128,7 +7128,7 @@ const autocompleteValid = defineRule({
 	recommendation: "Use a valid autofill token in `autoComplete` so browsers can fill the right field reliably.",
 	category: "Accessibility",
 	create: skipNonProductionFiles((context) => {
-		const settings = resolveSettings$49(context.settings);
+		const settings = resolveSettings$48(context.settings);
 		return { JSXOpeningElement: (node) => {
 			const tag = getElementType(node, context.settings);
 			if (!FORM_CONTROL_TAGS.has(tag) && !settings.inputComponents.has(tag)) return;
@@ -7247,7 +7247,7 @@ const isCreateElementCall = (node) => {
 //#region src/plugin/rules/react-builtins/button-has-type.ts
 const MISSING_MESSAGE$2 = "Your users can submit the form by accident because a `<button>` with no `type` defaults to submit.";
 const INVALID_MESSAGE = "This button has an invalid `type`, so the browser may treat it like a submit button.";
-const resolveSettings$48 = (settings) => {
+const resolveSettings$47 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.buttonHasType ?? {} : {};
 	return {
@@ -7485,7 +7485,7 @@ const buttonHasType = defineRule({
 	severity: "warn",
 	recommendation: "Set an explicit button `type` so plain buttons do not submit forms by accident: `type=\"button\"`, `\"submit\"`, or `\"reset\"`.",
 	create: (context) => {
-		const settings = resolveSettings$48(context.settings);
+		const settings = resolveSettings$47(context.settings);
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return {
 			JSXOpeningElement(node) {
@@ -7566,7 +7566,7 @@ const buttonHasType = defineRule({
 //#region src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.ts
 const MISSING_MESSAGE$1 = "Your users can't toggle this input because `checked` has no `onChange`.";
 const EXCLUSIVE_MESSAGE = "This input mixes `checked` with `defaultChecked`, so React can't tell whether it is controlled or uncontrolled.";
-const resolveSettings$47 = (settings) => {
+const resolveSettings$46 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.checkedRequiresOnchangeOrReadonly ?? {} : {};
 	return {
@@ -7667,7 +7667,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 	recommendation: "Add `onChange`, `readOnly`, or `defaultChecked` so React knows whether the checkbox is editable, display-only, or uncontrolled.",
 	category: "Correctness",
 	create: (context) => {
-		const settings = resolveSettings$47(context.settings);
+		const settings = resolveSettings$46(context.settings);
 		const reportFromPresence = (presence) => {
 			if (presence.checkedNode && presence.defaultCheckedNode && !presence.bothCheckedAndDefaultForwarded && !settings.ignoreExclusiveCheckedAttribute) context.report({
 				node: presence.checkedNode,
@@ -9008,6 +9008,16 @@ const hasVisibleBindingNamed = (node, bindingName, scopes) => {
 	}
 };
 //#endregion
+//#region src/plugin/utils/is-global-match-media-call.ts
+const isGlobalMatchMediaCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (isNodeOfType(callee, "Identifier")) return callee.name === "matchMedia" && scopes.isGlobalReference(callee);
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "matchMedia") return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && (receiver.name === "window" || receiver.name === "globalThis") && scopes.isGlobalReference(receiver);
+};
+//#endregion
 //#region src/plugin/utils/is-proven-browser-api-receiver.ts
 const DOM_EVENT_TARGET_TYPE_NAMES = new Set([
 	"AbortSignal",
@@ -9154,8 +9164,10 @@ const getProvenDomEventTargetPrototypeOwnerNames = (rawExpression, scopes, visit
 		if (memberName === "body" || memberName === "documentElement") return getDomPrototypeOwnerNamesForType("HTMLElement");
 	}
 	if (isNodeOfType(expression, "CallExpression")) {
+		if (isGlobalMatchMediaCall(expression, scopes)) return getDomPrototypeOwnerNamesForType("MediaQueryList");
 		const callee = stripParenExpression(expression.callee);
 		const methodName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : null;
+		if (methodName === "matchMedia" && isNodeOfType(callee, "MemberExpression") && getProvenDomEventTargetPrototypeOwnerNames(callee.object, scopes, visitedSymbolIds).includes("Window")) return getDomPrototypeOwnerNamesForType("MediaQueryList");
 		if (methodName === "createElement") return getDomPrototypeOwnerNamesForType("HTMLElement");
 		if (methodName === "createElementNS") return getDomPrototypeOwnerNamesForType("SVGElement");
 		if (methodName && DOM_EVENT_TARGET_FACTORY_METHOD_NAMES.has(methodName)) return getDomPrototypeOwnerNamesForType("Element");
@@ -10368,7 +10380,7 @@ const WRAPPER_LABEL_PROP = "label";
 const SELECT_ELEMENT = "select";
 const DEFAULT_DEPTH = 5;
 const MAX_DEPTH = 25;
-const resolveSettings$46 = (settings) => {
+const resolveSettings$45 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.controlHasAssociatedLabel ?? {} : {};
 	return {
@@ -10701,7 +10713,7 @@ const controlHasAssociatedLabel = defineRule({
 	recommendation: "Give every interactive control a label screen readers can read.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$46(context.settings);
+		const settings = resolveSettings$45(context.settings);
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		const iconComponentNames = /* @__PURE__ */ new Set();
 		const iconNamespaceNames = /* @__PURE__ */ new Set();
@@ -12653,7 +12665,7 @@ const DEFAULT_ADDITIONAL_HOCS = [
 	"lazy",
 	"withTracking"
 ];
-const resolveSettings$45 = (settings) => {
+const resolveSettings$44 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.displayName ?? {} : {};
 	const additionalHoCs = new Set(ruleSettings.additionalHoCs ?? DEFAULT_ADDITIONAL_HOCS);
@@ -12835,7 +12847,7 @@ const displayName = defineRule({
 	recommendation: "Give each component a `displayName` so DevTools shows a clear name.",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$45(context.settings);
+		const settings = resolveSettings$44(context.settings);
 		const ignoreNamed = !settings.ignoreTranspilerName;
 		const reportAt = (node) => {
 			context.report({
@@ -13815,6 +13827,116 @@ const findRenderPhaseComponentOrHook = (node, scopes) => {
 	return null;
 };
 //#endregion
+//#region src/plugin/utils/get-final-sequence-expression-value.ts
+const getFinalSequenceExpressionValue = (expression) => {
+	let finalExpression = stripParenExpression(expression);
+	while (isNodeOfType(finalExpression, "SequenceExpression")) {
+		const sequenceResult = finalExpression.expressions.at(-1);
+		if (!sequenceResult) break;
+		finalExpression = stripParenExpression(sequenceResult);
+	}
+	return finalExpression;
+};
+//#endregion
+//#region src/plugin/utils/collect-expression-path-coverage-nodes.ts
+const collectExpressionPathCoverageNodes = (owner, matchingNodes, context, expressionBoundary = owner) => {
+	const coverageNodes = /* @__PURE__ */ new Set();
+	const pendingNodes = matchingNodes.filter((matchingNode) => {
+		if (context.cfg.enclosingFunction(matchingNode) !== owner) return false;
+		let currentNode = matchingNode;
+		while (currentNode && currentNode !== expressionBoundary) currentNode = currentNode.parent ?? null;
+		return currentNode === expressionBoundary;
+	});
+	const visitedNodes = new Set(pendingNodes);
+	const coveredBranchesByConditional = /* @__PURE__ */ new Map();
+	while (pendingNodes.length > 0) {
+		const coverageCandidate = pendingNodes.pop();
+		if (!coverageCandidate) break;
+		if (coverageCandidate === expressionBoundary) {
+			coverageNodes.add(coverageCandidate);
+			continue;
+		}
+		let currentChild = coverageCandidate;
+		let currentParent = currentChild.parent ?? null;
+		let conditionalExpression = null;
+		let conditionalBranch = null;
+		let isBlockedByNonExhaustiveExpression = false;
+		while (currentParent && currentParent !== expressionBoundary) {
+			if (isNodeOfType(currentParent, "ConditionalExpression")) {
+				const isConsequent = currentParent.consequent === currentChild;
+				const isAlternate = currentParent.alternate === currentChild;
+				if (isConsequent || isAlternate) {
+					const staticTestValue = readStaticBoolean(getFinalSequenceExpressionValue(currentParent.test));
+					if (staticTestValue !== null) {
+						if (staticTestValue !== isConsequent) {
+							isBlockedByNonExhaustiveExpression = true;
+							break;
+						}
+						currentChild = currentParent;
+						currentParent = currentChild.parent ?? null;
+						continue;
+					}
+					conditionalExpression = currentParent;
+					conditionalBranch = isConsequent ? "consequent" : "alternate";
+					break;
+				}
+			}
+			if (isNodeOfType(currentParent, "LogicalExpression") && currentParent.right === currentChild) {
+				const staticLeftValue = readStaticBoolean(getFinalSequenceExpressionValue(currentParent.left));
+				if (!(currentParent.operator === "&&" && staticLeftValue === true || currentParent.operator === "||" && staticLeftValue === false)) {
+					isBlockedByNonExhaustiveExpression = true;
+					break;
+				}
+			}
+			if (isNodeOfType(currentParent, "AssignmentPattern") && currentParent.right === currentChild) {
+				isBlockedByNonExhaustiveExpression = true;
+				break;
+			}
+			currentChild = currentParent;
+			currentParent = currentChild.parent ?? null;
+		}
+		if (isBlockedByNonExhaustiveExpression) continue;
+		if (!conditionalExpression || !conditionalBranch) {
+			coverageNodes.add(coverageCandidate);
+			continue;
+		}
+		const coveredBranches = coveredBranchesByConditional.get(conditionalExpression) ?? /* @__PURE__ */ new Set();
+		coveredBranches.add(conditionalBranch);
+		coveredBranchesByConditional.set(conditionalExpression, coveredBranches);
+		if (coveredBranches.has("alternate") && coveredBranches.has("consequent") && !visitedNodes.has(conditionalExpression)) {
+			visitedNodes.add(conditionalExpression);
+			pendingNodes.push(conditionalExpression);
+		}
+	}
+	return coverageNodes;
+};
+//#endregion
+//#region src/plugin/utils/do-nodes-cover-every-path-from-function-entry.ts
+const doNodesCoverEveryPathFromFunctionEntry = (owner, matchingNodes, context, options = {}) => {
+	const functionCfg = context.cfg.cfgFor(owner);
+	if (!functionCfg) return false;
+	const matchingBlocks = new Set([...collectExpressionPathCoverageNodes(owner, matchingNodes, context)].flatMap((matchingNode) => {
+		const matchingBlock = functionCfg.blockOf(matchingNode);
+		return matchingBlock ? [matchingBlock] : [];
+	}));
+	if (matchingBlocks.size === 0) return false;
+	const visitedBlocks = new Set([functionCfg.entry]);
+	const pendingBlocks = [functionCfg.entry];
+	while (pendingBlocks.length > 0) {
+		const currentBlock = pendingBlocks.pop();
+		if (!currentBlock) break;
+		if (matchingBlocks.has(currentBlock)) continue;
+		for (const edge of currentBlock.successors) {
+			if (options.ignoreThrowEdges && edge.kind === "throw") continue;
+			if (edge.to === functionCfg.exit) return false;
+			if (visitedBlocks.has(edge.to)) continue;
+			visitedBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return true;
+};
+//#endregion
 //#region src/plugin/utils/get-function-binding-name.ts
 const getFunctionBindingIdentifier$1 = (functionNode) => {
 	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
@@ -13852,14 +13974,19 @@ const isAstDescendant = (inner, outer) => {
 };
 //#endregion
 //#region src/plugin/utils/react-ref-origin.ts
-const resolveReactRefSymbol = (memberExpression, scopes) => {
+const REACT_REF_API_NAMES = new Set(["createRef", "useRef"]);
+const resolveReactRefSymbol = (memberExpression, scopes, options = {}) => {
 	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
 	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticPropertyName(memberExpression) !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
 	const symbol = resolveConstIdentifierAlias(receiver, scopes);
 	if (!symbol?.initializer) return null;
 	const initializer = stripParenExpression(symbol.initializer);
 	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
+	return isReactApiCall(initializer, options.includeCreateRef ? REACT_REF_API_NAMES : "useRef", scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: options.allowUnboundBareCalls,
+		resolveNamedAliases: options.resolveNamedAliases
+	}) ? symbol : null;
 };
 const resolveReactRefCurrentOriginSymbol = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(node);
@@ -13958,9 +14085,35 @@ const isNodeReachableWithinFunction = (node, context) => {
 	return false;
 };
 //#endregion
+//#region src/plugin/utils/is-within-assignment-target.ts
+const isWithinAssignmentTarget = (identifier) => {
+	let currentNode = identifier;
+	let parentNode = currentNode.parent;
+	while (parentNode) {
+		if (isNodeOfType(parentNode, "AssignmentExpression")) return parentNode.left === currentNode;
+		if (isNodeOfType(parentNode, "UpdateExpression") || isNodeOfType(parentNode, "UnaryExpression") && parentNode.operator === "delete") return parentNode.argument === currentNode;
+		if (isNodeOfType(parentNode, "ForInStatement") || isNodeOfType(parentNode, "ForOfStatement")) return parentNode.left === currentNode;
+		currentNode = parentNode;
+		parentNode = currentNode.parent;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
 const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
 const REPLAYABLE_ITERATOR_COLLECTION_CACHE = /* @__PURE__ */ new WeakMap();
+const REPLAY_ENTRY_DROPPING_ARRAY_METHOD_NAMES = new Set([
+	"pop",
+	"shift",
+	"splice",
+	"fill",
+	"copyWithin"
+]);
+const REPLAY_ENTRY_DROPPING_COLLECTION_METHOD_NAMES = new Set([
+	"clear",
+	"delete",
+	"set"
+]);
 const REACT_REF_EFFECT_ANALYSIS_CACHE = /* @__PURE__ */ new WeakMap();
 const RESOURCE_NOUN_BY_KIND = {
 	subscribe: "subscription",
@@ -13994,13 +14147,111 @@ const resolveExpressionKey = (expression, context, visitedSymbolIds = /* @__PURE
 		return objectKey ? `${objectKey}.${unwrappedExpression.property.name}` : null;
 	}
 	if (isNodeOfType(unwrappedExpression, "ThisExpression")) return "this";
-	if (isNodeOfType(unwrappedExpression, "Literal") && (typeof unwrappedExpression.value === "string" || typeof unwrappedExpression.value === "number")) return `literal:${String(unwrappedExpression.value)}`;
+	if (isNodeOfType(unwrappedExpression, "Literal") && (typeof unwrappedExpression.value === "string" || typeof unwrappedExpression.value === "number" || typeof unwrappedExpression.value === "boolean")) return `literal:${String(unwrappedExpression.value)}`;
 	if (isFunctionLike$1(unwrappedExpression)) {
 		const rangeStart = getRangeStart(unwrappedExpression);
 		return rangeStart === null ? null : `function:${rangeStart}`;
 	}
 	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 assignmentPattern = isNodeOfType(symbol.bindingIdentifier.parent, "AssignmentPattern") && symbol.bindingIdentifier.parent.left === symbol.bindingIdentifier ? symbol.bindingIdentifier.parent : null;
+	const propertyName = isNodeOfType(firstParameter, "ObjectPattern") ? getDestructuredBindingPropertyName(symbol.bindingIdentifier) : null;
+	const defaultValueKey = assignmentPattern ? resolveExpressionKey(assignmentPattern.right, context) : null;
+	if (assignmentPattern && !defaultValueKey) return null;
+	const parameterProjection = firstParameter === symbol.bindingIdentifier ? "value" : propertyName && defaultValueKey ? `${propertyName}=default:${defaultValueKey}` : 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 resolveEventListenerCaptureValueIdentityKey = (expression, context) => {
+	if (!expression) return null;
+	const directIdentityKey = resolveResourceIdentityKey(expression, context);
+	if (directIdentityKey) return directIdentityKey;
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "BinaryExpression") && !isNodeOfType(unwrappedExpression, "LogicalExpression")) return null;
+	const leftIdentityKey = resolveEventListenerCaptureValueIdentityKey(unwrappedExpression.left, context);
+	const rightIdentityKey = resolveEventListenerCaptureValueIdentityKey(unwrappedExpression.right, context);
+	return leftIdentityKey && rightIdentityKey ? `${unwrappedExpression.type}:${unwrappedExpression.operator}:${leftIdentityKey}:${rightIdentityKey}` : null;
+};
+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 ? resolveEventListenerCaptureValueIdentityKey(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 = resolveEventListenerCaptureValueIdentityKey(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;
@@ -14012,6 +14263,30 @@ const findAssignedResourceKey = (resourceNode, context) => {
 	if (isNodeOfType(parentNode, "AssignmentExpression") && parentNode.right === currentNode) return resolveExpressionKey(parentNode.left, context);
 	return null;
 };
+const resolveStableMediaQueryListenerIdentityKey = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!expression) return null;
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = context.scopes.symbolFor(unwrappedExpression);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || !symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier))) return null;
+		const initializer = getDirectUnreassignedInitializer(symbol);
+		if (!initializer) return `symbol:${symbol.id}`;
+		const unwrappedInitializer = stripParenExpression(initializer);
+		if (!isNodeOfType(unwrappedInitializer, "Identifier")) return `symbol:${symbol.id}`;
+		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+		nextVisitedSymbolIds.add(symbol.id);
+		return resolveStableMediaQueryListenerIdentityKey(unwrappedInitializer, context, nextVisitedSymbolIds) ?? `symbol:${symbol.id}`;
+	}
+	if (isFunctionLike$1(unwrappedExpression)) {
+		const rangeStart = getRangeStart(unwrappedExpression);
+		return rangeStart === null ? null : `function:${rangeStart}`;
+	}
+	return null;
+};
+const isProvenLegacyMediaQueryListMethodCall = (callNode, methodName, context) => {
+	const callee = stripParenExpression(callNode.callee);
+	return callNode.arguments?.length === 1 && isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName && getProvenDomEventTargetPrototypeOwnerNames(callee.object, context.scopes).includes("MediaQueryList");
+};
 const getCallRegistrationDetails = (callNode, context) => {
 	const callee = stripParenExpression(callNode.callee);
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier")) return {
@@ -14020,11 +14295,17 @@ 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: resolveExpressionKey(callee.object, context),
+		receiverKey: resolveResourceIdentityKey(callee.object, context),
 		registrationVerbName: callee.property.name,
-		eventKey: resolveExpressionKey(callNode.arguments?.[0], context),
-		handlerKey: resolveExpressionKey(callNode.arguments?.[1], context)
+		eventKey: resolveResourceIdentityKey(callNode.arguments?.[0], context),
+		handlerKey: resolveResourceIdentityKey(callNode.arguments?.[1], context)
 	};
 };
 const findSubscribeLikeUsages = (callback, context) => {
@@ -14124,30 +14405,6 @@ const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, conte
 	}
 	return matchingBlocks.size > 0;
 };
-const doMatchingNodesCoverEveryPathFromFunctionEntry = (owner, matchingNodes, context) => {
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return false;
-	const matchingBlocks = new Set(matchingNodes.flatMap((matchingNode) => {
-		if (context.cfg.enclosingFunction(matchingNode) !== owner) return [];
-		const matchingBlock = functionCfg.blockOf(matchingNode);
-		return matchingBlock ? [matchingBlock] : [];
-	}));
-	if (matchingBlocks.size === 0) return false;
-	const visitedBlocks = new Set([functionCfg.entry]);
-	const pendingBlocks = [functionCfg.entry];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		if (matchingBlocks.has(currentBlock)) continue;
-		for (const edge of currentBlock.successors) {
-			if (edge.to === functionCfg.exit) return false;
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return true;
-};
 const removeSynchronouslyReleasedUsages = (callback, usages, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
@@ -14390,18 +14647,6 @@ const findPushedResourceCollectionKey = (usage, context) => {
 		return memberNode.property.name === "forEach" || memberNode.property.name === "push";
 	}) ? resolveExpressionKey(pushCallee.object, context) : null;
 };
-const isWithinAssignmentTarget = (identifier) => {
-	let currentNode = identifier;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "AssignmentExpression")) return parentNode.left === currentNode;
-		if (isNodeOfType(parentNode, "UpdateExpression") || isNodeOfType(parentNode, "UnaryExpression") && parentNode.operator === "delete") return parentNode.argument === currentNode;
-		if (isNodeOfType(parentNode, "ForInStatement") || isNodeOfType(parentNode, "ForOfStatement")) return parentNode.left === currentNode;
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
 const resolveStableValue = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	if (!expression) return null;
 	const unwrappedExpression = stripParenExpression(expression);
@@ -14449,8 +14694,8 @@ const isSynchronousIteratorCallback = (functionNode) => {
 	return SYNCHRONOUS_ITERATOR_METHOD_NAMES$2.has(callee.property.name) && callNode.arguments?.[0] === functionNode;
 };
 const findEnclosingForEachCall = (node) => {
-	const callbackNode = findEnclosingFunction$1(node);
-	if (!callbackNode) return null;
+	const callbackNode = isFunctionLike$1(node) ? node : findEnclosingFunction$1(node);
+	if (!callbackNode || !isFunctionLike$1(callbackNode) || callbackNode.async || callbackNode.generator) return null;
 	const callNode = callbackNode.parent;
 	if (!isNodeOfType(callNode, "CallExpression") || callNode.arguments?.[0] !== callbackNode) return null;
 	const callee = stripParenExpression(callNode.callee);
@@ -14525,7 +14770,7 @@ const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visite
 		const helperFunction = isNodeOfType(stableHelperFunction, "Identifier") ? resolveSingleAssignedCleanupFunction(stableHelperFunction, usage, context) : stableHelperFunction;
 		if (helperFunction && isFunctionLike$1(helperFunction) && !helperFunction.async && !helperFunction.generator && doesCleanupFunctionReleaseUsage(helperFunction, usage, context, new Set(visitedFunctions))) matchingLoopOrHelperAnchors.push(cleanupCall);
 	});
-	return didCleanupFunctionMatch || doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, matchingLoopOrHelperAnchors, context);
+	return didCleanupFunctionMatch || doNodesCoverEveryPathFromFunctionEntry(cleanupFunction, matchingLoopOrHelperAnchors, context);
 };
 const doesBoundCleanupReleaseUsage = (expression, usage, context) => {
 	const callExpression = stripParenExpression(expression);
@@ -14554,7 +14799,7 @@ const callbackReturnsCleanupForUsage = (callback, usage, context) => {
 	walkInsideStatementBlocks(callback.body, (child) => {
 		if (isNodeOfType(child, "ReturnStatement") && child.argument && doesReturnedValueReleaseUsage(stripParenExpression(child.argument))) matchingCleanupReturns.push(child);
 	});
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
+	return doNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
 };
 const doesTestRequireLiveExpressionKey = (test, expressionKey, context) => {
 	if (resolveExpressionKey(test, context) === expressionKey) return true;
@@ -14578,7 +14823,24 @@ const findLiveExpressionGuardForRelease = (releaseCall, owner, expressionKey, co
 	return null;
 };
 const findDirectHandleGuardForRelease = (releaseCall, owner, usage, context) => usage.handleKey === null ? null : findLiveExpressionGuardForRelease(releaseCall, owner, usage.handleKey, context);
-const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
+const hasExecutionBoundaryNotSharedWithUsage = (node, usageNode, owner) => {
+	const usageAncestors = /* @__PURE__ */ new Set();
+	let usageAncestor = usageNode;
+	while (usageAncestor && usageAncestor !== owner) {
+		usageAncestors.add(usageAncestor);
+		usageAncestor = usageAncestor.parent ?? null;
+	}
+	let descendant = node;
+	let ancestor = descendant.parent ?? null;
+	while (ancestor && ancestor !== owner) {
+		const guardedSubtree = isNodeOfType(ancestor, "IfStatement") && (ancestor.consequent === descendant || ancestor.alternate === descendant) || isNodeOfType(ancestor, "ConditionalExpression") && (ancestor.consequent === descendant || ancestor.alternate === descendant) || isNodeOfType(ancestor, "LogicalExpression") && ancestor.right === descendant || isNodeOfType(ancestor, "AssignmentPattern") && ancestor.right === descendant || (isNodeOfType(ancestor, "ForStatement") || isNodeOfType(ancestor, "ForInStatement") || isNodeOfType(ancestor, "ForOfStatement") || isNodeOfType(ancestor, "WhileStatement") || isNodeOfType(ancestor, "DoWhileStatement")) && ancestor.body === descendant ? descendant : isNodeOfType(ancestor, "SwitchCase") ? ancestor : null;
+		if (guardedSubtree && !usageAncestors.has(guardedSubtree)) return true;
+		descendant = ancestor;
+		ancestor = descendant.parent ?? null;
+	}
+	return false;
+};
+const hasRerunReleaseBeforeUsage = (callback, usage, context, allowUnreleasedPathsWithoutUsage = false) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") || !isNodeOfType(callback.body, "BlockStatement")) return false;
 	const functionCfg = context.cfg.cfgFor(callback);
 	const usageBlock = functionCfg?.blockOf(usage.node);
@@ -14589,7 +14851,8 @@ const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const releaseStart = getRangeStart(child);
 		const handleGuard = findDirectHandleGuardForRelease(child, callback, usage, context);
-		if (releaseStart === null || releaseStart >= usageStart || functionCfg.blockOf(child) !== usageBlock && !handleGuard) return;
+		const releaseBlock = functionCfg.blockOf(child);
+		if (releaseStart === null || releaseStart >= usageStart || releaseBlock !== usageBlock && !handleGuard || !handleGuard && hasExecutionBoundaryNotSharedWithUsage(child, usage.node, callback)) return;
 		if (doesReleaseCallMatchUsage(child, usage, context)) {
 			matchingReleaseAnchors.push(handleGuard ?? child);
 			return;
@@ -14597,7 +14860,7 @@ const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 		const helperFunction = resolveStableValue(child.callee, context);
 		if (helperFunction && isFunctionLike$1(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context)) matchingReleaseAnchors.push(handleGuard ?? child);
 	});
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
+	return allowUnreleasedPathsWithoutUsage ? doMatchingNodesCoverEveryPathBeforeUsage(usage.node, matchingReleaseAnchors, callback, context) : doNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
 };
 const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	const componentFunction = findEnclosingFunction$1(callback);
@@ -14617,7 +14880,7 @@ const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	});
 	return didFindUnmountCleanup;
 };
-const hasSplitLifecycleCleanup = (callback, usage, context) => usage.handleKey !== null && hasRerunReleaseBeforeUsage(callback, usage, context) && hasStableUnmountCleanupForUsage(callback, usage, context);
+const hasSplitLifecycleCleanup = (callback, usage, context) => usage.handleKey !== null && hasStableUnmountCleanupForUsage(callback, usage, context) && hasRerunReleaseBeforeUsage(callback, usage, context, usage.registrationVerbName === "setTimeout");
 const collectBlockingBooleanStates = (expression, blockedExpressionValue, guardNode, context) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return collectBlockingBooleanStates(unwrappedExpression.argument, !blockedExpressionValue, guardNode, context);
@@ -14848,7 +15111,7 @@ const hasGuardedRefOwnedNestedCleanup = (callback, usage, cleanupReturns, contex
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	const usageExpression = findTransparentExpressionRoot(usage.node);
 	const usageAssignment = usageExpression.parent;
-	if (usage.kind !== "subscribe" && usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !resolveReactRefSymbol(stripParenExpression(usageAssignment.left), context.scopes) || !collectSynchronouslyEffectInvokedFunctions(callback).has(usageFunction) || !cleanupReturnsReleaseUsage(cleanupReturns, usage, context) || !doMatchingNodesCoverEveryPathFromFunctionEntry(callback, cleanupReturns, context)) return false;
+	if (usage.kind !== "subscribe" && usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !resolveReactRefSymbol(stripParenExpression(usageAssignment.left), context.scopes) || !collectSynchronouslyEffectInvokedFunctions(callback).has(usageFunction) || !cleanupReturnsReleaseUsage(cleanupReturns, usage, context) || !doNodesCoverEveryPathFromFunctionEntry(callback, cleanupReturns, context)) return false;
 	const cleanupFunctions = cleanupReturns.flatMap((cleanupReturn) => {
 		if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return [];
 		const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
@@ -14896,7 +15159,7 @@ const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) =>
 				});
 			}
 		});
-		if (!doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, globalReleaseProofs.map((releaseProof) => releaseProof.anchor), context)) return false;
+		if (!doNodesCoverEveryPathFromFunctionEntry(cleanupFunction, globalReleaseProofs.map((releaseProof) => releaseProof.anchor), context)) return false;
 		globalReleaseProofsByCleanup.set(cleanupFunction, globalReleaseProofs);
 	}
 	const handleAssignments = handleSymbol.references.filter((reference) => isWithinAssignmentTarget(reference.identifier));
@@ -15099,9 +15362,7 @@ 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;
-	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;
+	if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], releaseCall.arguments?.[2], context)) return false;
 	const releaseStart = getRangeStart(releaseCall);
 	const matchingOwnershipAssignments = [];
 	const usageFunctionBody = usageFunction.body;
@@ -15111,7 +15372,127 @@ const isReactRefListenerReplacementRelease = (releaseCall, usage, context) => {
 	});
 	const releaseAnchor = findLiveExpressionGuardForRelease(releaseCall, usageFunction, releaseReceiverKey, context) ?? releaseCall;
 	const safeOwnershipAssignments = matchingOwnershipAssignments.filter((assignment) => doMatchingNodesCoverEveryPathBeforeUsage(assignment, [releaseAnchor], usageFunction, context));
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
+	return doNodesCoverEveryPathFromFunctionEntry(usageFunction, [releaseAnchor], context) && doMatchingNodesCoverEveryPathBeforeUsage(usage.node, safeOwnershipAssignments, usageFunction, context);
+};
+const findDirectExhaustiveForEachCleanupFunction = (releaseNode, requiredCollectionKeys, context) => {
+	let currentNode = findTransparentExpressionRoot(releaseNode);
+	const visitedFunctions = /* @__PURE__ */ new Set();
+	const replayedCollectionKeys = /* @__PURE__ */ new Set();
+	while (true) {
+		const ownerFunction = findEnclosingFunction$1(currentNode);
+		if (!ownerFunction || !isFunctionLike$1(ownerFunction) || visitedFunctions.has(ownerFunction)) return null;
+		visitedFunctions.add(ownerFunction);
+		const isDirectConciseBody = ownerFunction.body === currentNode;
+		const statementNode = currentNode.parent;
+		const isDirectBlockStatement = isNodeOfType(ownerFunction.body, "BlockStatement") && isNodeOfType(statementNode, "ExpressionStatement") && statementNode.parent === ownerFunction.body;
+		if (!isDirectConciseBody && !isDirectBlockStatement || !doNodesCoverEveryPathFromFunctionEntry(ownerFunction, [isDirectBlockStatement ? statementNode : currentNode], context)) return null;
+		const forEachCall = findEnclosingForEachCall(ownerFunction);
+		if (!forEachCall) return replayedCollectionKeys.size === requiredCollectionKeys.size && isReturnedEffectCleanupFunction(ownerFunction, context) ? ownerFunction : null;
+		const forEachCallee = stripParenExpression(forEachCall.callee);
+		if (!isNodeOfType(forEachCallee, "MemberExpression")) return null;
+		const collectionKey = resolveExpressionKey(forEachCallee.object, context);
+		if (!collectionKey || !requiredCollectionKeys.has(collectionKey)) return null;
+		replayedCollectionKeys.add(collectionKey);
+		currentNode = findTransparentExpressionRoot(forEachCall);
+	}
+};
+const collectReplayOwnerFunctions = (usageNode) => {
+	const ownerFunctions = /* @__PURE__ */ new Set();
+	let currentNode = usageNode;
+	while (true) {
+		const ownerFunction = findEnclosingFunction$1(currentNode);
+		if (!ownerFunction || !isFunctionLike$1(ownerFunction) || ownerFunctions.has(ownerFunction)) break;
+		ownerFunctions.add(ownerFunction);
+		const forEachCall = findEnclosingForEachCall(ownerFunction);
+		if (!forEachCall) break;
+		currentNode = forEachCall;
+	}
+	return ownerFunctions;
+};
+const hasCollectionMutationBeforeRelease = (usageNode, releaseNode, collectionKeys, context) => {
+	const usageStart = getRangeStart(usageNode);
+	const releaseStart = getRangeStart(releaseNode);
+	if (usageStart === null || releaseStart === null) return true;
+	const setupOwnerFunctions = collectReplayOwnerFunctions(usageNode);
+	const cleanupOwnerFunctions = collectReplayOwnerFunctions(releaseNode);
+	let programNode = usageNode;
+	while (programNode.parent) programNode = programNode.parent;
+	let didFindMutation = false;
+	walkAst(programNode, (child) => {
+		if (didFindMutation) return false;
+		const childStart = getRangeStart(child);
+		if (childStart === null) return;
+		const ownerFunction = context.cfg.enclosingFunction(child);
+		if (!ownerFunction) return;
+		const isAfterRegistration = setupOwnerFunctions.has(ownerFunction) && childStart > usageStart;
+		const isBeforeRelease = cleanupOwnerFunctions.has(ownerFunction) && childStart < releaseStart;
+		if (!isAfterRegistration && !isBeforeRelease) return;
+		if (isNodeOfType(child, "AssignmentExpression")) {
+			const assignmentKey = resolveExpressionKey(child.left, context);
+			const assignmentTarget = stripParenExpression(child.left);
+			if (assignmentKey && [...collectionKeys].some((collectionKey) => assignmentKey === collectionKey || assignmentKey === `${collectionKey}.length`) || isNodeOfType(assignmentTarget, "MemberExpression") && assignmentTarget.computed && collectionKeys.has(resolveExpressionKey(assignmentTarget.object, context) ?? "")) {
+				didFindMutation = true;
+				return false;
+			}
+			return;
+		}
+		if (isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
+			const deletedMember = stripParenExpression(child.argument);
+			if (!isNodeOfType(deletedMember, "MemberExpression")) return;
+			if (collectionKeys.has(resolveExpressionKey(deletedMember.object, context) ?? "")) {
+				didFindMutation = true;
+				return false;
+			}
+			return;
+		}
+		if (isNodeOfType(child, "UpdateExpression")) {
+			const updatedKey = resolveExpressionKey(child.argument, context);
+			if (updatedKey && [...collectionKeys].some((collectionKey) => updatedKey === `${collectionKey}.length`)) {
+				didFindMutation = true;
+				return false;
+			}
+			return;
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = stripParenExpression(child.callee);
+		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || !REPLAY_ENTRY_DROPPING_ARRAY_METHOD_NAMES.has(callee.property.name) && !REPLAY_ENTRY_DROPPING_COLLECTION_METHOD_NAMES.has(callee.property.name) || !collectionKeys.has(resolveExpressionKey(callee.object, context) ?? "")) return;
+		didFindMutation = true;
+		return false;
+	});
+	return didFindMutation;
+};
+const usesUnaryListenerSignature = (registrationCall, releaseCall) => getCalleeName$1(registrationCall) === "addListener" && registrationCall.arguments?.length === 1 && releaseCall.arguments?.length === 1;
+const hasSafeForEachProjectionCleanup = (registrationCall, releaseCall, context) => {
+	const registrationCallee = stripParenExpression(registrationCall.callee);
+	const releaseCallee = stripParenExpression(releaseCall.callee);
+	if (!isNodeOfType(registrationCallee, "MemberExpression") || !isNodeOfType(releaseCallee, "MemberExpression")) return true;
+	const registrationVerbName = getCalleeName$1(registrationCall);
+	const releaseVerbName = getCalleeName$1(releaseCall);
+	const releaseHandler = releaseCall.arguments?.[usesUnaryListenerSignature(registrationCall, releaseCall) ? 0 : 1];
+	const releaseFunction = findEnclosingFunction$1(releaseCall);
+	const registrationEventKey = resolveResourceIdentityKey(registrationCall.arguments?.[0], context);
+	const releaseEventKey = resolveResourceIdentityKey(releaseCall.arguments?.[0], context);
+	const doesHandlerlessOffReleaseEveryRegistration = releaseVerbName === "off" && !releaseHandler && (releaseCall.arguments?.length === 0 || registrationEventKey !== null && registrationEventKey === releaseEventKey);
+	if (Boolean(releaseFunction && isFunctionLike$1(releaseFunction) && isReturnedEffectCleanupFunction(releaseFunction, context) && doNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseCall], context)) && (releaseVerbName !== null && UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName) || doesHandlerlessOffReleaseEveryRegistration)) return true;
+	const projections = [
+		registrationCallee.object,
+		registrationCall.arguments?.[0],
+		registrationCall.arguments?.[1],
+		releaseCallee.object,
+		releaseCall.arguments?.[0],
+		releaseCall.arguments?.[1]
+	].flatMap((expression) => {
+		const projection = resolveForEachProjection(expression, context);
+		return projection ? [projection] : [];
+	});
+	if (registrationVerbName === "addEventListener" && releaseVerbName === "removeEventListener") for (const optionsNode of [registrationCall.arguments?.[2], releaseCall.arguments?.[2]]) {
+		const captureProjection = resolveEventListenerCaptureProjection(optionsNode, context);
+		if (captureProjection) projections.push(captureProjection);
+	}
+	if (projections.length === 0) return true;
+	const collectionKeys = new Set(projections.map((projection) => projection.collectionKey));
+	if (!findDirectExhaustiveForEachCleanupFunction(releaseCall, collectionKeys, context)) return false;
+	return !hasCollectionMutationBeforeRelease(registrationCall, releaseCall, collectionKeys, context);
 };
 const doesReleaseCallMatchUsage = (node, usage, context) => {
 	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
@@ -15128,8 +15509,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 = resolveExpressionKey(callee.object, context);
-	const releaseEventKey = resolveExpressionKey(callNode.arguments?.[0], context);
+	const releaseReceiverKey = resolveResourceIdentityKey(callee.object, context);
+	const releaseEventKey = resolveResourceIdentityKey(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);
@@ -15139,7 +15520,13 @@ 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;
@@ -15149,6 +15536,9 @@ 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;
@@ -15162,9 +15552,7 @@ 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;
-			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 (!doEventListenerCapturesMatch(usage.node.arguments?.[2], callNode.arguments?.[2], context)) return false;
 			if (!isDirectExhaustiveForOfRelease(callNode, releaseForOfStatement)) return false;
 		}
 	}
@@ -15173,27 +15561,28 @@ const doesReleaseCallMatchUsage = (node, usage, context) => {
 		return isNodeOfType(handlerArgument, "Literal") && handlerArgument.value === null;
 	}
 	if (releaseVerbName === "removeEventListener" || releaseVerbName === "removeListener" || releaseVerbName === "off") {
-		const usesUnaryListenerSignature = usage.registrationVerbName === "addListener" && isNodeOfType(usage.node, "CallExpression") && usage.node.arguments?.length === 1 && callNode.arguments?.length === 1;
-		const releaseHandler = usesUnaryListenerSignature ? callNode.arguments?.[0] : callNode.arguments?.[1];
+		const usesUnaryListenerSignatureForCalls = isNodeOfType(usage.node, "CallExpression") && usesUnaryListenerSignature(usage.node, callNode);
+		const releaseHandler = usesUnaryListenerSignatureForCalls ? callNode.arguments?.[0] : callNode.arguments?.[1];
 		if (!releaseHandler) return releaseVerbName === "off";
-		const expectedHandlerKey = usesUnaryListenerSignature ? usage.eventKey : usage.handlerKey;
-		const registrationHandler = isNodeOfType(usage.node, "CallExpression") ? usage.node.arguments?.[usesUnaryListenerSignature ? 0 : 1] : null;
-		return expectedHandlerKey !== null && resolveExpressionKey(releaseHandler, context) === expectedHandlerKey || registrationHandler !== null && resolveStableValue(releaseHandler, context) === resolveStableValue(registrationHandler, context);
+		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);
 	}
 	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) => {
-	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 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;
 };
 const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (isInlineRetainedHandlerFunction(functionNode, context) || isReturnedEffectCleanupFunction(functionNode, context)) return true;
@@ -15283,7 +15672,7 @@ const hasEffectCleanupInvocation = (storage, usage, context) => {
 			if (!cleanupFunction || !cleanupFunctionInvokesRef(cleanupFunction)) return;
 			matchingReturns.push(child);
 		});
-		return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+		return doNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
 	};
 	let didFindInvocation = false;
 	walkAst(componentFunction.body, (child) => {
@@ -15335,12 +15724,10 @@ const isRetainedDisposerRefRelease = (releaseNode, usage, context) => {
 	return findRetainedDisposerStorages(disposerFunction, usage, context).some((storage) => isRetainedDisposerStorageEstablished(storage, usage, context) && !hasUnsafeRetainedDisposerOverwrite(storage, usage, context) && (hasEffectCleanupInvocation(storage, usage, context) || hasCallbackRefReplacementInvocation(storage, usage, context)));
 };
 const isSelfReleasingListenerRelease = (releaseNode, releaseFunction, usage, context) => {
-	if (usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.receiverKey === null || usage.eventKey === null || !isNodeOfType(usage.node, "CallExpression") || !isFunctionLike$1(releaseFunction) || releaseFunction.async || releaseFunction.generator || !isNodeOfType(releaseFunction.body, "BlockStatement") || !doMatchingNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
-	const registrationCapture = resolveEventListenerCapture(usage.node.arguments?.[2], { allowIndeterminateEntries: true });
+	if (usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.receiverKey === null || usage.eventKey === null || !isNodeOfType(usage.node, "CallExpression") || !isFunctionLike$1(releaseFunction) || releaseFunction.async || releaseFunction.generator || !isNodeOfType(releaseFunction.body, "BlockStatement") || !doNodesCoverEveryPathFromFunctionEntry(releaseFunction, [releaseNode], context)) return false;
 	const releaseCall = isNodeOfType(releaseNode, "ChainExpression") ? releaseNode.expression : releaseNode;
 	if (!isNodeOfType(releaseCall, "CallExpression")) return false;
-	const releaseCapture = resolveEventListenerCapture(releaseCall.arguments?.[2], { allowIndeterminateEntries: true });
-	if (registrationCapture === null || releaseCapture === null || registrationCapture !== releaseCapture) return false;
+	if (!doEventListenerCapturesMatch(usage.node.arguments?.[2], releaseCall.arguments?.[2], context)) return false;
 	const ownerFunction = findEnclosingFunction$1(releaseFunction);
 	if (!ownerFunction || !isFunctionLike$1(ownerFunction)) return false;
 	const triggerRegistrations = [];
@@ -15565,7 +15952,7 @@ const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retaine
 	walkInsideStatementBlocks(effectCallback.body, (child) => {
 		if (isNodeOfType(child, "ReturnStatement") && child.argument && matchesReturnedCleanup(stripParenExpression(child.argument))) matchingReturns.push(child);
 	});
-	return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
+	return doNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
 };
 const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) => {
 	const componentFunction = findEnclosingFunction$1(retainedFunction);
@@ -15608,15 +15995,6 @@ const findUnconditionalReturnStatement = (expression, ownerFunction) => {
 	const returnStatement = expressionRoot.parent;
 	return isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument === expressionRoot && findEnclosingFunction$1(returnStatement) === ownerFunction ? returnStatement : null;
 };
-const getFinalSequenceExpressionValue = (expression) => {
-	let finalExpression = stripParenExpression(expression);
-	while (isNodeOfType(finalExpression, "SequenceExpression")) {
-		const sequenceResult = finalExpression.expressions.at(-1);
-		if (!sequenceResult) break;
-		finalExpression = stripParenExpression(sequenceResult);
-	}
-	return finalExpression;
-};
 const doesResourceResultEscape = (resourceNode, allowReturnedResourceEscape, allowConciseReturnEscape, context) => {
 	if (!allowReturnedResourceEscape) return false;
 	let currentNode = resourceNode;
@@ -15865,7 +16243,7 @@ const isReactRefCallbackCleanupOwnedByEffect = (retainedFunction, cleanupFunctio
 			if (child !== returnedCleanupFunction.body && isFunctionLike$1(child)) return false;
 			if (isNodeOfType(child, "CallExpression") && resolveRefOwnedCleanupFunction(child.callee, context) === cleanupFunction) matchingCalls.push(child);
 		});
-		return doMatchingNodesCoverEveryPathFromFunctionEntry(returnedCleanupFunction, matchingCalls, context);
+		return doNodesCoverEveryPathFromFunctionEntry(returnedCleanupFunction, matchingCalls, context);
 	};
 	const matchingReturns = [];
 	walkInsideStatementBlocks(retainedFunction.body, (child) => {
@@ -18668,7 +19046,7 @@ const compileGlob = (pattern) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-component-props.ts
-const resolveSettings$44 = (settings) => {
+const resolveSettings$43 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { forbid: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidComponentProps ?? {} : {}).forbid ?? [] };
 };
@@ -18720,7 +19098,7 @@ const forbidComponentProps = defineRule({
 	recommendation: "Configure blocked component props so callers cannot bypass the component API contract.",
 	category: "Architecture",
 	create: (context) => {
-		const entries = resolveSettings$44(context.settings).forbid.map(normalizeEntry);
+		const entries = resolveSettings$43(context.settings).forbid.map(normalizeEntry);
 		return { JSXOpeningElement(node) {
 			if (entries.length === 0) return;
 			if (!isSupportedJsxName(node.name)) return;
@@ -18749,7 +19127,7 @@ const forbidComponentProps = defineRule({
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-dom-props.ts
 const buildMessage$24 = (propName, customMessage) => customMessage ?? `Your project blocks the \`${propName}\` prop on plain HTML tags, so this bypasses the agreed DOM API contract.`;
-const resolveSettings$43 = (settings) => {
+const resolveSettings$42 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidDomProps ?? {} : {};
 	const map = /* @__PURE__ */ new Map();
@@ -18771,7 +19149,7 @@ const forbidDomProps = defineRule({
 	recommendation: "Configure blocked DOM props so plain HTML tags stay on the agreed DOM API surface.",
 	category: "Architecture",
 	create: (context) => {
-		const forbidMap = resolveSettings$43(context.settings);
+		const forbidMap = resolveSettings$42(context.settings);
 		return { JSXOpeningElement(node) {
 			if (forbidMap.size === 0) return;
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
@@ -18810,11 +19188,12 @@ const forbidDomProps = defineRule({
 * carrying their own near-identical inlined implementation.
 */
 const flattenCalleeName = (callee) => {
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
-		const objectName = flattenCalleeName(callee.object);
+	const unwrappedCallee = stripParenExpression(callee);
+	if (isNodeOfType(unwrappedCallee, "Identifier")) return unwrappedCallee.name;
+	if (isNodeOfType(unwrappedCallee, "MemberExpression") && !unwrappedCallee.computed) {
+		const objectName = flattenCalleeName(unwrappedCallee.object);
 		if (!objectName) return null;
-		if (isNodeOfType(callee.property, "Identifier")) return `${objectName}.${callee.property.name}`;
+		if (isNodeOfType(unwrappedCallee.property, "Identifier")) return `${objectName}.${unwrappedCallee.property.name}`;
 	}
 	return null;
 };
@@ -18833,7 +19212,7 @@ const isReactFunctionCall = (node, expectedCall) => {
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-elements.ts
 const buildMessage$23 = (element, customHelp) => customHelp ? `Your project blocks \`<${element}>\` here. ${customHelp}` : `Your project blocks \`<${element}>\` here, so code stays on the approved UI surface.`;
-const resolveSettings$42 = (settings) => {
+const resolveSettings$41 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidElements ?? {} : {};
 	const map = /* @__PURE__ */ new Map();
@@ -18849,7 +19228,7 @@ const forbidElements = defineRule({
 	recommendation: "Configure blocked elements so code stays on the approved UI primitives.",
 	category: "Architecture",
 	create: (context) => {
-		const forbidMap = resolveSettings$42(context.settings);
+		const forbidMap = resolveSettings$41(context.settings);
 		return {
 			JSXOpeningElement(node) {
 				if (forbidMap.size === 0) return;
@@ -18958,7 +19337,7 @@ const DEFAULT_HEADING_TAGS = [
 	"h5",
 	"h6"
 ];
-const resolveSettings$41 = (settings) => {
+const resolveSettings$40 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.headingHasContent ?? {} : {};
 	return { headingTags: new Set([...DEFAULT_HEADING_TAGS, ...ruleSettings.components ?? []]) };
@@ -18971,7 +19350,7 @@ const headingHasContent = defineRule({
 	recommendation: "Put readable text in every heading.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$41(context.settings);
+		const settings = resolveSettings$40(context.settings);
 		return { JSXOpeningElement(node) {
 			const elementType = getElementType(node, context.settings);
 			if (!settings.headingTags.has(elementType)) return;
@@ -18992,7 +19371,7 @@ const headingHasContent = defineRule({
 //#region src/plugin/rules/react-builtins/hook-use-state.ts
 const REQUIRE_DESTRUCTURE_MESSAGE = "`useState` should be destructured as `[value, setValue]` so readers can see the state value and setter together.";
 const NAMING_CONVENTION_MESSAGE = "This `useState` setter does not match its value name, so updates are harder to trace.";
-const resolveSettings$40 = (settings) => {
+const resolveSettings$39 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { allowDestructuredState: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.hookUseState ?? {} : {}).allowDestructuredState ?? false };
 };
@@ -19019,7 +19398,7 @@ const hookUseState = defineRule({
 	recommendation: "Destructure `useState` as `const [thing, setThing] = useState(…)` so state reads and writes stay visible together.",
 	category: "Architecture",
 	create: (context) => {
-		const { allowDestructuredState } = resolveSettings$40(context.settings);
+		const { allowDestructuredState } = resolveSettings$39(context.settings);
 		return { CallExpression(node) {
 			const callExpressionNode = node;
 			if (!isReactFunctionCall(callExpressionNode, "useState")) return;
@@ -19152,7 +19531,7 @@ const hooksNoNanInDeps = defineRule({
 //#endregion
 //#region src/plugin/rules/a11y/html-has-lang.ts
 const MESSAGE$52 = "Screen readers may mispronounce this page because it doesn't declare a language, so add a `lang` attribute like `en`.";
-const resolveSettings$39 = (settings) => {
+const resolveSettings$38 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { htmlTags: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.htmlHasLang ?? {} : {}).htmlTags ?? ["html"] };
 };
@@ -19189,7 +19568,7 @@ const htmlHasLang = defineRule({
 	recommendation: "Set `<html lang=\"…\">` so screen readers know the page language.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$39(context.settings);
+		const settings = resolveSettings$38(context.settings);
 		const tagSet = new Set(settings.htmlTags);
 		return { JSXOpeningElement(node) {
 			const tag = getElementType(node, context.settings);
@@ -19705,7 +20084,7 @@ const DEFAULT_REDUNDANT_WORDS = [
 	"photo",
 	"picture"
 ];
-const resolveSettings$38 = (settings) => {
+const resolveSettings$37 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.imgRedundantAlt ?? {} : {};
 	return {
@@ -19753,7 +20132,7 @@ const imgRedundantAlt = defineRule({
 	category: "Accessibility",
 	create: (context) => {
 		if (isGeneratedImageRenderContext(context)) return {};
-		const settings = resolveSettings$38(context.settings);
+		const settings = resolveSettings$37(context.settings);
 		return { JSXOpeningElement(node) {
 			const tag = getElementType(node, context.settings);
 			if (!settings.components.includes(tag)) return;
@@ -20061,7 +20440,7 @@ const COMPOSITE_ITEM_ROLES = new Set([
 	"row",
 	"gridcell"
 ]);
-const resolveSettings$37 = (settings) => {
+const resolveSettings$36 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { tabbable: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.interactiveSupportsFocus ?? {} : {}).tabbable ?? DEFAULT_TABBABLE_ROLES };
 };
@@ -20073,7 +20452,7 @@ const interactiveSupportsFocus = defineRule({
 	recommendation: "Add keyboard focus support so users can reach interactive elements without a pointer.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$37(context.settings);
+		const settings = resolveSettings$36(context.settings);
 		const tabbableSet = new Set(settings.tabbable);
 		return { JSXOpeningElement(node) {
 			if (isLocalTestScaffoldJsx(node, context)) return;
@@ -22214,25 +22593,49 @@ const jsLengthCheckFirst = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/is-proven-global-namespace-reference.ts
+const GLOBAL_SELF_PROPERTY_NAMES = new Set([
+	"global",
+	"globalThis",
+	"self",
+	"window"
+]);
 const isProvenGlobalObjectReference = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const strippedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
-	if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
-	const symbol = scopes.symbolFor(strippedExpression);
-	if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	return isProvenGlobalObjectReference(symbol.initializer, scopes, visitedSymbolIds);
+	let currentExpression = expression;
+	while (true) {
+		const strippedExpression = stripParenExpression(currentExpression);
+		if (!isNodeOfType(strippedExpression, "Identifier")) return false;
+		if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
+		const declaration = symbol.declarationNode;
+		const initializer = declaration.init;
+		if (!initializer) return false;
+		const isDirectIdentifierAlias = isNodeOfType(declaration.id, "Identifier") && declaration.id === symbol.bindingIdentifier && initializer === symbol.initializer;
+		const bindingProperty = symbol.bindingIdentifier.parent;
+		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
+		const isDirectGlobalSelfAlias = isNodeOfType(declaration.id, "ObjectPattern") && isNodeOfType(bindingProperty, "Property") && bindingProperty.value === symbol.bindingIdentifier && bindingProperty.parent === declaration.id && destructuredPropertyName !== null && GLOBAL_SELF_PROPERTY_NAMES.has(destructuredPropertyName);
+		if (!isDirectIdentifierAlias && !isDirectGlobalSelfAlias) return false;
+		visitedSymbolIds.add(symbol.id);
+		currentExpression = initializer;
+	}
 };
 const isProvenGlobalNamespaceReference = (expression, namespaceName, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const strippedExpression = stripParenExpression(expression);
-	if (isNodeOfType(strippedExpression, "Identifier")) {
+	let currentExpression = expression;
+	while (true) {
+		const strippedExpression = stripParenExpression(currentExpression);
+		if (!isNodeOfType(strippedExpression, "Identifier")) return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
 		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
 		const symbol = scopes.symbolFor(strippedExpression);
-		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+		if (!symbol || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
 		visitedSymbolIds.add(symbol.id);
-		return isProvenGlobalNamespaceReference(symbol.initializer, namespaceName, scopes, visitedSymbolIds);
+		const declaration = symbol.declarationNode;
+		const bindingIdentifier = symbol.bindingIdentifier;
+		const bindingProperty = bindingIdentifier.parent;
+		if (getDestructuredBindingPropertyName(bindingIdentifier) === namespaceName && isNodeOfType(declaration, "VariableDeclarator") && isNodeOfType(declaration.id, "ObjectPattern") && isNodeOfType(bindingProperty, "Property") && bindingProperty.value === bindingIdentifier && bindingProperty.parent === declaration.id && declaration.init) return isProvenGlobalObjectReference(declaration.init, scopes);
+		const directInitializer = getDirectConstInitializer(symbol);
+		if (!directInitializer) return false;
+		currentExpression = directInitializer;
 	}
-	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
 };
 //#endregion
 //#region src/plugin/rules/js-performance/js-min-max-loop.ts
@@ -23345,7 +23748,7 @@ const jsTosortedImmutable = defineRule({
 const NEVER_MESSAGE$2 = () => "This boolean prop style disagrees with the project setting, so equivalent true props are harder to scan consistently.";
 const ALWAYS_MESSAGE$2 = () => "This boolean prop style disagrees with the project setting, so equivalent true props are harder to scan consistently.";
 const FALSE_OMITTED_MESSAGE = (attributeName) => `\`${attributeName}={false}\` does nothing, so the explicit false value adds noise without changing output.`;
-const resolveSettings$36 = (settings) => {
+const resolveSettings$35 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxBooleanValue ?? {} : {};
 	return {
@@ -23363,7 +23766,7 @@ const jsxBooleanValue = defineRule({
 	recommendation: "Use one boolean-attribute style so equivalent true props scan the same across the codebase.",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$36(context.settings);
+		const settings = resolveSettings$35(context.settings);
 		const alwaysSet = new Set(settings.always);
 		const neverSet = new Set(settings.never);
 		return { JSXAttribute(node) {
@@ -23417,7 +23820,7 @@ const jsxBooleanValue = defineRule({
 const UNNECESSARY_BRACES_MESSAGE = "These curly braces wrap a literal value, so they add JSX noise without changing output.";
 const REQUIRED_BRACES_MESSAGE = "This JSX value needs `{ }` so React reads it as an expression instead of text.";
 const isAllowedMode = (value) => value === "always" || value === "never" || value === "ignore";
-const resolveSettings$35 = (settings) => {
+const resolveSettings$34 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettingsRaw = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxCurlyBracePresence : void 0;
 	if (isAllowedMode(ruleSettingsRaw)) return {
@@ -23513,7 +23916,7 @@ const jsxCurlyBracePresence = defineRule({
 	recommendation: "Use one JSX literal style so equivalent markup scans the same without extra JSX noise.",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$35(context.settings);
+		const settings = resolveSettings$34(context.settings);
 		return {
 			JSXAttribute(node) {
 				const value = node.value;
@@ -23596,7 +23999,7 @@ const containsJsxElement = (root) => {
 //#region src/plugin/rules/react-builtins/jsx-filename-extension.ts
 const JSX_NOT_ALLOWED = (extension) => `This file contains JSX but uses a \`${extension}\` name, so the filename no longer signals JSX to readers or tooling conventions.`;
 const EXTENSION_ONLY_FOR_JSX = (extension) => `\`${extension}\` files are reserved for JSX here, so using that extension without JSX makes file-type conventions less useful.`;
-const resolveSettings$34 = (settings) => {
+const resolveSettings$33 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxFilenameExtension ?? {} : {};
 	return {
@@ -23618,7 +24021,7 @@ const jsxFilenameExtension = defineRule({
 	recommendation: "Name JSX files with the configured extension so file names accurately signal which files contain JSX.",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$34(context.settings);
+		const settings = resolveSettings$33(context.settings);
 		const allowedExtensions = normalizeExtensions(settings.extensions);
 		const filename = normalizeFilename(context.filename ?? "fixture.tsx");
 		const extensionOnly = path.extname(filename).slice(1);
@@ -23659,7 +24062,7 @@ const jsxFilenameExtension = defineRule({
 //#region src/plugin/rules/react-builtins/jsx-fragments.ts
 const SYNTAX_MESSAGE = "`<React.Fragment>` is used where shorthand fragments are configured, so similar wrappers look different across the codebase.";
 const ELEMENT_MESSAGE = "Fragment shorthand is used where explicit fragments are configured, so similar wrappers look different across the codebase.";
-const resolveSettings$33 = (settings) => {
+const resolveSettings$32 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { mode: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxFragments ?? {} : {}).mode ?? "syntax" };
 };
@@ -23671,7 +24074,7 @@ const jsxFragments = defineRule({
 	recommendation: "Use one fragment style so identical wrappers do not look different across files.",
 	category: "Architecture",
 	create: (context) => {
-		const { mode } = resolveSettings$33(context.settings);
+		const { mode } = resolveSettings$32(context.settings);
 		return {
 			JSXElement(node) {
 				if (mode !== "syntax") return;
@@ -23715,7 +24118,7 @@ const buildPropRegex = (handlerPropPrefix) => {
 	const escaped = tokens.map((token) => token.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("|");
 	return new RegExp(`^(${escaped})[A-Z].*$`);
 };
-const resolveSettings$32 = (settings) => {
+const resolveSettings$31 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxHandlerNames ?? {} : {};
 	let handlerPrefix = DEFAULT_HANDLER_PREFIX;
@@ -23791,7 +24194,7 @@ const jsxHandlerNames = defineRule({
 	recommendation: "Use the `on…` prefix for event-handler props and `handle…` for handlers so readers can trace event flow.",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$32(context.settings);
+		const settings = resolveSettings$31(context.settings);
 		return { JSXAttribute(node) {
 			if (settings.ignoreComponentNames.length > 0) {
 				const opening = node.parent;
@@ -23866,6 +24269,19 @@ const hasJsxKeyAttribute = (openingElement) => {
 	return false;
 };
 //#endregion
+//#region src/plugin/utils/is-component-function.ts
+const isFunctionAssignedToComponent = (functionNode) => {
+	let cursor = functionNode.parent ?? null;
+	while (isNodeOfType(cursor, "CallExpression")) cursor = cursor.parent ?? null;
+	if (isNodeOfType(cursor, "VariableDeclarator") && isNodeOfType(cursor.id, "Identifier") && isUppercaseName(cursor.id.name)) return true;
+	return isNodeOfType(cursor, "ExportDefaultDeclaration");
+};
+const isComponentFunction$1 = (node) => {
+	if (!isFunctionLike$1(node)) return false;
+	if (isNodeOfType(node, "FunctionDeclaration")) return !node.id || node.id.name === "default" || isUppercaseName(node.id.name) || isNodeOfType(node.parent, "ExportDefaultDeclaration");
+	return isFunctionAssignedToComponent(node);
+};
+//#endregion
 //#region src/plugin/utils/is-const-declared-binding.ts
 const BINDING_PATTERN_ANCESTOR_TYPES = new Set([
 	"VariableDeclarator",
@@ -23910,11 +24326,17 @@ const ITERATOR_METHOD_NAMES$1 = new Set([
 	"flatMap",
 	"from"
 ]);
+const RENDERING_CALL_NAMES = new Set([
+	"createPortal",
+	"hydrate",
+	"hydrateRoot",
+	"render"
+]);
 const MISSING_KEY_ARRAY = "Your users can see the wrong data when this array reorders.";
 const MISSING_KEY_ITERATOR = "Your users can see the wrong data when this list reorders.";
-const KEY_AFTER_SPREAD = "Place this `key` before the `{...spread}` so the JSX transform can always extract it.";
+const KEY_BEFORE_SPREAD = "Place this `key` after the `{...spread}` so the spread cannot override it.";
 const DUPLICATE_KEY = (keyValue) => `Your users can see the wrong data because two elements share the key "${keyValue}".`;
-const resolveSettings$31 = (settings) => {
+const resolveSettings$30 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxKey ?? {} : {};
 	return {
@@ -23928,6 +24350,33 @@ const findArrayVariableDeclarator = (arrayExpression) => {
 	if (ancestor && isNodeOfType(ancestor, "VariableDeclarator") && ancestor.init === wrapped && isNodeOfType(ancestor.id, "Identifier")) return ancestor;
 	return null;
 };
+const isArrayNestedInObjectProperty = (arrayExpression) => {
+	let current = findTransparentExpressionRoot(arrayExpression);
+	while (current.parent) {
+		const parent = current.parent;
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === current || parent.alternate === current) || isNodeOfType(parent, "LogicalExpression") && (parent.left === current || parent.right === current)) {
+			current = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		return isNodeOfType(parent, "Property") && parent.value === current;
+	}
+	return false;
+};
+const isArrayPassedToNonRenderingCall = (arrayExpression, scopes) => {
+	const transparentArray = findTransparentExpressionRoot(arrayExpression);
+	const callExpression = transparentArray.parent;
+	if (!callExpression || !isNodeOfType(callExpression, "CallExpression") || !callExpression.arguments.some((argument) => argument === transparentArray)) return false;
+	const argumentIndex = callExpression.arguments.findIndex((argument) => argument === transparentArray);
+	if (isReactApiCall(callExpression, "createElement", scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: true,
+		resolveNamedAliases: true
+	})) return argumentIndex < 2;
+	const callee = stripParenExpression(callExpression.callee);
+	if (isNodeOfType(callee, "Identifier")) return !RENDERING_CALL_NAMES.has(callee.name);
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return !RENDERING_CALL_NAMES.has(callee.property.name);
+	return true;
+};
 const isIdentityIteratorCallback = (callback) => {
 	const callbackFunction = stripParenExpression(callback);
 	if (!isNodeOfType(callbackFunction, "ArrowFunctionExpression") && !isNodeOfType(callbackFunction, "FunctionExpression")) return true;
@@ -24024,7 +24473,7 @@ const findNamedCallbackIteratorCall = (functionNode) => {
 	namedCallbackIteratorCallCache.set(functionNode, iteratorCall);
 	return iteratorCall;
 };
-const findEnclosingIteratorContext = (jsxNode) => {
+const findEnclosingIteratorContext = (jsxNode, scopes) => {
 	let current = jsxNode;
 	let isOutsideContainingFunction = false;
 	let didSeeReturnStatement = false;
@@ -24046,6 +24495,8 @@ const findEnclosingIteratorContext = (jsxNode) => {
 			isOutsideContainingFunction = true;
 		} else if (isNodeOfType(parent, "ArrayExpression")) {
 			if (isOutsideContainingFunction) return null;
+			if (isArrayNestedInObjectProperty(parent)) return null;
+			if (isArrayPassedToNonRenderingCall(parent, scopes)) return null;
 			const arrayParent = parent.parent;
 			if (arrayParent && isNodeOfType(arrayParent, "Property")) return null;
 			if (arrayParent && isNodeOfType(arrayParent, "ArrayExpression")) return null;
@@ -24127,9 +24578,15 @@ const isWithinChildrenToArray = (jsxNode) => {
 const isKeyPropertyName = (propertyKey) => {
 	if (isNodeOfType(propertyKey, "Identifier")) return propertyKey.name === "key";
 	if (isNodeOfType(propertyKey, "Literal")) return String(propertyKey.value) === "key";
-	return true;
+	return false;
 };
 const isThisPropsMember = (expression) => isNodeOfType(expression, "MemberExpression") && !expression.computed && isNodeOfType(expression.object, "ThisExpression") && isNodeOfType(expression.property, "Identifier") && expression.property.name === "props";
+const isDirectComponentPropsParameter = (bindingIdentifier, functionNode) => {
+	if (!isFunctionLike$1(functionNode) || !isComponentFunction$1(functionNode)) return false;
+	const firstParameter = functionNode.params?.[0];
+	if (!firstParameter) return false;
+	return (isNodeOfType(firstParameter, "AssignmentPattern") ? firstParameter.left : firstParameter) === bindingIdentifier;
+};
 const isFunctionParameterPropsRest = (bindingIdentifier) => {
 	const restElement = bindingIdentifier.parent;
 	if (!restElement || !isNodeOfType(restElement, "RestElement")) return false;
@@ -24139,7 +24596,7 @@ const isFunctionParameterPropsRest = (bindingIdentifier) => {
 	const parameterNode = patternParent && isNodeOfType(patternParent, "AssignmentPattern") && patternParent.left === objectPattern ? patternParent : objectPattern;
 	const functionNode = parameterNode.parent;
 	if (!functionNode || !isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "FunctionDeclaration")) return false;
-	return functionNode.params.some((param) => param === parameterNode);
+	return isComponentFunction$1(functionNode) && functionNode.params[0] === parameterNode;
 };
 const isRestBindingWithKeyExtracted = (bindingIdentifier) => {
 	const restElement = bindingIdentifier.parent;
@@ -24152,14 +24609,14 @@ const isRestBindingWithKeyExtracted = (bindingIdentifier) => {
 	}
 	return false;
 };
-const isBindingObjectMutated = (scopeOwner, bindingName) => {
-	let didFindMutation = false;
+const isBindingAssignedKey = (scopeOwner, bindingName) => {
+	let didFindKeyAssignment = false;
 	walkAst(scopeOwner, (node) => {
-		if (didFindMutation) return false;
+		if (didFindKeyAssignment) return false;
 		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression")) {
 			const assignedObject = stripParenExpression(node.left.object);
-			if (isNodeOfType(assignedObject, "Identifier") && assignedObject.name === bindingName) {
-				didFindMutation = true;
+			if (isNodeOfType(assignedObject, "Identifier") && assignedObject.name === bindingName && isKeyPropertyName(node.left.property)) {
+				didFindKeyAssignment = true;
 				return false;
 			}
 		}
@@ -24167,59 +24624,63 @@ const isBindingObjectMutated = (scopeOwner, bindingName) => {
 			const callee = node.callee;
 			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Object" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "assign") {
 				const firstArgument = node.arguments[0];
-				if (firstArgument && isNodeOfType(firstArgument, "Identifier") && firstArgument.name === bindingName) {
-					didFindMutation = true;
-					return false;
+				if (firstArgument && isNodeOfType(firstArgument, "Identifier") && firstArgument.name === bindingName) for (const sourceArgument of node.arguments.slice(1)) {
+					const source = stripParenExpression(sourceArgument);
+					if (!isNodeOfType(source, "ObjectExpression")) continue;
+					if (source.properties.some((property) => isNodeOfType(property, "Property") && isKeyPropertyName(property.key))) {
+						didFindKeyAssignment = true;
+						return false;
+					}
 				}
 			}
 		}
 	});
-	return didFindMutation;
+	return didFindKeyAssignment;
 };
-const spreadExpressionCanCarryKey = (expression, depth) => {
+const spreadExpressionHasKey = (expression, depth) => {
 	const inner = stripParenExpression(expression);
 	if (isNodeOfType(inner, "ObjectExpression")) {
 		for (const property of inner.properties) {
 			if (isNodeOfType(property, "SpreadElement")) {
-				if (depth >= 3) return true;
-				if (spreadExpressionCanCarryKey(property.argument, depth + 1)) return true;
+				if (depth >= 3) continue;
+				if (spreadExpressionHasKey(property.argument, depth + 1)) return true;
 				continue;
 			}
-			if (!isNodeOfType(property, "Property")) return true;
-			if (property.computed) return true;
+			if (!isNodeOfType(property, "Property")) continue;
 			if (isKeyPropertyName(property.key)) return true;
 		}
 		return false;
 	}
 	if (isNodeOfType(inner, "ConditionalExpression")) {
-		if (depth >= 3) return true;
-		return spreadExpressionCanCarryKey(inner.consequent, depth + 1) || spreadExpressionCanCarryKey(inner.alternate, depth + 1);
+		if (depth >= 3) return false;
+		return spreadExpressionHasKey(inner.consequent, depth + 1) || spreadExpressionHasKey(inner.alternate, depth + 1);
 	}
 	if (isNodeOfType(inner, "LogicalExpression")) {
-		if (depth >= 3) return true;
-		if (inner.operator === "&&") return spreadExpressionCanCarryKey(inner.right, depth + 1);
-		return spreadExpressionCanCarryKey(inner.left, depth + 1) || spreadExpressionCanCarryKey(inner.right, depth + 1);
+		if (depth >= 3) return false;
+		if (inner.operator === "&&") return spreadExpressionHasKey(inner.right, depth + 1);
+		return spreadExpressionHasKey(inner.left, depth + 1) || spreadExpressionHasKey(inner.right, depth + 1);
 	}
 	if (isNodeOfType(inner, "Literal")) return false;
 	if (isThisPropsMember(inner)) return false;
 	if (isNodeOfType(inner, "Identifier")) {
 		if (inner.name === "undefined") return false;
-		if (depth >= 3) return true;
+		if (depth >= 3) return false;
 		const binding = findVariableInitializer(inner, inner.name);
-		if (!binding) return true;
+		if (!binding) return false;
 		if (isRestBindingWithKeyExtracted(binding.bindingIdentifier)) return false;
 		if (isFunctionParameterPropsRest(binding.bindingIdentifier)) return false;
-		if (!isConstDeclaredBinding(binding) || !binding.initializer) return true;
-		if (isBindingObjectMutated(binding.scopeOwner, inner.name)) return true;
-		return spreadExpressionCanCarryKey(binding.initializer, depth + 1);
+		if (isDirectComponentPropsParameter(binding.bindingIdentifier, binding.scopeOwner)) return false;
+		if (!isConstDeclaredBinding(binding) || !binding.initializer) return false;
+		if (isBindingAssignedKey(binding.scopeOwner, inner.name)) return true;
+		return spreadExpressionHasKey(binding.initializer, depth + 1);
 	}
-	return true;
+	return false;
 };
-const spreadCanOverwriteKey = (spreadAttribute) => spreadExpressionCanCarryKey(spreadAttribute.argument, 0);
+const spreadCanOverwriteKey = (spreadAttribute) => spreadExpressionHasKey(spreadAttribute.argument, 0);
 const checkKeyBeforeSpread = (context, openingElement) => {
 	let keyIndex = null;
 	let keyAttribute = null;
-	let firstKeyCarryingSpreadIndex = null;
+	let lastKeyCarryingSpreadIndex = null;
 	for (let attributeIndex = 0; attributeIndex < openingElement.attributes.length; attributeIndex++) {
 		const attribute = openingElement.attributes[attributeIndex];
 		if (isNodeOfType(attribute, "JSXAttribute")) {
@@ -24227,11 +24688,11 @@ const checkKeyBeforeSpread = (context, openingElement) => {
 				keyIndex = attributeIndex;
 				keyAttribute = attribute;
 			}
-		} else if (isNodeOfType(attribute, "JSXSpreadAttribute") && firstKeyCarryingSpreadIndex === null && spreadCanOverwriteKey(attribute)) firstKeyCarryingSpreadIndex = attributeIndex;
+		} else if (isNodeOfType(attribute, "JSXSpreadAttribute") && spreadCanOverwriteKey(attribute)) lastKeyCarryingSpreadIndex = attributeIndex;
 	}
-	if (keyIndex !== null && firstKeyCarryingSpreadIndex !== null && firstKeyCarryingSpreadIndex < keyIndex && keyAttribute) context.report({
+	if (keyIndex !== null && lastKeyCarryingSpreadIndex !== null && lastKeyCarryingSpreadIndex > keyIndex && keyAttribute) context.report({
 		node: keyAttribute,
-		message: KEY_AFTER_SPREAD
+		message: KEY_BEFORE_SPREAD
 	});
 };
 const getKeyAttributeValueString = (openingElement) => {
@@ -24275,7 +24736,7 @@ const jsxKey = defineRule({
 	severity: "error",
 	recommendation: "Add a stable `key` prop so React can keep list items matched to the right data when the list changes.",
 	create: (context) => {
-		const settings = resolveSettings$31(context.settings);
+		const settings = resolveSettings$30(context.settings);
 		return {
 			JSXElement(node) {
 				const openingElement = node.openingElement;
@@ -24293,7 +24754,7 @@ const jsxKey = defineRule({
 						else seenKeys.add(keyValue.keyValue);
 					}
 				}
-				const enclosingContext = findEnclosingIteratorContext(node);
+				const enclosingContext = findEnclosingIteratorContext(node, context.scopes);
 				if (!enclosingContext) return;
 				if (isWithinChildrenToArray(node)) return;
 				if (hasJsxKeyAttribute(openingElement)) return;
@@ -24329,7 +24790,7 @@ const jsxKey = defineRule({
 //#region src/plugin/rules/react-builtins/jsx-max-depth.ts
 const buildMessage$19 = (depth, max) => `This JSX is hard to read at ${depth} levels deep, past the limit of ${max}.`;
 const DEFAULT_MAX_DEPTH = 14;
-const resolveSettings$30 = (settings) => {
+const resolveSettings$29 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { max: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxMaxDepth ?? {} : {}).max ?? DEFAULT_MAX_DEPTH };
 };
@@ -24398,7 +24859,7 @@ const jsxMaxDepth = defineRule({
 	recommendation: "Pull deeply nested JSX into smaller components so it's easier to read.",
 	category: "Architecture",
 	create: (context) => {
-		const { max } = resolveSettings$30(context.settings);
+		const { max } = resolveSettings$29(context.settings);
 		const deepestLeafPerTree = /* @__PURE__ */ new Map();
 		const checkNode = (node) => {
 			if (!isLeafJsxNode(node)) return;
@@ -24587,9 +25048,14 @@ const collectContextBindings = (programRoot) => {
 	}
 	return bindings;
 };
-const isCreateContextBindingJsxName = (node, contextBindings) => {
+const isCreateContextBindingJsxName = (node, contextBindings, scopes) => {
 	if (!isNodeOfType(node, "JSXIdentifier")) return false;
-	if (!contextBindings.has(node.name)) 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);
+	}
 	const binding = findVariableInitializer(node, node.name);
 	if (!binding) return false;
 	return binding.scopeOwner.type === "Program";
@@ -24613,7 +25079,7 @@ const jsxNoConstructedContextValues = defineRule({
 				if (isTestlikeFile) return;
 				const nameNode = node.name;
 				const isLegacyProvider = isProviderMemberName(nameNode);
-				const isReact19Shorthand = isCreateContextBindingJsxName(nameNode, contextBindings);
+				const isReact19Shorthand = isCreateContextBindingJsxName(nameNode, contextBindings, context.scopes);
 				if (!isLegacyProvider && !isReact19Shorthand) return;
 				if (!isInsideFunctionScope(node)) return;
 				for (const attribute of node.attributes) {
@@ -24884,6 +25350,29 @@ 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;
@@ -25169,6 +25658,7 @@ 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;
@@ -25188,19 +25678,6 @@ 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",
@@ -25559,7 +26036,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)) return;
+				if (hasCustomMemoComparator(openingName, context.scopes)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier") && isDataArrayPropName(node.name.name)) return;
 				if (!isInsideFunctionScope(node)) return;
 				const value = node.value;
@@ -26023,6 +26500,7 @@ 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;
@@ -26330,7 +26808,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)) return;
+				if (hasCustomMemoComparator(openingName, context.scopes)) return;
 				if (!isInsideFunctionScope(node)) return;
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
 				if (ALWAYS_FRESH_OBJECT_PROPS.has(node.name.name)) return;
@@ -26353,7 +26831,7 @@ const jsxNoNewObjectAsProp = defineRule({
 //#region src/plugin/rules/react-builtins/jsx-no-script-url.ts
 const MESSAGE$43 = "A `javascript:` URL is an XSS hole that runs injected input as code.";
 const JAVASCRIPT_URL_PATTERN = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
-const resolveSettings$29 = (settings) => {
+const resolveSettings$28 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	if (typeof reactDoctor !== "object" || reactDoctor === null) return {};
 	return reactDoctor.jsxNoScriptUrl ?? {};
@@ -26375,7 +26853,7 @@ const jsxNoScriptUrl = defineRule({
 	recommendation: "Use real event handlers instead of `javascript:` URLs so injected URL text cannot execute as code.",
 	category: "Security",
 	create: (context) => {
-		const options = resolveSettings$29(context.settings);
+		const options = resolveSettings$28(context.settings);
 		return { JSXOpeningElement(node) {
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
 			const elementName = resolveJsxElementType(node);
@@ -26396,283 +26874,6 @@ const jsxNoScriptUrl = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/react-builtins/jsx-no-target-blank.ts
-const NOREFERRER_MESSAGE = "`target=\"_blank\"` without `rel=\"noreferrer\"` lets the linked page hijack your tab to a phishing site.";
-const NOOPENER_MESSAGE = "`target=\"_blank\"` without `rel` lets the linked page hijack your tab to a phishing site.";
-const SPREAD_MESSAGE = "A spread here can add `target=\"_blank\"`, letting the linked page hijack your tab to a phishing site.";
-const resolveSettings$28 = (settings) => {
-	const reactDoctor = settings?.["react-doctor"];
-	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxNoTargetBlank ?? {} : {};
-	const reactSettings = typeof settings?.react === "object" && settings.react !== null ? settings.react : {};
-	const linkComponents = /* @__PURE__ */ new Map();
-	for (const entry of reactSettings.linkComponents ?? []) if (typeof entry === "string") linkComponents.set(entry, ["href"]);
-	else if (typeof entry === "object" && entry !== null) {
-		const linkAttribute = entry.linkAttribute ?? "href";
-		linkComponents.set(entry.name, Array.isArray(linkAttribute) ? linkAttribute : [linkAttribute]);
-	}
-	const formComponents = /* @__PURE__ */ new Map();
-	for (const entry of reactSettings.formComponents ?? []) if (typeof entry === "string") formComponents.set(entry, ["action"]);
-	else if (typeof entry === "object" && entry !== null) {
-		const formAttribute = entry.formAttribute ?? "action";
-		formComponents.set(entry.name, Array.isArray(formAttribute) ? formAttribute : [formAttribute]);
-	}
-	return {
-		enforceDynamicLinks: ruleSettings.enforceDynamicLinks ?? "always",
-		warnOnSpreadAttributes: ruleSettings.warnOnSpreadAttributes ?? false,
-		allowReferrer: ruleSettings.allowReferrer ?? false,
-		links: ruleSettings.links ?? true,
-		forms: ruleSettings.forms ?? false,
-		linkComponents,
-		formComponents
-	};
-};
-const isExternalLink = (href) => href.includes("//");
-const matchHrefExpression = (expression, state) => {
-	if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") {
-		if (isExternalLink(expression.value)) state.isExternal = true;
-		return;
-	}
-	if (isNodeOfType(expression, "Identifier")) {
-		state.isDynamic = true;
-		return;
-	}
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		matchHrefExpression(expression.consequent, state);
-		matchHrefExpression(expression.alternate, state);
-	}
-};
-const checkHref = (attributeValue, enforceDynamicLinks) => {
-	const state = {
-		isExternal: false,
-		isDynamic: false
-	};
-	if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") state.isExternal = isExternalLink(attributeValue.value);
-	else if (isNodeOfType(attributeValue, "JSXExpressionContainer")) matchHrefExpression(attributeValue.expression, state);
-	if (enforceDynamicLinks === "never") return !state.isExternal || state.isDynamic;
-	return !(state.isExternal || state.isDynamic);
-};
-const checkRelValue = (text, allowReferrer) => {
-	const tokens = text.split(/\s+/);
-	if (allowReferrer) return tokens.includes("noopener") || tokens.includes("noreferrer");
-	return tokens.some((token) => token.toLowerCase() === "noreferrer");
-};
-const matchRelExpression = (expression, allowReferrer) => {
-	const empty = {
-		combined: false,
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return {
-		combined: checkRelValue(expression.value, allowReferrer),
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		const consequent = matchRelExpression(expression.consequent, allowReferrer);
-		const alternate = matchRelExpression(expression.alternate, allowReferrer);
-		const test = expression.test;
-		if (isNodeOfType(test, "Identifier")) return {
-			combined: consequent.combined && alternate.combined,
-			testName: test.name,
-			consequent: consequent.combined,
-			alternate: alternate.combined
-		};
-		return {
-			combined: consequent.combined && alternate.combined,
-			testName: "",
-			consequent: consequent.combined,
-			alternate: alternate.combined
-		};
-	}
-	return empty;
-};
-const checkRel = (attributeValue, allowReferrer) => {
-	const empty = {
-		combined: false,
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") return {
-		combined: checkRelValue(attributeValue.value, allowReferrer),
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
-		const expression = attributeValue.expression;
-		if (expression.type === "JSXEmptyExpression") return empty;
-		return matchRelExpression(expression, allowReferrer);
-	}
-	return empty;
-};
-const matchTargetExpression = (expression) => {
-	const empty = {
-		combined: false,
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return {
-		combined: expression.value.toLowerCase() === "_blank",
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		const consequent = matchTargetExpression(expression.consequent);
-		const alternate = matchTargetExpression(expression.alternate);
-		const test = expression.test;
-		const combined = consequent.combined || alternate.combined;
-		if (isNodeOfType(test, "Identifier")) return {
-			combined,
-			testName: test.name,
-			consequent: consequent.combined,
-			alternate: alternate.combined
-		};
-		return {
-			combined,
-			testName: "",
-			consequent: consequent.combined,
-			alternate: alternate.combined
-		};
-	}
-	return empty;
-};
-const checkTarget = (attributeValue) => {
-	if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") return {
-		combined: attributeValue.value.toLowerCase() === "_blank",
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
-		const expression = attributeValue.expression;
-		if (expression.type === "JSXEmptyExpression") return {
-			combined: false,
-			testName: "",
-			consequent: false,
-			alternate: false
-		};
-		return matchTargetExpression(expression);
-	}
-	return {
-		combined: false,
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-};
-const jsxNoTargetBlank = defineRule({
-	id: "jsx-no-target-blank",
-	title: "Unsafe target=_blank link",
-	severity: "warn",
-	recommendation: "Add `rel=\"noreferrer\"` (or `\"noopener\"`) when using `target=\"_blank\"`.",
-	category: "Security",
-	create: (context) => {
-		const settings = resolveSettings$28(context.settings);
-		const isLink = (tagName) => {
-			if (!settings.links) return false;
-			if (tagName === "a") return true;
-			return settings.linkComponents.has(tagName);
-		};
-		const isForm = (tagName) => {
-			if (!settings.forms) return false;
-			if (tagName === "form") return true;
-			return settings.formComponents.has(tagName);
-		};
-		return { JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const tagName = resolveJsxElementType(node);
-			if (!tagName) return;
-			if (!isLink(tagName) && !isForm(tagName)) return;
-			const linkAttributeNames = settings.linkComponents.get(tagName) ?? ["href"];
-			const formAttributeNames = settings.formComponents.get(tagName) ?? ["action"];
-			let targetTuple = {
-				combined: false,
-				testName: "",
-				consequent: false,
-				alternate: false
-			};
-			let relTuple = {
-				combined: false,
-				testName: "",
-				consequent: false,
-				alternate: false
-			};
-			let isHrefValid = true;
-			let hasHrefValue = false;
-			let warnSpread = false;
-			let targetReportNode = node.name;
-			let spreadReportNode = null;
-			for (const attribute of node.attributes) {
-				if (isNodeOfType(attribute, "JSXSpreadAttribute")) {
-					if (settings.warnOnSpreadAttributes) {
-						warnSpread = true;
-						spreadReportNode = attribute;
-						targetTuple = {
-							combined: false,
-							testName: "",
-							consequent: false,
-							alternate: false
-						};
-						relTuple = {
-							combined: false,
-							testName: "",
-							consequent: false,
-							alternate: false
-						};
-						isHrefValid = false;
-						hasHrefValue = true;
-					}
-					continue;
-				}
-				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
-				const attributeName = attribute.name;
-				if (!isNodeOfType(attributeName, "JSXIdentifier")) continue;
-				const propName = attributeName.name;
-				const value = attribute.value;
-				if (propName === "target") {
-					if (value) {
-						targetTuple = checkTarget(value);
-						targetReportNode = value;
-					}
-				} else if (propName === "href" || propName === "action" || linkAttributeNames.includes(propName) || formAttributeNames.includes(propName)) {
-					if (value) {
-						hasHrefValue = true;
-						isHrefValid = checkHref(value, settings.enforceDynamicLinks);
-					}
-				} else if (propName === "rel" && value) relTuple = checkRel(value, settings.allowReferrer);
-			}
-			if (warnSpread) {
-				if (hasHrefValue && isHrefValid || relTuple.combined) return;
-				context.report({
-					node: spreadReportNode ?? node,
-					message: SPREAD_MESSAGE
-				});
-				return;
-			}
-			if (!isHrefValid) {
-				if (targetTuple.testName !== "" && targetTuple.testName === relTuple.testName) {
-					const consequentBad = targetTuple.consequent && !relTuple.consequent;
-					const alternateBad = targetTuple.alternate && !relTuple.alternate;
-					if (consequentBad || alternateBad) context.report({
-						node: targetReportNode,
-						message: settings.allowReferrer ? NOOPENER_MESSAGE : NOREFERRER_MESSAGE
-					});
-					return;
-				}
-				if (targetTuple.combined && !relTuple.combined) context.report({
-					node: targetReportNode,
-					message: settings.allowReferrer ? NOOPENER_MESSAGE : NOREFERRER_MESSAGE
-				});
-			}
-		} };
-	}
-});
-//#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-undef.ts
 const buildMessage$18 = (name) => `\`${name}\` crashes at runtime because it isn't defined here.`;
 const KNOWN_GLOBALS = new Set([
@@ -28330,6 +28531,30 @@ const hasAncestorLayoutMatching = (pageFilename, matchesLayout) => {
 const hasAncestorMetadataLayout = (pageFilename) => hasAncestorLayoutMatching(pageFilename, (layoutPath) => METADATA_EXPORT_NAMES.some((exportName) => doesModuleExportName(layoutPath, exportName)));
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-missing-metadata.ts
+const unwrapAwaitedExpression = (node) => {
+	let expression = stripParenExpression(node);
+	while (isNodeOfType(expression, "AwaitExpression")) expression = stripParenExpression(expression.argument);
+	return expression;
+};
+const isNextNavigationRedirectCall = (node, context) => {
+	const expression = unwrapAwaitedExpression(node);
+	if (!isNodeOfType(expression, "CallExpression")) return false;
+	const callee = stripParenExpression(expression.callee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	if (context.scopes.symbolFor(callee)?.kind !== "import") return false;
+	const importedName = getImportedNameFromModule(expression, callee.name, "next/navigation");
+	return importedName === "redirect" || importedName === "permanentRedirect";
+};
+const isRedirectOnlyDefaultExport = (programNode, context) => {
+	const defaultExport = findExportedValue(programNode, "default");
+	if (!defaultExport || !isFunctionLike$1(defaultExport)) return false;
+	if (!isNodeOfType(defaultExport.body, "BlockStatement")) return isNextNavigationRedirectCall(defaultExport.body, context);
+	if (defaultExport.body.body.length !== 1) return false;
+	const onlyStatement = defaultExport.body.body[0];
+	if (isNodeOfType(onlyStatement, "ExpressionStatement")) return isNextNavigationRedirectCall(onlyStatement.expression, context);
+	if (isNodeOfType(onlyStatement, "ReturnStatement") && onlyStatement.argument) return isNextNavigationRedirectCall(onlyStatement.argument, context);
+	return false;
+};
 const nextjsMissingMetadata = defineRule({
 	id: "nextjs-missing-metadata",
 	title: "Page missing metadata for search previews",
@@ -28349,6 +28574,7 @@ const nextjsMissingMetadata = defineRule({
 			if (isNodeOfType(declaration, "FunctionDeclaration")) return declaration.id?.name === "generateMetadata";
 			return (statement.specifiers ?? []).some((specifier) => isNodeOfType(specifier, "ExportSpecifier") && isNodeOfType(specifier.exported, "Identifier") && METADATA_EXPORT_NAMES.includes(specifier.exported.name));
 		})) return;
+		if (isRedirectOnlyDefaultExport(programNode, context)) return;
 		if (hasAncestorMetadataLayout(context.filename ?? "")) return;
 		context.report({
 			node: programNode,
@@ -29362,6 +29588,14 @@ 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",
@@ -29374,6 +29608,9 @@ 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({
@@ -34466,6 +34703,19 @@ const noCascadingSetState = defineRetiredRule({
 	recommendation: "Retired: React batches synchronous state updates from one effect into the same follow-up commit, so setter count does not prove repeated redraws."
 });
 //#endregion
+//#region src/plugin/utils/get-react-use-callback-call.ts
+const getReactUseCallbackCall = (expression, scopes) => {
+	const identifier = stripParenExpression(expression);
+	if (!isNodeOfType(identifier, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(identifier, scopes);
+	if (symbol?.kind !== "const" || !symbol.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	return isNodeOfType(initializer, "CallExpression") && isReactApiCall(initializer, "useCallback", scopes, {
+		allowGlobalReactNamespace: true,
+		resolveNamedAliases: true
+	}) ? initializer : null;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/utils/create-state-trigger-reachability.ts
 const getRefCurrentSymbol = (node, context) => {
 	const expression = stripParenExpression(node);
@@ -34994,19 +35244,8 @@ const isBuiltinNamespaceCallee = (callee) => {
 	}
 	return false;
 };
-const getReactUseCallbackSource = (reference, context) => {
-	const identifier = reference.identifier;
-	const symbol = resolveConstIdentifierAlias(identifier, context.scopes);
-	if (!symbol || symbol.kind !== "const" || !symbol.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	if (isNodeOfType(initializer, "CallExpression") && isReactApiCall(initializer, "useCallback", context.scopes, {
-		allowGlobalReactNamespace: true,
-		resolveNamedAliases: true
-	})) return initializer;
-	return null;
-};
 const getDependencyStateRefs = (analysis, context, dependencyReference) => {
-	const useCallbackCall = getReactUseCallbackSource(dependencyReference, context);
+	const useCallbackCall = getReactUseCallbackCall(dependencyReference.identifier, context.scopes);
 	if (!useCallbackCall) return getUpstreamRefs(analysis, dependencyReference).filter((reference) => isState(analysis, reference));
 	const dependencyList = useCallbackCall.arguments?.[1];
 	if (!dependencyList || !isNodeOfType(dependencyList, "ArrayExpression")) return getUpstreamRefs(analysis, dependencyReference).filter((reference) => isState(analysis, reference));
@@ -36594,19 +36833,6 @@ const noDefaultProps = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/is-component-function.ts
-const isFunctionAssignedToComponent = (functionNode) => {
-	let cursor = functionNode.parent ?? null;
-	while (isNodeOfType(cursor, "CallExpression")) cursor = cursor.parent ?? null;
-	if (isNodeOfType(cursor, "VariableDeclarator") && isNodeOfType(cursor.id, "Identifier") && isUppercaseName(cursor.id.name)) return true;
-	return isNodeOfType(cursor, "ExportDefaultDeclaration");
-};
-const isComponentFunction$1 = (node) => {
-	if (!isFunctionLike$1(node)) return false;
-	if (isNodeOfType(node, "FunctionDeclaration")) return !node.id || node.id.name === "default" || isUppercaseName(node.id.name) || isNodeOfType(node.parent, "ExportDefaultDeclaration");
-	return isFunctionAssignedToComponent(node);
-};
-//#endregion
 //#region src/plugin/utils/create-component-prop-stack-tracker.ts
 const extractDestructuredPropNames = (params) => {
 	const propNames = /* @__PURE__ */ new Set();
@@ -38520,6 +38746,17 @@ const noDynamicImportPath = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/utils/get-require-call-source.ts
+const getRequireCallSource = (expression) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return getRequireCallSource(unwrappedExpression.object);
+	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
+	if (!isNodeOfType(unwrappedExpression.callee, "Identifier") || unwrappedExpression.callee.name !== "require") return null;
+	const [firstArgument] = unwrappedExpression.arguments ?? [];
+	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
+	return typeof firstArgument.value === "string" ? firstArgument.value : null;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/utils/is-cleanup-return.ts
 const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
 	"each",
@@ -38664,7 +38901,16 @@ const collectDependencyStateSymbolIds = (effectNode, stateSymbolIds, scopes) =>
 	}
 	return dependencyStateSymbolIds;
 };
-const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
+const resolveSynchronouslyInvokedFunction = (expression, scopes) => {
+	const localFunction = resolveExactLocalFunction(expression, scopes);
+	if (localFunction) return localFunction;
+	const useCallbackCall = getReactUseCallbackCall(expression, scopes);
+	if (!useCallbackCall) return null;
+	const callback = useCallbackCall.arguments[0];
+	if (!callback || isNodeOfType(callback, "SpreadElement")) return null;
+	return resolveExactLocalFunction(callback, scopes);
+};
+const collectSynchronouslyInvokedFunctions = (effectCallback, scopes, includeStableCallbacks = true) => {
 	const analysisFunctions = new Set([effectCallback]);
 	const pendingFunctions = [effectCallback];
 	while (pendingFunctions.length > 0) {
@@ -38672,9 +38918,9 @@ const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
 		if (!currentFunction || !isFunctionLike$1(currentFunction)) continue;
 		walkInsideStatementBlocks(currentFunction.body, (child) => {
 			if (!isNodeOfType(child, "CallExpression")) return;
-			const invokedFunction = resolveExactLocalFunction(child.callee, scopes);
+			const invokedFunction = includeStableCallbacks ? resolveSynchronouslyInvokedFunction(child.callee, scopes) : resolveExactLocalFunction(child.callee, scopes);
 			if (!invokedFunction || analysisFunctions.has(invokedFunction)) return;
-			if (isFunctionLike$1(invokedFunction) && invokedFunction.async) return;
+			if (isFunctionLike$1(invokedFunction) && (invokedFunction.async || invokedFunction.generator)) return;
 			analysisFunctions.add(invokedFunction);
 			pendingFunctions.push(invokedFunction);
 		});
@@ -38687,7 +38933,51 @@ const visitSynchronousFunctionBodies = (analysisFunctions, visitor) => {
 		walkInsideStatementBlocks(analysisFunction.body, visitor);
 	}
 };
-const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+const getStateNameForSetterCall = (node, setterSymbolIdToStateName, scopes) => {
+	if (!isNodeOfType(node, "CallExpression") || !isNodeOfType(node.callee, "Identifier")) return null;
+	const setterSymbol = resolveConstIdentifierAlias(node.callee, scopes, true);
+	return setterSymbol ? setterSymbolIdToStateName.get(setterSymbol.id) ?? null : null;
+};
+const collectStateWriteAnalysisFunctions = (effectCallback, scopes, setterSymbolIdToStateName) => {
+	const ordinaryAnalysisFunctions = collectSynchronouslyInvokedFunctions(effectCallback, scopes, false);
+	const fullAnalysisFunctions = collectSynchronouslyInvokedFunctions(effectCallback, scopes);
+	const stableAnalysisFunctions = [...fullAnalysisFunctions].filter((analysisFunction) => !ordinaryAnalysisFunctions.has(analysisFunction));
+	if (stableAnalysisFunctions.length === 0) return ordinaryAnalysisFunctions;
+	let hasUnprovenObservableWork = stableAnalysisFunctions.some((analysisFunction) => {
+		if (!isFunctionLike$1(analysisFunction)) return false;
+		let hasExecutableDefault = false;
+		for (const parameter of analysisFunction.params) {
+			walkInsideStatementBlocks(parameter, (child) => {
+				if (isNodeOfType(child, "CallExpression") || isNodeOfType(child, "AssignmentExpression") || isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "ImportExpression") || isNodeOfType(child, "NewExpression") || isNodeOfType(child, "TaggedTemplateExpression") || isNodeOfType(child, "ThrowStatement") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") hasExecutableDefault = true;
+			});
+			if (hasExecutableDefault) return true;
+		}
+		return false;
+	});
+	const stableWrittenStateNames = /* @__PURE__ */ new Set();
+	const allWrittenStateNames = /* @__PURE__ */ new Set();
+	visitSynchronousFunctionBodies(fullAnalysisFunctions, (child) => {
+		const writtenStateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
+		if (writtenStateName) allWrittenStateNames.add(writtenStateName);
+	});
+	visitSynchronousFunctionBodies(new Set(stableAnalysisFunctions), (child) => {
+		if (hasUnprovenObservableWork) return;
+		if (isNodeOfType(child, "CallExpression")) {
+			const writtenStateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
+			if (writtenStateName) {
+				stableWrittenStateNames.add(writtenStateName);
+				return;
+			}
+			const invokedFunction = resolveSynchronouslyInvokedFunction(child.callee, scopes);
+			if (invokedFunction && fullAnalysisFunctions.has(invokedFunction)) return;
+			hasUnprovenObservableWork = true;
+			return;
+		}
+		if (isNodeOfType(child, "AssignmentExpression") || isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "ImportExpression") || isNodeOfType(child, "NewExpression") || isNodeOfType(child, "TaggedTemplateExpression") || isNodeOfType(child, "ThrowStatement") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") hasUnprovenObservableWork = true;
+	});
+	return !hasUnprovenObservableWork && stableWrittenStateNames.size === 1 && allWrittenStateNames.size === 1 ? fullAnalysisFunctions : ordinaryAnalysisFunctions;
+};
+const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, visitedSymbolIds = /* @__PURE__ */ new Set(), additionalStateValues = /* @__PURE__ */ new Map()) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	if (isNodeOfType(unwrappedExpression, "Literal")) {
 		const literalValue = unwrappedExpression.value;
@@ -38695,46 +38985,49 @@ const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, vi
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		if (scopes.symbolFor(unwrappedExpression)?.id === stateSymbolId) return stateValue;
+		const symbol = scopes.symbolFor(unwrappedExpression);
+		if (symbol?.id === stateSymbolId) return stateValue;
+		if (symbol && additionalStateValues.has(symbol.id)) return additionalStateValues.get(symbol.id) ?? null;
 		if (unwrappedExpression.name === "undefined" && scopes.isGlobalReference(unwrappedExpression)) return { value: void 0 };
+		if (unwrappedExpression.name === "NaN" && scopes.isGlobalReference(unwrappedExpression)) return { value: NaN };
 		const immutableSymbol = scopes.symbolFor(unwrappedExpression);
 		if (immutableSymbol?.kind !== "const" || !immutableSymbol.initializer || !isNodeOfType(immutableSymbol.declarationNode, "VariableDeclarator") || immutableSymbol.declarationNode.id !== immutableSymbol.bindingIdentifier || immutableSymbol.declarationNode.init !== immutableSymbol.initializer || immutableSymbol.references.some((reference) => reference.flag !== "read") || visitedSymbolIds.has(immutableSymbol.id)) return null;
-		return readStaticEffectValue(immutableSymbol.initializer, scopes, stateSymbolId, stateValue, new Set(visitedSymbolIds).add(immutableSymbol.id));
+		return readStaticEffectValue(immutableSymbol.initializer, scopes, stateSymbolId, stateValue, new Set(visitedSymbolIds).add(immutableSymbol.id), additionalStateValues);
 	}
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression")) {
 		if (unwrappedExpression.operator === "void") return { value: void 0 };
 		if (unwrappedExpression.operator !== "!") return null;
-		const argumentValue = readStaticEffectValue(unwrappedExpression.argument, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const argumentValue = readStaticEffectValue(unwrappedExpression.argument, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		return argumentValue ? { value: !argumentValue.value } : null;
 	}
 	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
 		if (isNodeOfType(unwrappedExpression.callee, "Identifier") && unwrappedExpression.callee.name === "Boolean" && scopes.isGlobalReference(unwrappedExpression.callee) && unwrappedExpression.arguments.length === 1 && unwrappedExpression.arguments[0] && !isNodeOfType(unwrappedExpression.arguments[0], "SpreadElement")) {
-			const argumentValue = readStaticEffectValue(unwrappedExpression.arguments[0], scopes, stateSymbolId, stateValue, visitedSymbolIds);
+			const argumentValue = readStaticEffectValue(unwrappedExpression.arguments[0], scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 			return argumentValue ? { value: Boolean(argumentValue.value) } : null;
 		}
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		if (!leftValue) return null;
 		if (unwrappedExpression.operator === "&&" && !leftValue.value) return leftValue;
 		if (unwrappedExpression.operator === "||" && leftValue.value) return leftValue;
 		if (unwrappedExpression.operator === "??" && leftValue.value !== null && leftValue.value !== void 0) return leftValue;
-		return readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		return readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 	}
 	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
-		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		if (!testValue) return null;
-		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 	}
 	if (isNodeOfType(unwrappedExpression, "MemberExpression") && unwrappedExpression.optional) {
-		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		if (objectValue?.value === null || objectValue?.value === void 0) return { value: void 0 };
 		return null;
 	}
 	if (isNodeOfType(unwrappedExpression, "BinaryExpression")) {
-		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
-		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
+		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds, additionalStateValues);
 		if (!leftValue || !rightValue) return null;
 		if (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "!==") {
 			const areEqual = leftValue.value === rightValue.value;
@@ -38773,8 +39066,7 @@ const collectStateWritesInEffect = (analysisFunctions, setterSymbolIdToStateName
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
-		const setterSymbol = resolveConstIdentifierAlias(child.callee, scopes, true);
-		const stateName = setterSymbol ? setterSymbolIdToStateName.get(setterSymbol.id) : void 0;
+		const stateName = getStateNameForSetterCall(child, setterSymbolIdToStateName, scopes);
 		if (!stateName) return;
 		const writeInfo = stateWrites.get(stateName) ?? {
 			values: /* @__PURE__ */ new Set(),
@@ -38790,27 +39082,27 @@ const collectStateWritesInEffect = (analysisFunctions, setterSymbolIdToStateName
 const isGlobalBooleanCall = (node, scopes) => {
 	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Boolean" && scopes.isGlobalReference(node.callee);
 };
-const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, scopes) => {
+const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map()) => {
 	let currentNode = workNode;
 	while (currentNode.parent) {
 		const parentNode = currentNode.parent;
 		if (isFunctionLike$1(parentNode)) break;
 		if (isNodeOfType(parentNode, "IfStatement")) {
-			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
 			if (testValue) {
 				if (currentNode === parentNode.consequent && !testValue.value) return false;
 				if (currentNode === parentNode.alternate && testValue.value) return false;
 			}
 		}
 		if (isNodeOfType(parentNode, "ConditionalExpression")) {
-			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
 			if (testValue) {
 				if (currentNode === parentNode.consequent && !testValue.value) return false;
 				if (currentNode === parentNode.alternate && testValue.value) return false;
 			}
 		}
 		if (isNodeOfType(parentNode, "LogicalExpression") && currentNode === parentNode.right) {
-			const leftValue = readStaticEffectValue(parentNode.left, scopes, stateSymbolId, stateValue);
+			const leftValue = readStaticEffectValue(parentNode.left, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues);
 			if (leftValue) {
 				if (parentNode.operator === "&&" && !leftValue.value) return false;
 				if (parentNode.operator === "||" && leftValue.value) return false;
@@ -38822,7 +39114,7 @@ const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, s
 			if (statementIndex >= 0) for (let index = 0; index < statementIndex; index += 1) {
 				const earlierStatement = parentNode.body[index];
 				if (!isNodeOfType(earlierStatement, "IfStatement") || earlierStatement.alternate || !statementAlwaysExits(earlierStatement.consequent)) continue;
-				if (readStaticEffectValue(earlierStatement.test, scopes, stateSymbolId, stateValue)?.value) return false;
+				if (readStaticEffectValue(earlierStatement.test, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), additionalStateValues)?.value) return false;
 			}
 		}
 		currentNode = parentNode;
@@ -38832,24 +39124,93 @@ const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, s
 const isReaderWorkNode = (node, analysisFunctions, scopes) => {
 	if (isNodeOfType(node, "CallExpression")) {
 		if (isGlobalBooleanCall(node, scopes)) return false;
-		const invokedFunction = resolveExactLocalFunction(node.callee, scopes);
+		const invokedFunction = resolveSynchronouslyInvokedFunction(node.callee, scopes);
 		return !invokedFunction || !analysisFunctions.has(invokedFunction);
 	}
 	return isNodeOfType(node, "AssignmentExpression") || isNodeOfType(node, "UpdateExpression") || isNodeOfType(node, "NewExpression") || isNodeOfType(node, "TaggedTemplateExpression") || isNodeOfType(node, "ThrowStatement") || isNodeOfType(node, "UnaryExpression") && node.operator === "delete";
 };
-const canStateWriteReachReaderWork = (writeInfo, readerEffect, stateSymbolId, scopes) => {
-	if (writeInfo.hasUnknownValue || stateSymbolId === null) return true;
-	for (const writtenValue of writeInfo.values) {
-		const stateValue = { value: writtenValue };
+const mergeKnownStateValues = (additionalStateValues, parameterStateValues) => {
+	if (parameterStateValues.size === 0) return additionalStateValues;
+	const knownStateValues = new Map(additionalStateValues);
+	for (const [symbolId, value] of parameterStateValues) knownStateValues.set(symbolId, value);
+	return knownStateValues;
+};
+const buildInvokedFunctionParameterStateValues = (invokedFunction, invocation, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map(), callerParameterStateValues = /* @__PURE__ */ new Map()) => {
+	if (!isFunctionLike$1(invokedFunction)) return /* @__PURE__ */ new Map();
+	const parameterStateValues = /* @__PURE__ */ new Map();
+	const callerKnownStateValues = mergeKnownStateValues(additionalStateValues, callerParameterStateValues);
+	for (let parameterIndex = 0; parameterIndex < invokedFunction.params.length; parameterIndex += 1) {
+		const rawParameter = invokedFunction.params[parameterIndex];
+		const rawArgument = invocation.arguments[parameterIndex];
+		if (rawArgument && isNodeOfType(rawArgument, "SpreadElement")) break;
+		const parameter = isNodeOfType(rawParameter, "AssignmentPattern") ? rawParameter.left : rawParameter;
+		if (!isNodeOfType(parameter, "Identifier")) continue;
+		const parameterSymbol = scopes.symbolFor(parameter);
+		if (!parameterSymbol) continue;
+		let argumentValue = null;
+		if (rawArgument) {
+			argumentValue = readStaticEffectValue(rawArgument, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), callerKnownStateValues);
+			if (argumentValue !== null && argumentValue.value === void 0 && isNodeOfType(rawParameter, "AssignmentPattern")) {
+				const defaultKnownStateValues = mergeKnownStateValues(callerKnownStateValues, parameterStateValues);
+				argumentValue = readStaticEffectValue(rawParameter.right, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), defaultKnownStateValues);
+			}
+		} else if (isNodeOfType(rawParameter, "AssignmentPattern")) {
+			const defaultKnownStateValues = mergeKnownStateValues(callerKnownStateValues, parameterStateValues);
+			argumentValue = readStaticEffectValue(rawParameter.right, scopes, stateSymbolId, stateValue, /* @__PURE__ */ new Set(), defaultKnownStateValues);
+		} else argumentValue = { value: void 0 };
+		if (argumentValue) parameterStateValues.set(parameterSymbol.id, argumentValue);
+	}
+	return parameterStateValues;
+};
+const haveEqualParameterStateValues = (leftValues, rightValues) => {
+	if (leftValues.size !== rightValues.size) return false;
+	for (const [symbolId, leftValue] of leftValues) {
+		const rightValue = rightValues.get(symbolId);
+		if (!rightValue || !Object.is(leftValue.value, rightValue.value)) return false;
+	}
+	return true;
+};
+const canReaderWorkRunForStateValues = (readerEffect, stateSymbolId, stateValue, scopes, additionalStateValues = /* @__PURE__ */ new Map()) => {
+	const pendingFrames = [{
+		functionNode: readerEffect.callback,
+		parameterStateValues: /* @__PURE__ */ new Map()
+	}];
+	const visitedParameterStateValues = /* @__PURE__ */ new Map();
+	while (pendingFrames.length > 0) {
+		const frame = pendingFrames.pop();
+		if (!frame || !isFunctionLike$1(frame.functionNode)) continue;
+		const functionParameterStateValues = visitedParameterStateValues.get(frame.functionNode) ?? [];
+		if (functionParameterStateValues.some((previousValues) => haveEqualParameterStateValues(previousValues, frame.parameterStateValues))) continue;
+		functionParameterStateValues.push(frame.parameterStateValues);
+		visitedParameterStateValues.set(frame.functionNode, functionParameterStateValues);
+		const knownStateValues = mergeKnownStateValues(additionalStateValues, frame.parameterStateValues);
 		let didFindReachableWork = false;
-		visitSynchronousFunctionBodies(readerEffect.analysisFunctions, (child) => {
-			if (didFindReachableWork || !isReaderWorkNode(child, readerEffect.analysisFunctions, scopes)) return;
-			if (isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes)) didFindReachableWork = true;
+		walkInsideStatementBlocks(frame.functionNode.body, (child) => {
+			if (didFindReachableWork) return;
+			if (isNodeOfType(child, "CallExpression")) {
+				const invokedFunction = resolveSynchronouslyInvokedFunction(child.callee, scopes);
+				if (invokedFunction && readerEffect.analysisFunctions.has(invokedFunction)) {
+					if (isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes, knownStateValues)) pendingFrames.push({
+						functionNode: invokedFunction,
+						parameterStateValues: buildInvokedFunctionParameterStateValues(invokedFunction, child, stateSymbolId, stateValue, scopes, additionalStateValues, frame.parameterStateValues)
+					});
+					return;
+				}
+			}
+			if (isReaderWorkNode(child, readerEffect.analysisFunctions, scopes) && isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes, knownStateValues)) didFindReachableWork = true;
 		});
 		if (didFindReachableWork) return true;
 	}
 	return false;
 };
+const canStateWriteReachReaderWork = (writtenStateName, writerEffect, readerEffect, stateSymbolIds, scopes) => {
+	const writeInfo = writerEffect.stateWrites.get(writtenStateName);
+	const stateSymbolId = stateSymbolIds.get(writtenStateName);
+	if (!writeInfo || stateSymbolId === void 0) return true;
+	if (writeInfo.hasUnknownValue) return true;
+	for (const writtenValue of writeInfo.values) if (canReaderWorkRunForStateValues(readerEffect, stateSymbolId, { value: writtenValue }, scopes)) return true;
+	return false;
+};
 const EMPTY_CLEANUP_NAME_SET = /* @__PURE__ */ new Set();
 const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
 	"clear",
@@ -38860,26 +39221,499 @@ const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
 	"keys",
 	"values"
 ]);
-const isFunctionShapedReturn = (returnedValue, setterToStateName, setterSymbolIdToStateName, scopes, isExplicitReturnStatement) => {
-	if (isNodeOfType(returnedValue, "ArrowFunctionExpression") || isNodeOfType(returnedValue, "FunctionExpression")) return true;
-	if (isNodeOfType(returnedValue, "CallExpression")) {
-		if (isNodeOfType(returnedValue.callee, "Identifier")) {
-			const setterSymbol = resolveConstIdentifierAlias(returnedValue.callee, scopes, true);
-			if (setterToStateName.has(returnedValue.callee.name) || setterSymbol && setterSymbolIdToStateName.has(setterSymbol.id)) return false;
-			if (isSetterIdentifier(returnedValue.callee.name)) return true;
+const EXTERNAL_SYNC_DIRECT_IMPORT_SOURCES = new Map([
+	["fetch", new Set([
+		"cross-fetch",
+		"node-fetch",
+		"undici"
+	])],
+	["ky", new Set(["ky"])],
+	["got", new Set(["got"])],
+	["wretch", new Set(["wretch"])],
+	["ofetch", new Set(["ofetch"])],
+	["setTimeout", new Set([
+		"node:timers",
+		"node:timers/promises",
+		"timers",
+		"timers/promises"
+	])],
+	["setInterval", new Set([
+		"node:timers",
+		"node:timers/promises",
+		"timers",
+		"timers/promises"
+	])]
+]);
+const EXTERNAL_SYNC_DEFAULT_IMPORT_NAMES = new Map([
+	["axios", "axios"],
+	["cross-fetch", "fetch"],
+	["got", "got"],
+	["ky", "ky"],
+	["node-fetch", "fetch"],
+	["wretch", "wretch"]
+]);
+const EXTERNAL_SYNC_HTTP_CLIENT_MODULE_SOURCES = new Set([
+	"axios",
+	"cross-fetch",
+	"got",
+	"ky",
+	"node-fetch",
+	"ofetch",
+	"undici",
+	"wretch"
+]);
+const EXTERNAL_SYNC_GLOBAL_HTTP_CLIENT_NAMES = new Set([
+	"axios",
+	"got",
+	"ky",
+	"ofetch",
+	"wretch"
+]);
+const EXTERNAL_SYNC_HTTP_METHOD_NAMES = new Set([
+	...EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES,
+	"fetch",
+	"patch",
+	"post",
+	"put",
+	"request"
+]);
+const TANSTACK_QUERY_CLIENT_MODULE_SOURCES = new Set(["@tanstack/query-core", "@tanstack/react-query"]);
+const TANSTACK_QUERY_EXTERNAL_SYNC_METHOD_NAMES = new Set(["fetchQuery", "prefetchQuery"]);
+const EXTERNAL_SYNC_RESOURCE_CONSTRUCTOR_NAMES = new Set([
+	...EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS,
+	...SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP,
+	"EventTarget",
+	"XMLHttpRequest"
+]);
+const getDestructuredBindingDepth = (bindingIdentifier) => {
+	let bindingNode = bindingIdentifier;
+	let depth = 0;
+	while (true) {
+		if (isNodeOfType(bindingNode.parent, "AssignmentPattern") && bindingNode.parent.left === bindingNode) bindingNode = bindingNode.parent;
+		const property = bindingNode.parent;
+		if (!property || !isNodeOfType(property, "Property") || property.value !== bindingNode || !property.parent || !isNodeOfType(property.parent, "ObjectPattern")) return depth;
+		depth += 1;
+		bindingNode = property.parent;
+	}
+};
+const isMutatedMemberExpression = (rawMemberExpression) => {
+	let expression = findTransparentExpressionRoot(rawMemberExpression);
+	while (expression.parent) {
+		const parent = expression.parent;
+		if (isNodeOfType(parent, "MemberExpression") && parent.object === expression) {
+			expression = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		if (isNodeOfType(parent, "Property") && parent.value === expression && isNodeOfType(parent.parent, "ObjectPattern")) {
+			expression = findTransparentExpressionRoot(parent);
+			continue;
 		}
-		return isCleanupReturn(returnedValue, EMPTY_CLEANUP_NAME_SET, EMPTY_CLEANUP_NAME_SET, { allowOpaqueReturn: isExplicitReturnStatement });
+		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;
 	}
-	if (isNodeOfType(returnedValue, "Identifier")) return true;
+	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;
+		}
+	}
+	return true;
+};
+const hasProvenGlobalNamespaceReference = (expression, namespaceNames, scopes) => {
+	for (const namespaceName of namespaceNames) if (isProvenGlobalNamespaceReference(expression, namespaceName, scopes)) return true;
 	return false;
 };
-const STORAGE_GLOBAL_NAMES = new Set(["localStorage", "sessionStorage"]);
-const isBrowserStorageReceiver = (receiver) => {
-	if (!receiver) return false;
-	if (isNodeOfType(receiver, "Identifier")) return STORAGE_GLOBAL_NAMES.has(receiver.name);
-	if (isNodeOfType(receiver, "MemberExpression")) return isNodeOfType(receiver.property, "Identifier") && STORAGE_GLOBAL_NAMES.has(receiver.property.name);
+const getTypeScriptImportEqualsSource = (symbol) => {
+	if (symbol.kind !== "ts-import-equals" || !isNodeOfType(symbol.declarationNode, "TSImportEqualsDeclaration")) return null;
+	const moduleReference = symbol.declarationNode.moduleReference;
+	if (!isNodeOfType(moduleReference, "TSExternalModuleReference") || !isNodeOfType(moduleReference.expression, "Literal")) return null;
+	return typeof moduleReference.expression.value === "string" ? moduleReference.expression.value : null;
+};
+const getUnshadowedRequireSource = (rawExpression, scopes) => {
+	let expression = stripParenExpression(rawExpression);
+	while (isNodeOfType(expression, "MemberExpression")) expression = stripParenExpression(expression.object);
+	if (!isNodeOfType(expression, "CallExpression") || !isNodeOfType(expression.callee, "Identifier") || expression.callee.name !== "require" || !scopes.isGlobalReference(expression.callee)) return null;
+	return getRequireCallSource(rawExpression);
+};
+const resolveExternalModuleBinding = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set(), ignoreCommonJsMutation = false) => {
+	let expression = stripParenExpression(rawExpression);
+	let outermostExportedName = null;
+	let exportedPropertyDepth = 0;
+	let resolvedBinding = null;
+	let isCommonJsModuleObject = false;
+	const traversedSymbolIds = new Set(visitedSymbolIds);
+	const commonJsModuleObjectSymbols = /* @__PURE__ */ new Set();
+	while (true) {
+		if (isNodeOfType(expression, "MemberExpression")) {
+			const propertyName = getStaticPropertyName(expression);
+			if (propertyName === null) return null;
+			outermostExportedName ??= propertyName;
+			exportedPropertyDepth += 1;
+			expression = stripParenExpression(expression.object);
+			continue;
+		}
+		const requireSource = getUnshadowedRequireSource(expression, scopes);
+		if (requireSource !== null) {
+			resolvedBinding = {
+				source: requireSource,
+				exportedName: null,
+				isModuleObject: true
+			};
+			isCommonJsModuleObject = true;
+			break;
+		}
+		if (!isNodeOfType(expression, "Identifier")) return null;
+		const symbol = scopes.symbolFor(expression);
+		if (!symbol || traversedSymbolIds.has(symbol.id)) return null;
+		if (symbol.kind === "import") {
+			const importDeclaration = symbol.declarationNode.parent;
+			if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration") || typeof importDeclaration.source.value !== "string") return null;
+			if (isNodeOfType(symbol.declarationNode, "ImportSpecifier")) resolvedBinding = {
+				source: importDeclaration.source.value,
+				exportedName: getImportedName(symbol.declarationNode) ?? null,
+				isModuleObject: false
+			};
+			else if (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier")) resolvedBinding = {
+				source: importDeclaration.source.value,
+				exportedName: "default",
+				isModuleObject: false
+			};
+			else if (isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")) resolvedBinding = {
+				source: importDeclaration.source.value,
+				exportedName: null,
+				isModuleObject: true
+			};
+			break;
+		}
+		const importEqualsSource = getTypeScriptImportEqualsSource(symbol);
+		if (importEqualsSource !== null) {
+			resolvedBinding = {
+				source: importEqualsSource,
+				exportedName: null,
+				isModuleObject: true
+			};
+			isCommonJsModuleObject = true;
+			commonJsModuleObjectSymbols.add(symbol);
+			break;
+		}
+		const directInitializer = getDirectUnreassignedInitializer(symbol);
+		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
+		const initializer = directInitializer ?? (destructuredPropertyName !== null && symbol.kind === "const" && isNodeOfType(symbol.declarationNode, "VariableDeclarator") ? symbol.declarationNode.init : null);
+		if (!initializer) return null;
+		traversedSymbolIds.add(symbol.id);
+		outermostExportedName ??= destructuredPropertyName;
+		if (destructuredPropertyName !== null) exportedPropertyDepth += getDestructuredBindingDepth(symbol.bindingIdentifier);
+		const unwrappedInitializer = stripParenExpression(initializer);
+		if (destructuredPropertyName === null && !isNodeOfType(unwrappedInitializer, "MemberExpression")) commonJsModuleObjectSymbols.add(symbol);
+		expression = unwrappedInitializer;
+	}
+	if (!resolvedBinding) return null;
+	if (!ignoreCommonJsMutation && isCommonJsModuleObject && !hasSafeReceiverAliases(commonJsModuleObjectSymbols, scopes)) return null;
+	if (outermostExportedName === null) return resolvedBinding;
+	if (!resolvedBinding.isModuleObject || exportedPropertyDepth !== 1) return null;
+	return {
+		source: resolvedBinding.source,
+		exportedName: outermostExportedName,
+		isModuleObject: false
+	};
+};
+const getCanonicalExternalSyncExportName = (binding) => {
+	if (binding.exportedName && binding.exportedName !== "default") return binding.exportedName;
+	return EXTERNAL_SYNC_DEFAULT_IMPORT_NAMES.get(binding.source) ?? null;
+};
+const isKnownExternalSyncDirectModuleBinding = (binding) => {
+	const exportedName = getCanonicalExternalSyncExportName(binding);
+	return Boolean(exportedName && EXTERNAL_SYNC_DIRECT_IMPORT_SOURCES.get(exportedName)?.has(binding.source));
+};
+const DEFINITELY_NON_FUNCTION_GLOBAL_CALL_NAMES = new Set([
+	"Array",
+	"BigInt",
+	"Boolean",
+	"Date",
+	"Number",
+	"String",
+	"Symbol"
+]);
+const DEFINITELY_NON_FUNCTION_GLOBAL_CONSTRUCTOR_NAMES = new Set([
+	"Array",
+	"Boolean",
+	"Date",
+	"Map",
+	"Number",
+	"Promise",
+	"RegExp",
+	"Set",
+	"String",
+	"URL",
+	"URLSearchParams",
+	"WeakMap",
+	"WeakSet"
+]);
+const PROMISE_STATIC_RESULT_METHOD_NAMES = new Set([
+	"all",
+	"allSettled",
+	"any",
+	"race",
+	"reject",
+	"resolve",
+	"withResolvers"
+]);
+const returnsOnlyNonCleanupValues = (functionNode, setterToStateName, scopes, visitedFunctions = /* @__PURE__ */ new Set()) => {
+	if (!isFunctionLike$1(functionNode) || functionNode.async || functionNode.generator || visitedFunctions.has(functionNode)) return false;
+	const nextVisitedFunctions = new Set(visitedFunctions).add(functionNode);
+	const isNonCleanupValue = (returnValue) => {
+		const expression = stripParenExpression(returnValue);
+		if (isNodeOfType(expression, "Identifier") && expression.name === "undefined" && scopes.isGlobalReference(expression)) return true;
+		if (isNodeOfType(expression, "Literal") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "JSXElement") || isNodeOfType(expression, "JSXFragment") || isNodeOfType(expression, "TemplateLiteral") || isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return true;
+		if (isNodeOfType(expression, "ConditionalExpression")) return isNonCleanupValue(expression.consequent) && isNonCleanupValue(expression.alternate);
+		if (isNodeOfType(expression, "LogicalExpression")) return isNonCleanupValue(expression.left) && isNonCleanupValue(expression.right);
+		if (isNodeOfType(expression, "SequenceExpression")) {
+			const finalExpression = expression.expressions.at(-1);
+			return Boolean(finalExpression && isNonCleanupValue(finalExpression));
+		}
+		if (isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && DEFINITELY_NON_FUNCTION_GLOBAL_CONSTRUCTOR_NAMES.has(expression.callee.name) && scopes.isGlobalReference(expression.callee)) return true;
+		if (!isNodeOfType(expression, "CallExpression")) return false;
+		if (isNodeOfType(expression.callee, "Identifier") && DEFINITELY_NON_FUNCTION_GLOBAL_CALL_NAMES.has(expression.callee.name) && scopes.isGlobalReference(expression.callee)) return true;
+		if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.object, "Identifier") && expression.callee.object.name === "Promise" && scopes.isGlobalReference(expression.callee.object) && PROMISE_STATIC_RESULT_METHOD_NAMES.has(getStaticPropertyName(expression.callee) ?? "")) return true;
+		if (isNodeOfType(expression.callee, "Identifier") && setterToStateName.has(expression.callee.name)) return true;
+		const invokedFunction = resolveSynchronouslyInvokedFunction(expression.callee, scopes);
+		return Boolean(invokedFunction && returnsOnlyNonCleanupValues(invokedFunction, setterToStateName, scopes, nextVisitedFunctions));
+	};
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isNonCleanupValue(functionNode.body);
+	let returnsOnlyNonCleanup = true;
+	walkAst(functionNode.body, (child) => {
+		if (!returnsOnlyNonCleanup) return false;
+		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "ReturnStatement")) return;
+		if (child.argument && !isNonCleanupValue(child.argument)) {
+			returnsOnlyNonCleanup = false;
+			return false;
+		}
+	});
+	return returnsOnlyNonCleanup;
+};
+const getResolvedFunctionCleanupReturnProof = (functionNode, scopes, visitedFunctions = /* @__PURE__ */ new Set()) => {
+	if (!isFunctionLike$1(functionNode) || functionNode.async || functionNode.generator || visitedFunctions.has(functionNode)) return {
+		hasCleanup: false,
+		isValid: false
+	};
+	const nextVisitedFunctions = new Set(visitedFunctions).add(functionNode);
+	const getCleanupReturnProof = (returnValue) => {
+		const expression = stripParenExpression(returnValue);
+		if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression")) return {
+			hasCleanup: true,
+			isValid: true
+		};
+		if (isNodeOfType(expression, "Identifier")) {
+			if (expression.name === "undefined" && scopes.isGlobalReference(expression)) return {
+				hasCleanup: false,
+				isValid: true
+			};
+			const localFunction = resolveExactLocalFunction(expression, scopes);
+			return {
+				hasCleanup: Boolean(localFunction),
+				isValid: Boolean(localFunction)
+			};
+		}
+		if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return {
+			hasCleanup: false,
+			isValid: true
+		};
+		if (isNodeOfType(expression, "ConditionalExpression")) {
+			const consequentProof = getCleanupReturnProof(expression.consequent);
+			const alternateProof = getCleanupReturnProof(expression.alternate);
+			return {
+				hasCleanup: consequentProof.hasCleanup || alternateProof.hasCleanup,
+				isValid: consequentProof.isValid && alternateProof.isValid
+			};
+		}
+		if (isNodeOfType(expression, "LogicalExpression")) {
+			const leftProof = getCleanupReturnProof(expression.left);
+			const rightProof = getCleanupReturnProof(expression.right);
+			return {
+				hasCleanup: leftProof.hasCleanup || rightProof.hasCleanup,
+				isValid: leftProof.isValid && rightProof.isValid
+			};
+		}
+		if (isNodeOfType(expression, "SequenceExpression")) {
+			const finalExpression = expression.expressions.at(-1);
+			return finalExpression ? getCleanupReturnProof(finalExpression) : {
+				hasCleanup: false,
+				isValid: false
+			};
+		}
+		if (!isNodeOfType(expression, "CallExpression")) return {
+			hasCleanup: false,
+			isValid: false
+		};
+		const invokedFunction = resolveSynchronouslyInvokedFunction(expression.callee, scopes);
+		return invokedFunction ? getResolvedFunctionCleanupReturnProof(invokedFunction, scopes, nextVisitedFunctions) : {
+			hasCleanup: false,
+			isValid: false
+		};
+	};
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return getCleanupReturnProof(functionNode.body);
+	let cleanupReturnProof = {
+		hasCleanup: false,
+		isValid: true
+	};
+	walkAst(functionNode.body, (child) => {
+		if (!cleanupReturnProof.isValid) return false;
+		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "ReturnStatement")) return;
+		if (!child.argument) return;
+		const returnProof = getCleanupReturnProof(child.argument);
+		if (!returnProof.isValid) {
+			cleanupReturnProof = {
+				hasCleanup: false,
+				isValid: false
+			};
+			return false;
+		}
+		cleanupReturnProof.hasCleanup ||= returnProof.hasCleanup;
+	});
+	return cleanupReturnProof;
+};
+const isFunctionShapedReturn = (returnedValue, setterToStateName, setterSymbolIdToStateName, scopes, isExplicitReturnStatement) => {
+	const unwrappedReturnedValue = stripParenExpression(returnedValue);
+	if (isNodeOfType(unwrappedReturnedValue, "ArrowFunctionExpression") || isNodeOfType(unwrappedReturnedValue, "FunctionExpression")) return true;
+	if (isNodeOfType(unwrappedReturnedValue, "CallExpression")) {
+		if (isNodeOfType(unwrappedReturnedValue.callee, "Identifier")) {
+			const setterSymbol = resolveConstIdentifierAlias(unwrappedReturnedValue.callee, scopes, true);
+			if (setterToStateName.has(unwrappedReturnedValue.callee.name) || setterSymbol && setterSymbolIdToStateName.has(setterSymbol.id)) return false;
+		}
+		const invokedFunction = resolveSynchronouslyInvokedFunction(unwrappedReturnedValue.callee, scopes);
+		if (invokedFunction && returnsOnlyNonCleanupValues(invokedFunction, setterToStateName, scopes)) return false;
+		if (invokedFunction) {
+			const cleanupReturnProof = getResolvedFunctionCleanupReturnProof(invokedFunction, scopes);
+			if (cleanupReturnProof.isValid) return cleanupReturnProof.hasCleanup;
+		}
+		if (!invokedFunction && isNodeOfType(unwrappedReturnedValue.callee, "Identifier") && isSetterIdentifier(unwrappedReturnedValue.callee.name)) return true;
+		return isCleanupReturn(unwrappedReturnedValue, EMPTY_CLEANUP_NAME_SET, EMPTY_CLEANUP_NAME_SET, { allowOpaqueReturn: isExplicitReturnStatement });
+	}
+	if (isNodeOfType(unwrappedReturnedValue, "Identifier")) return true;
 	return false;
 };
+const STORAGE_GLOBAL_NAMES = ["localStorage", "sessionStorage"];
+const isBrowserStorageReceiver = (receiver, scopes) => Boolean(receiver && STORAGE_GLOBAL_NAMES.some((storageName) => isProvenGlobalNamespaceReference(receiver, storageName, scopes)));
 const STORAGE_HOOK_PATTERN = /^use\w*Storage/i;
 const collectStorageHookSetterNames = (componentBody) => {
 	const setterNames = /* @__PURE__ */ new Set();
@@ -38911,23 +39745,16 @@ const callsOpaqueExternalSetter = (analysisFunctions, setterToStateName) => {
 	});
 	return didFindOpaqueSetterCall;
 };
-const isReactRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && (isReactApiCall(expression, "useRef", scopes, {
+const isReactUseRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && isReactApiCall(expression, "useRef", scopes, {
 	allowGlobalReactNamespace: true,
 	allowUnboundBareCalls: true,
 	resolveNamedAliases: true
-}) || isReactApiCall(expression, "createRef", scopes, {
+});
+const isReactRefCall = (expression, scopes) => isReactUseRefCall(expression, scopes) || isNodeOfType(expression, "CallExpression") && isReactApiCall(expression, "createRef", scopes, {
 	allowGlobalReactNamespace: true,
 	allowUnboundBareCalls: true,
 	resolveNamedAliases: true
-}));
-const getDirectReactRefSymbol = (rawExpression, scopes) => {
-	const expression = stripParenExpression(rawExpression);
-	if (!isNodeOfType(expression, "Identifier")) return null;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol) return null;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	return initializer && isReactRefCall(stripParenExpression(initializer), scopes) ? symbol : null;
-};
+});
 const isReactNativeJsxElement = (openingElement, scopes) => {
 	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
 	const symbol = scopes.symbolFor(openingElement.name);
@@ -38935,19 +39762,33 @@ const isReactNativeJsxElement = (openingElement, scopes) => {
 	return Boolean(symbol?.kind === "import" && importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react-native");
 };
 const isDirectHostJsxRef = (symbol, scopes) => {
-	let hostRefCount = 0;
-	for (const reference of symbol.references) {
-		const expression = findTransparentExpressionRoot(reference.identifier);
-		const container = expression.parent;
-		if (isNodeOfType(container, "MemberExpression") && container.object === expression && getStaticPropertyName(container) === "current") continue;
-		if (!container || !isNodeOfType(container, "JSXExpressionContainer") || container.expression !== expression) return false;
-		const attribute = container.parent;
-		if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
-		const openingElement = attribute.parent;
-		if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement") || !isProvenIntrinsicJsxElement(openingElement, scopes) && !isReactNativeJsxElement(openingElement, scopes)) return false;
-		hostRefCount += 1;
-	}
-	return hostRefCount > 0;
+	let didFindHostRef = false;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	const pendingSymbols = [symbol];
+	while (pendingSymbols.length > 0) {
+		const currentSymbol = pendingSymbols.pop();
+		if (!currentSymbol || visitedSymbolIds.has(currentSymbol.id)) continue;
+		visitedSymbolIds.add(currentSymbol.id);
+		for (const reference of currentSymbol.references) {
+			const expression = findTransparentExpressionRoot(reference.identifier);
+			const container = expression.parent;
+			if (isNodeOfType(container, "MemberExpression") && container.object === expression && getStaticPropertyName(container) === "current") continue;
+			if (isNodeOfType(container, "VariableDeclarator") && container.init === expression && isNodeOfType(container.id, "Identifier")) {
+				const aliasSymbol = scopes.symbolFor(container.id);
+				const aliasInitializer = aliasSymbol && getDirectUnreassignedInitializer(aliasSymbol);
+				if (!aliasSymbol || aliasInitializer !== expression) return false;
+				pendingSymbols.push(aliasSymbol);
+				continue;
+			}
+			if (!container || !isNodeOfType(container, "JSXExpressionContainer") || container.expression !== expression) return false;
+			const attribute = container.parent;
+			if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
+			const openingElement = attribute.parent;
+			if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement") || !isProvenIntrinsicJsxElement(openingElement, scopes) && !isReactNativeJsxElement(openingElement, scopes)) return false;
+			didFindHostRef = true;
+		}
+	}
+	return didFindHostRef;
 };
 const isIntrinsicRefCallbackParameter = (expression, scopes) => {
 	const identifier = stripParenExpression(expression);
@@ -38957,7 +39798,18 @@ const isIntrinsicRefCallbackParameter = (expression, scopes) => {
 	const rawFirstParameter = callback.params?.[0];
 	const firstParameter = isNodeOfType(rawFirstParameter, "AssignmentPattern") ? rawFirstParameter.left : rawFirstParameter;
 	const symbol = scopes.symbolFor(identifier);
-	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter);
+	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter && symbol.references.every((reference) => {
+		if (reference.flag !== "read") return false;
+		let referenceRoot = reference.identifier;
+		while (referenceRoot.parent) {
+			const parent = referenceRoot.parent;
+			if (isNodeOfType(parent, "AssignmentExpression")) return parent.left !== referenceRoot;
+			if (isNodeOfType(parent, "UpdateExpression")) return parent.argument !== referenceRoot;
+			if (isNodeOfType(parent, "ForInStatement") || isNodeOfType(parent, "ForOfStatement")) return parent.left !== referenceRoot;
+			referenceRoot = parent;
+		}
+		return true;
+	}));
 };
 const getDirectReactRefCall = (symbol, scopes) => {
 	const initializer = getDirectUnreassignedInitializer(symbol);
@@ -38965,15 +39817,38 @@ const getDirectReactRefCall = (symbol, scopes) => {
 	const expression = stripParenExpression(initializer);
 	return isNodeOfType(expression, "CallExpression") && isReactRefCall(expression, scopes) ? expression : null;
 };
+const isEmptyGlobalMapConstruction = (rawExpression, scopes) => {
+	const expression = stripParenExpression(rawExpression);
+	return isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Map" && scopes.isGlobalReference(expression.callee) && expression.arguments.length === 0;
+};
+const hasEmptyRefSentinelInitializer = (refCall, scopes) => {
+	if (!isReactUseRefCall(refCall, scopes) || refCall.arguments.length > 1) return false;
+	const [initialValue] = refCall.arguments;
+	return !initialValue || isNodeOfType(initialValue, "Literal") && initialValue.value === null || isNodeOfType(initialValue, "Identifier") && initialValue.name === "undefined" && scopes.isGlobalReference(initialValue);
+};
+const isDirectLazyEmptyMapInitialization = (currentExpression, symbol, scopes) => {
+	const assignment = currentExpression.parent;
+	if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.left !== currentExpression || assignment.operator !== "??=" || !isEmptyGlobalMapConstruction(assignment.right, scopes)) return false;
+	const refOwner = findEnclosingFunction$1(symbol.bindingIdentifier);
+	return refOwner !== null && findEnclosingFunction$1(assignment) === refOwner;
+};
 const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
-	const initialValue = getDirectReactRefCall(symbol, scopes)?.arguments?.[0];
-	if (!initialValue || !isNodeOfType(initialValue, "NewExpression") || !isNodeOfType(initialValue.callee, "Identifier") || initialValue.callee.name !== "Map" || !scopes.isGlobalReference(initialValue.callee) || initialValue.arguments.length !== 0) return false;
+	const refCall = getDirectReactRefCall(symbol, scopes);
+	const initialValue = refCall?.arguments[0];
+	const hasDirectEmptyMapInitializer = Boolean(initialValue && isEmptyGlobalMapConstruction(initialValue, scopes));
+	const hasLazyEmptyMapInitializer = Boolean(refCall && hasEmptyRefSentinelInitializer(refCall, scopes));
+	if (!hasDirectEmptyMapInitializer && !hasLazyEmptyMapInitializer) return false;
 	let intrinsicValueWriteCount = 0;
+	let lazyEmptyMapInitializationCount = 0;
 	for (const reference of symbol.references) {
 		const identifier = findTransparentExpressionRoot(reference.identifier);
 		const currentMember = identifier.parent;
 		if (!isNodeOfType(currentMember, "MemberExpression") || currentMember.object !== identifier || getStaticPropertyName(currentMember) !== "current") return false;
 		const currentExpression = findTransparentExpressionRoot(currentMember);
+		if (hasLazyEmptyMapInitializer && isDirectLazyEmptyMapInitialization(currentExpression, symbol, scopes)) {
+			lazyEmptyMapInitializationCount += 1;
+			continue;
+		}
 		const methodMember = currentExpression.parent;
 		if (!isNodeOfType(methodMember, "MemberExpression") || methodMember.object !== currentExpression) return false;
 		const methodName = getStaticPropertyName(methodMember);
@@ -38986,7 +39861,7 @@ const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
 		if (!storedValue || isNodeOfType(storedValue, "SpreadElement") || !isIntrinsicRefCallbackParameter(storedValue, scopes)) return false;
 		intrinsicValueWriteCount += 1;
 	}
-	return intrinsicValueWriteCount > 0;
+	return intrinsicValueWriteCount > 0 && (hasDirectEmptyMapInitializer || lazyEmptyMapInitializationCount === 1);
 };
 const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollectionValue = false, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const expression = stripParenExpression(rawExpression);
@@ -39000,7 +39875,11 @@ const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollecti
 	}
 	if (isNodeOfType(expression, "MemberExpression")) {
 		if (getStaticPropertyName(expression) === "current") {
-			const symbol = getDirectReactRefSymbol(expression.object, scopes);
+			const symbol = resolveReactRefSymbol(expression, scopes, {
+				allowUnboundBareCalls: true,
+				includeCreateRef: true,
+				resolveNamedAliases: true
+			});
 			return Boolean(symbol && (isDirectHostJsxRef(symbol, scopes) || didReadCollectionValue && storesOnlyIntrinsicRefCallbackValues(symbol, scopes)));
 		}
 		return isDerivedFromProvenDomRefCurrent(expression.object, scopes, didReadCollectionValue, visitedSymbolIds);
@@ -39018,19 +39897,80 @@ const isCommittedDomSyncNode = (node, scopes) => {
 	if (propertyName === null || !EXTERNAL_SYNC_DOM_MEMBER_METHOD_NAMES.has(propertyName)) return false;
 	return isDerivedFromProvenDomRefCurrent(callee.object, scopes) || isProvenBrowserApiReceiver(callee.object, "dom-event-target", scopes);
 };
-const isExternalSyncNode = (node) => {
-	if (isNodeOfType(node, "NewExpression")) return isNodeOfType(node.callee, "Identifier") && EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS.has(node.callee.name);
-	if (isNodeOfType(node, "AssignmentExpression")) return isNodeOfType(node.left, "MemberExpression") && isNodeOfType(node.left.property, "Identifier") && node.left.property.name === "current";
+const isProvenHttpClientReceiver = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isNodeOfType(expression, "Identifier")) {
+		const receiverSymbol = scopes.symbolFor(expression);
+		if (receiverSymbol && !hasSafeReceiverAliases(new Set([receiverSymbol]), scopes)) return false;
+	}
+	if (hasProvenGlobalNamespaceReference(expression, EXTERNAL_SYNC_GLOBAL_HTTP_CLIENT_NAMES, scopes)) return true;
+	const moduleBinding = resolveExternalModuleBinding(expression, scopes);
+	if (moduleBinding && EXTERNAL_SYNC_HTTP_CLIENT_MODULE_SOURCES.has(moduleBinding.source) && (moduleBinding.isModuleObject || moduleBinding.exportedName === "default" && EXTERNAL_SYNC_DEFAULT_IMPORT_NAMES.has(moduleBinding.source) || isKnownExternalSyncDirectModuleBinding(moduleBinding))) return true;
+	if (isNodeOfType(expression, "CallExpression")) {
+		const callee = stripParenExpression(expression.callee);
+		return Boolean(isNodeOfType(callee, "MemberExpression") && getStaticPropertyName(callee) === "create" && isProvenHttpClientReceiver(callee.object, scopes, visitedSymbolIds));
+	}
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	if (resolveExternalModuleBinding(expression, scopes, /* @__PURE__ */ new Set(), true)) return false;
+	const initializer = getDirectUnreassignedInitializer(symbol);
+	return Boolean(initializer && isProvenHttpClientReceiver(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id)));
+};
+const isProvenTanStackQueryClientReceiver = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isNodeOfType(expression, "Identifier")) {
+		const receiverSymbol = scopes.symbolFor(expression);
+		if (receiverSymbol && !hasSafeReceiverAliases(new Set([receiverSymbol]), scopes)) return false;
+	}
+	if (isNodeOfType(expression, "CallExpression")) {
+		const binding = resolveExternalModuleBinding(expression.callee, scopes);
+		return Boolean(binding && binding.source === "@tanstack/react-query" && binding.exportedName === "useQueryClient");
+	}
+	if (isNodeOfType(expression, "NewExpression")) {
+		const binding = resolveExternalModuleBinding(expression.callee, scopes);
+		return Boolean(binding && TANSTACK_QUERY_CLIENT_MODULE_SOURCES.has(binding.source) && binding.exportedName === "QueryClient");
+	}
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	const initializer = getDirectUnreassignedInitializer(symbol);
+	return Boolean(initializer && isProvenTanStackQueryClientReceiver(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id)));
+};
+const isProvenExternalResourceReceiver = (rawExpression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isDerivedFromProvenDomRefCurrent(expression, scopes) || isProvenBrowserApiReceiver(expression, "dom-event-target", scopes) || isProvenBrowserApiReceiver(expression, "xml-http-request", scopes) || isProvenHttpClientReceiver(expression, scopes)) return true;
+	if (isNodeOfType(expression, "NewExpression")) return hasProvenGlobalNamespaceReference(expression.callee, EXTERNAL_SYNC_RESOURCE_CONSTRUCTOR_NAMES, scopes);
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	const initializer = getDirectUnreassignedInitializer(symbol);
+	return Boolean(initializer && isProvenExternalResourceReceiver(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id)));
+};
+const isProvenExternalSyncDirectCallee = (callee, scopes) => {
+	if (hasProvenGlobalNamespaceReference(callee, EXTERNAL_SYNC_DIRECT_CALLEE_NAMES, scopes)) return true;
+	const moduleBinding = resolveExternalModuleBinding(callee, scopes);
+	return Boolean(moduleBinding && isKnownExternalSyncDirectModuleBinding(moduleBinding));
+};
+const isExternalSyncNode = (node, scopes) => {
+	if (isNodeOfType(node, "NewExpression")) return hasProvenGlobalNamespaceReference(node.callee, EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS, scopes);
+	if (isNodeOfType(node, "AssignmentExpression") || isNodeOfType(node, "UpdateExpression")) {
+		const mutationTarget = isNodeOfType(node, "AssignmentExpression") ? node.left : node.argument;
+		return isNodeOfType(mutationTarget, "MemberExpression") && getStaticPropertyName(mutationTarget) === "current" && Boolean(resolveReactRefSymbol(mutationTarget, scopes, {
+			allowUnboundBareCalls: true,
+			includeCreateRef: true,
+			resolveNamedAliases: true
+		}));
+	}
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	if (isNodeOfType(node.callee, "Identifier")) return EXTERNAL_SYNC_DIRECT_CALLEE_NAMES.has(node.callee.name);
+	if (isProvenExternalSyncDirectCallee(node.callee, scopes)) return true;
 	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
 	const propertyName = getStaticPropertyName(node.callee);
 	if (propertyName === null) return false;
-	if (EXTERNAL_SYNC_MEMBER_METHOD_NAMES.has(propertyName)) return true;
-	if (isBrowserStorageReceiver(node.callee.object)) return true;
-	if (!EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES.has(propertyName)) return false;
-	const receiverRootName = getRootIdentifierName(node.callee.object);
-	return receiverRootName !== null && EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS.has(receiverRootName);
+	if (isBrowserStorageReceiver(node.callee.object, scopes)) return true;
+	if (TANSTACK_QUERY_EXTERNAL_SYNC_METHOD_NAMES.has(propertyName)) return isProvenTanStackQueryClientReceiver(node.callee.object, scopes);
+	if (EXTERNAL_SYNC_HTTP_METHOD_NAMES.has(propertyName)) return isProvenHttpClientReceiver(node.callee.object, scopes);
+	return EXTERNAL_SYNC_MEMBER_METHOD_NAMES.has(propertyName) && isProvenExternalResourceReceiver(node.callee.object, scopes);
 };
 const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, setterSymbolIdToStateName, scopes, allowCommittedDomSync) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
@@ -39039,7 +39979,7 @@ const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateNa
 	} else for (const statement of effectCallback.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument && isFunctionShapedReturn(statement.argument, setterToStateName, setterSymbolIdToStateName, scopes, true)) return true;
 	let didFindExternalCall = false;
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
-		if (isExternalSyncNode(child) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
+		if (isExternalSyncNode(child, scopes) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
 	});
 	return didFindExternalCall;
 };
@@ -39061,11 +40001,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);
@@ -39078,10 +40018,11 @@ const noEffectChain = defineRule({
 				const callback = getEffectCallback(effectCall, context.scopes);
 				if (!callback || !isFunctionLike$1(callback) || callback.async) continue;
 				const analysisFunctions = collectSynchronouslyInvokedFunctions(callback, context.scopes);
-				const stateWrites = collectStateWritesInEffect(analysisFunctions, setterSymbolIdToStateName, context.scopes);
+				const stateWrites = collectStateWritesInEffect(collectStateWriteAnalysisFunctions(callback, context.scopes, setterSymbolIdToStateName), setterSymbolIdToStateName, context.scopes);
 				const writtenStateNames = new Set(stateWrites.keys());
 				effectInfos.push({
 					node: effectCall,
+					callback,
 					dependencyStateSymbolIds: collectDependencyStateSymbolIds(effectCall, stateSymbolIdSet, context.scopes),
 					stateWrites,
 					analysisFunctions,
@@ -39098,10 +40039,10 @@ const noEffectChain = defineRule({
 					if (readerEffect.isExternalSync) continue;
 					if (readerEffect.dependencyStateSymbolIds.size === 0) continue;
 					let chainedStateName = null;
-					for (const [writtenName, writeInfo] of writerEffect.stateWrites) {
+					for (const writtenName of writerEffect.stateWrites.keys()) {
 						const writtenStateSymbolId = stateSymbolIds.get(writtenName);
 						if (writtenStateSymbolId === void 0 || !readerEffect.dependencyStateSymbolIds.has(writtenStateSymbolId)) continue;
-						if (!canStateWriteReachReaderWork(writeInfo, readerEffect, stateSymbolIds.get(writtenName) ?? null, context.scopes)) continue;
+						if (!canStateWriteReachReaderWork(writtenName, writerEffect, readerEffect, stateSymbolIds, context.scopes)) continue;
 						chainedStateName = writtenName;
 						break;
 					}
@@ -39490,7 +40431,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 changes on every render on purpose.",
+	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.",
 	create: (context) => {
 		const componentBindings = createComponentBindingStackTracker({ onVariableDeclarator: (declaratorNode) => {
 			if (!isNodeOfType(declaratorNode, "VariableDeclarator")) return;
@@ -39512,7 +40453,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 re-runs your effect every render & defeats useEffectEvent.`
+						message: `Listing "${element.name}" in the deps defeats useEffectEvent — Effect Events are non-reactive and must be omitted from deps.`
 					});
 				}
 			}
@@ -39555,6 +40496,7 @@ 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({
@@ -42495,14 +43437,13 @@ const noInlineExhaustiveStyle = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/performance/no-inline-prop-on-memo-component.ts
-const isMemoCall = (node) => {
+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) => {
 	if (!isNodeOfType(node, "CallExpression")) return 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 comparator = node.arguments?.[1];
+	return comparator ? !isIdentitySensitiveMemoComparator(comparator, scopes) : 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";
@@ -42516,16 +43457,17 @@ 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)) memoizedComponentNames.add(node.id.name);
+				if (isMemoCall(node.init) && !hasCustomComparator(node.init, context.scopes)) memoizedComponentNames.add(node.id.name);
 			},
 			ExportDefaultDeclaration(node) {
-				if (node.declaration && isNodeOfType(node.declaration, "CallExpression") && isMemoCall(node.declaration) && !hasCustomComparator(node.declaration)) {
+				if (node.declaration && isNodeOfType(node.declaration, "CallExpression") && isMemoCall(node.declaration) && !hasCustomComparator(node.declaration, context.scopes)) {
 					const innerArgument = node.declaration.arguments?.[0];
 					if (isNodeOfType(innerArgument, "Identifier")) memoizedComponentNames.add(innerArgument.name);
 				}
@@ -43885,16 +44827,6 @@ const noManyBooleanProps = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-global-match-media-call.ts
-const isGlobalMatchMediaCall = (node, scopes) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (isNodeOfType(callee, "Identifier")) return callee.name === "matchMedia" && scopes.isGlobalReference(callee);
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "matchMedia") return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && (receiver.name === "window" || receiver.name === "globalThis") && scopes.isGlobalReference(receiver);
-};
-//#endregion
 //#region src/plugin/rules/performance/no-match-media-in-state-initializer.ts
 const REACT_USE_STATE_OPTIONS = {
 	allowGlobalReactNamespace: true,
@@ -46284,6 +47216,103 @@ const EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1 = new Set([
 	"useVisibility",
 	"useWindowSize"
 ]);
+const EXTERNAL_SUBSCRIPTION_PRIMITIVE_RESULT_HOOK_NAMES = new Set([
+	"useMatchMedia",
+	"useMediaQuery",
+	"useVisibility"
+]);
+const isImportBindingRef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "ImportBinding"));
+const getImportedExternalSubscriptionHookName = (analysis, rawCallee) => {
+	const callee = stripParenExpression(rawCallee);
+	if (isNodeOfType(callee, "Identifier")) {
+		const calleeRef = getRef(analysis, callee);
+		if (!calleeRef || !isImportBindingRef(calleeRef)) return null;
+		const importBinding = getImportBindingForName(callee, callee.name);
+		if (!importBinding || importBinding.isNamespace) return null;
+		if (importBinding.exportedName && EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(importBinding.exportedName)) return importBinding.exportedName;
+		return importBinding.exportedName === "default" && EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(callee.name) ? callee.name : null;
+	}
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	const hookName = getStaticMemberPropertyName(callee);
+	const namespaceIdentifier = stripParenExpression(callee.object);
+	if (!hookName || !EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(hookName) || !isNodeOfType(namespaceIdentifier, "Identifier")) return null;
+	const namespaceRef = getRef(analysis, namespaceIdentifier);
+	if (!namespaceRef || !isImportBindingRef(namespaceRef)) return null;
+	return getImportBindingForName(namespaceIdentifier, namespaceIdentifier.name)?.isNamespace ? hookName : null;
+};
+const isSafeExternalSubscriptionResultBinding = (bindingIdentifier, bindingPattern) => {
+	let current = bindingIdentifier;
+	let didCrossDestructuringBoundary = false;
+	while (current !== bindingPattern) {
+		const parent = current.parent;
+		if (!parent || isNodeOfType(parent, "AssignmentPattern") || isNodeOfType(parent, "RestElement")) return false;
+		if (isNodeOfType(parent, "Property")) {
+			if (parent.value !== current) return false;
+			didCrossDestructuringBoundary = true;
+		}
+		if (isNodeOfType(parent, "ArrayPattern")) didCrossDestructuringBoundary = true;
+		current = parent;
+	}
+	return didCrossDestructuringBoundary;
+};
+const getVariablesDefinedByDeclarator = (analysis, declarator) => analysis.scopeManager.scopes.flatMap((scope) => scope.variables).filter((variable) => variable.defs.some((definition) => definition.node === declarator));
+const hasUnsafeExternalSubscriptionBindingUse = (analysis, variable, visitedVariables = /* @__PURE__ */ new Set()) => {
+	if (visitedVariables.has(variable)) return false;
+	visitedVariables.add(variable);
+	return variable.references.some((candidateReference) => {
+		if (candidateReference.init) return false;
+		if (candidateReference.isWrite()) return true;
+		let usageRoot = findTransparentExpressionRoot(candidateReference.identifier);
+		while (isNodeOfType(usageRoot.parent, "MemberExpression") && usageRoot.parent.object === usageRoot) usageRoot = findTransparentExpressionRoot(usageRoot.parent);
+		const usageParent = usageRoot.parent;
+		if (isNodeOfType(usageParent, "AssignmentExpression") && usageParent.left === usageRoot || isNodeOfType(usageParent, "UpdateExpression") && usageParent.argument === usageRoot || isNodeOfType(usageParent, "UnaryExpression") && usageParent.operator === "delete" && usageParent.argument === usageRoot) return true;
+		let usageAncestor = usageRoot.parent;
+		while (usageAncestor && !isNodeOfType(usageAncestor, "VariableDeclarator") && !isFunctionLike$1(usageAncestor) && !isNodeOfType(usageAncestor, "Program")) usageAncestor = usageAncestor.parent;
+		if (isNodeOfType(usageAncestor, "VariableDeclarator") && usageAncestor.init) {
+			const aliasVariables = getVariablesDefinedByDeclarator(analysis, usageAncestor);
+			return aliasVariables.length === 0 || aliasVariables.some((aliasVariable) => hasUnsafeExternalSubscriptionBindingUse(analysis, aliasVariable, visitedVariables));
+		}
+		return false;
+	});
+};
+const hasOnlySafeExternalSubscriptionResultBindings = (analysis, declarator, variables = getVariablesDefinedByDeclarator(analysis, declarator)) => {
+	return variables.length > 0 && variables.every((variable) => {
+		const bindingIdentifier = variable.defs.find((candidateDefinition) => candidateDefinition.node === declarator)?.name;
+		return Boolean(bindingIdentifier && isNodeOfType(bindingIdentifier, "Identifier") && isSafeExternalSubscriptionResultBinding(bindingIdentifier, declarator.id) && !hasUnsafeExternalSubscriptionBindingUse(analysis, variable));
+	});
+};
+const hasImmutableExternalSubscriptionCallResult = (analysis, rawCallee, relatedRefs, allowWholeResult) => {
+	const callee = stripParenExpression(rawCallee);
+	const callExpression = callee.parent;
+	if (!callExpression || !isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== callee) return false;
+	const initializer = findTransparentExpressionRoot(callExpression);
+	const declarator = initializer.parent;
+	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== initializer || !isNodeOfType(declarator.parent, "VariableDeclaration") || declarator.parent.kind !== "const") return false;
+	const relatedVariables = getVariablesDefinedByDeclarator(analysis, declarator).filter((variable) => relatedRefs.some((relatedRef) => relatedRef.resolved === variable));
+	if (relatedVariables.length === 0) return false;
+	return isNodeOfType(declarator.id, "Identifier") ? allowWholeResult && relatedVariables.every((variable) => !hasUnsafeExternalSubscriptionBindingUse(analysis, variable)) : hasOnlySafeExternalSubscriptionResultBindings(analysis, declarator, relatedVariables);
+};
+const isImmutableImportedExternalSubscriptionHookCallee = (analysis, rawCallee, relatedRefs) => {
+	const hookName = getImportedExternalSubscriptionHookName(analysis, rawCallee);
+	return Boolean(hookName && hasImmutableExternalSubscriptionCallResult(analysis, rawCallee, relatedRefs, EXTERNAL_SUBSCRIPTION_PRIMITIVE_RESULT_HOOK_NAMES.has(hookName)));
+};
+const isExternalSubscriptionHookResultRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
+	const declarator = def.node;
+	if (!isNodeOfType(declarator, "VariableDeclarator") || !declarator.init || !isNodeOfType(declarator.parent, "VariableDeclaration") || declarator.parent.kind !== "const") return false;
+	const initializer = stripParenExpression(declarator.init);
+	if (!isNodeOfType(initializer, "CallExpression")) return false;
+	const hookName = getImportedExternalSubscriptionHookName(analysis, initializer.callee);
+	if (!hookName) return false;
+	if (isNodeOfType(declarator.id, "Identifier")) return EXTERNAL_SUBSCRIPTION_PRIMITIVE_RESULT_HOOK_NAMES.has(hookName) && ref.resolved && !hasUnsafeExternalSubscriptionBindingUse(analysis, ref.resolved);
+	const bindingIdentifier = def.name;
+	return isNodeOfType(bindingIdentifier, "Identifier") && isSafeExternalSubscriptionResultBinding(bindingIdentifier, declarator.id) && ref.resolved && !hasUnsafeExternalSubscriptionBindingUse(analysis, ref.resolved);
+}));
+const isExternalSubscriptionHookResultArgument = (analysis, argument) => {
+	const unwrappedArgument = stripParenExpression(argument);
+	if (!isNodeOfType(unwrappedArgument, "Identifier")) return false;
+	const argumentRef = getRef(analysis, unwrappedArgument);
+	return Boolean(argumentRef && isExternalSubscriptionHookResultRef(analysis, argumentRef));
+};
 const isCallbackPropReference = (analysis, ref) => {
 	if (!isProp(analysis, ref)) return false;
 	const identifier = ref.identifier;
@@ -46316,8 +47345,9 @@ const isParentWiredHookCalleeRef = (analysis, ref) => {
 	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier) return false;
 	return (parent.arguments ?? []).some((hookArgument) => getDownstreamRefs(analysis, hookArgument).some((downstreamRef) => isCallbackPropReference(analysis, downstreamRef)));
 };
-const getLocalHookExternalStateProof = (analysis, ref) => {
+const getLocalHookExternalStateProof = (analysis, ref, scopes) => {
 	let hookFunction = resolveToFunction(ref);
+	let didResolveThroughResultBinding = false;
 	if (!hookFunction) for (const definition of ref.resolved?.defs ?? []) {
 		const definitionNode = definition.node;
 		if (!isNodeOfType(definitionNode, "VariableDeclarator") || !definitionNode.init) continue;
@@ -46328,29 +47358,27 @@ const getLocalHookExternalStateProof = (analysis, ref) => {
 		const calleeReference = getRef(analysis, callee);
 		if (!calleeReference) continue;
 		hookFunction = resolveToFunction(calleeReference);
-		if (hookFunction) break;
+		if (hookFunction) {
+			didResolveThroughResultBinding = true;
+			break;
+		}
 	}
 	if (!hookFunction) return null;
-	const returnedReferences = collectFunctionReturnStatements(hookFunction).flatMap((returnStatement) => returnStatement.argument ? getDownstreamRefs(analysis, returnStatement.argument) : []);
+	if (didResolveThroughResultBinding && (!ref.resolved || hasUnsafeExternalSubscriptionBindingUse(analysis, ref.resolved))) return false;
+	if (isNodeOfType(hookFunction, "ArrowFunctionExpression") && !isNodeOfType(hookFunction.body, "BlockStatement") && isReactHookCall(stripParenExpression(hookFunction.body), "useSyncExternalStore", scopes)) return true;
+	const returnStatements = collectFunctionReturnStatements(hookFunction);
+	if (returnStatements.length > 0 && returnStatements.every((returnStatement) => returnStatement.argument && isReactHookCall(stripParenExpression(returnStatement.argument), "useSyncExternalStore", scopes))) return true;
+	const returnedReferences = returnStatements.flatMap((returnStatement) => returnStatement.argument ? getDownstreamRefs(analysis, returnStatement.argument) : []);
 	if (returnedReferences.length === 0) return null;
 	return returnedReferences.every((returnedReference) => isState(analysis, returnedReference) && isExternallyDrivenState(analysis, returnedReference));
 };
-const isExternalSubscriptionHookRef = (analysis, ref) => {
-	const identifier = ref.identifier;
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const localHookProof = getLocalHookExternalStateProof(analysis, ref);
-	if (localHookProof !== null) return localHookProof;
-	if (EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(identifier.name) && isCalleePosition(identifier)) return true;
-	return Boolean(ref.resolved?.defs.some((def) => {
-		const node = def.node;
-		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
-		const initializer = stripParenExpression(node.init);
-		if (!isNodeOfType(initializer, "CallExpression")) return false;
-		const callee = stripParenExpression(initializer.callee);
-		return isNodeOfType(callee, "Identifier") && EXTERNAL_SUBSCRIPTION_HOOK_NAMES$1.has(callee.name);
-	}));
+const isImmutableLocalExternalStoreHookCallee = (analysis, rawCallee, relatedRefs, scopes) => {
+	const callee = stripParenExpression(rawCallee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const calleeReference = getRef(analysis, callee);
+	if (!calleeReference || getLocalHookExternalStateProof(analysis, calleeReference, scopes) !== true) return false;
+	return hasImmutableExternalSubscriptionCallResult(analysis, callee, relatedRefs, true);
 };
-const isImportBindingRef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "ImportBinding"));
 const isCalleePosition = (identifier) => {
 	const parent = identifier.parent;
 	return Boolean(parent && (isNodeOfType(parent, "CallExpression") || isNodeOfType(parent, "NewExpression")) && parent.callee === identifier);
@@ -46411,25 +47439,35 @@ const noPassDataToParent = defineRule({
 						return getFunctionalUpdaterDataRefs(analysis, argument);
 					}
 					if (isHandlerBagArgument(analysis, argument)) return [];
+					if (isExternalSubscriptionHookResultArgument(analysis, argument)) return [];
 					if (isParentWiredHookResultArgument(analysis, argument)) return [];
 					if (isNodeOfType(argument, "Identifier")) {
 						const argumentRef = getRef(analysis, argument);
 						if (argumentRef && resolveToFunction(argumentRef)) return [];
 					}
 					return getDownstreamRefs(analysis, argument);
-				}).flatMap((argumentRef) => isExternallyDrivenState(analysis, argumentRef) || isExternalSubscriptionHookRef(analysis, argumentRef) ? [] : getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
-				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref, context.scopes)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
+				}).flatMap((argumentRef) => {
+					if (isExternallyDrivenState(analysis, argumentRef) || getLocalHookExternalStateProof(analysis, argumentRef, context.scopes) === true) return [];
+					const upstreamRefs = getUpstreamRefs(analysis, argumentRef);
+					return upstreamRefs.filter((upstreamRef) => {
+						if (!isLeafRef(upstreamRef)) return false;
+						return !isImmutableImportedExternalSubscriptionHookCallee(analysis, upstreamRef.identifier, upstreamRefs) && !isImmutableLocalExternalStoreHookCallee(analysis, upstreamRef.identifier, upstreamRefs, context.scopes);
+					});
+				});
+				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref, context.scopes)) {
+					const wrapperUpstreamRefs = getArgsUpstreamRefs(analysis, ref);
+					argsUpstreamRefs.push(...wrapperUpstreamRefs.filter((upstreamRef) => isLeafRef(upstreamRef) && !isImmutableImportedExternalSubscriptionHookCallee(analysis, upstreamRef.identifier, wrapperUpstreamRefs) && !isImmutableLocalExternalStoreHookCallee(analysis, upstreamRef.identifier, wrapperUpstreamRefs, context.scopes)));
+				}
 				if (!argsUpstreamRefs.some((argRef) => {
-					if (isUseStateIdentifier(argRef.identifier)) return false;
-					if (isExternalSubscriptionHookRef(analysis, argRef)) return false;
+					const argIdentifier = argRef.identifier;
+					if (isUseStateIdentifier(argIdentifier)) return false;
 					if (isProp(analysis, argRef)) return false;
-					if (isUseRefIdentifier(argRef.identifier)) return false;
+					if (isUseRefIdentifier(argIdentifier)) return false;
 					if (isRefCurrent(argRef)) return false;
 					if (isConstant(argRef)) return false;
 					if (isParentWiredHookResultRef(analysis, argRef)) return false;
 					if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
 					if (resolveToFunction(argRef)) return false;
-					const argIdentifier = argRef.identifier;
 					if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
 					if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
 					return true;
@@ -55380,6 +56418,7 @@ 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) => {
@@ -55419,17 +56458,6 @@ const preferModuleScopePureFunction = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-require-call-source.ts
-const getRequireCallSource = (expression) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return getRequireCallSource(unwrappedExpression.object);
-	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
-	if (!isNodeOfType(unwrappedExpression.callee, "Identifier") || unwrappedExpression.callee.name !== "require") return null;
-	const [firstArgument] = unwrappedExpression.arguments ?? [];
-	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
-	return typeof firstArgument.value === "string" ? firstArgument.value : null;
-};
-//#endregion
 //#region src/plugin/utils/is-proven-node-crypto-namespace-reference.ts
 const NODE_CRYPTO_MODULE_SOURCES = new Set(["crypto", "node:crypto"]);
 const isProvenNodeCryptoNamespaceReference = (expression, scopes) => {
@@ -56021,10 +57049,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"],
+	requires: ["react:19.2"],
 	tags: ["test-noise"],
 	severity: "warn",
-	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",
+	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",
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
@@ -57629,7 +58657,6 @@ 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();
@@ -57689,7 +58716,6 @@ 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();
@@ -57815,6 +58841,7 @@ 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;
@@ -58261,8 +59288,9 @@ const renderingHydrationNoFlicker = defineRule({
 	id: "rendering-hydration-no-flicker",
 	title: "useEffect setState flashes on mount",
 	tags: ["test-noise"],
+	requires: ["ssr"],
 	severity: "warn",
-	recommendation: "Use `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)` or add `suppressHydrationWarning` to the element",
+	recommendation: "Read the value with `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)` inside a reusable hook, 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];
@@ -58715,7 +59743,7 @@ const renderingUsetransitionLoading = defineRule({
 	title: "Loading useState forces extra render",
 	tags: ["test-noise"],
 	severity: "warn",
-	recommendation: "Replace with `const [isPending, startTransition] = useTransition()`, which skips the extra render for the loading flag",
+	recommendation: "Replace with `const [isPending, startTransition] = useTransition()`, which marks the update as non-urgent and interruptible so the input stays responsive",
 	create: (context) => ({ VariableDeclarator(node) {
 		if (!isNodeOfType(node.id, "ArrayPattern") || !node.id.elements?.length) return;
 		if (!node.init || !isHookCall$2(node.init, "useState")) return;
@@ -58747,7 +59775,7 @@ const renderingUsetransitionLoading = defineRule({
 		}
 		context.report({
 			node: node.init,
-			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`
+			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`
 		});
 	} })
 });
@@ -58756,7 +59784,7 @@ const renderingUsetransitionLoading = defineRule({
 const isRepositorySecretFilePath = (relativePath) => DOTENV_FILE_PATTERN.test(relativePath) || /(?:^|\/)\.npmrc$/.test(relativePath) || /(?:^|\/)[^/]*(?:credential|credentials|service-account|serviceAccount|firebase-admin|google-service-account|gcp-service-account)[^/]*\.(?:json|env|pem|key)$/i.test(relativePath);
 //#endregion
 //#region src/plugin/rules/security-scan/repository-secret-file.ts
-const isRepositorySecretExamplePath = (relativePath) => /(?:^|\/)\.env\.(?:example|sample|template|dist|defaults?)$|(?:^|\/)[^/]*(?:example|sample|template)[^/]*\.(?:env|json|pem|key)$/i.test(relativePath);
+const isRepositorySecretExamplePath = (relativePath) => /(?:^|\/)\.env(?:\.[^./]+)*\.(?:example|sample|template|dist|defaults?)$|(?:^|\/)[^/]*(?:example|sample|template)[^/]*\.(?:env|json|pem|key)$/i.test(relativePath);
 const repositorySecretFile = defineRule({
 	id: "repository-secret-file",
 	title: "Secret file checked into repository",
@@ -59062,6 +60090,7 @@ 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;
@@ -59474,7 +60503,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 	title: "useMemo before an early return",
 	tags: ["test-noise"],
 	severity: "warn",
-	recommendation: "Move the JSX into a child component wrapped in memo, so the parent's early return skips it",
+	recommendation: "Move the JSX into a child component rendered after the early return, so renders that take the early return never build it",
 	create: (context) => {
 		const inspectFunctionBody = (statements) => {
 			let memoNode = null;
@@ -59500,7 +60529,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 					if (callbackGuardTests.some((guardTest) => areConditionsStructurallyEqual(stmt.test, guardTest))) continue;
 					context.report({
 						node: memoNode,
-						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"
+						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"
 					});
 					return;
 				}
@@ -60003,6 +61032,7 @@ 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();
@@ -60135,6 +61165,717 @@ const isSetterCalledDuringRender = (root, setterName) => {
 	return found;
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/create-external-location-invalidation-checker.ts
+const HISTORY_LOCATION_MUTATION_METHOD_NAMES = new Set(["pushState", "replaceState"]);
+const AGGREGATE_MUTATION_METHOD_NAMES = new Set([...MUTATING_ARRAY_METHODS, ...MUTATING_COLLECTION_METHODS]);
+const OBJECT_AGGREGATE_MUTATION_METHOD_NAMES = new Set([
+	"assign",
+	"defineProperties",
+	"defineProperty",
+	"setPrototypeOf"
+]);
+const REFLECT_AGGREGATE_MUTATION_METHOD_NAMES = new Set([
+	"defineProperty",
+	"deleteProperty",
+	"set",
+	"setPrototypeOf"
+]);
+const LOCATION_CHANGE_EVENT_NAMES = new Set(["hashchange", "popstate"]);
+const containsGlobalLocationSnapshotRead = (node, scopes) => {
+	let didFindLocationSnapshotRead = false;
+	walkAst(node, (child) => {
+		if (didFindLocationSnapshotRead) return false;
+		if (child !== node && isFunctionLike$1(child) && !executesDuringRender(findTransparentExpressionRoot(child), scopes)) return false;
+		if (!isProvenGlobalNamespaceReference(child, "location", scopes)) return;
+		didFindLocationSnapshotRead = true;
+		return false;
+	});
+	return didFindLocationSnapshotRead;
+};
+const resolveExactLocalOrReactCallbackFunction = (expression, scopes) => {
+	const localFunction = resolveExactLocalFunction(expression, scopes);
+	if (isFunctionLike$1(localFunction)) return localFunction;
+	const unwrappedExpression = stripParenExpression(expression);
+	let callbackSource = unwrappedExpression;
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const callbackSymbol = resolveConstIdentifierAlias(unwrappedExpression, scopes);
+		if (callbackSymbol?.kind !== "const" || !callbackSymbol.initializer) return null;
+		callbackSource = callbackSymbol.initializer;
+	}
+	const unwrappedCallbackSource = stripParenExpression(callbackSource);
+	if (!isNodeOfType(unwrappedCallbackSource, "CallExpression") || !isReactApiCall(unwrappedCallbackSource, "useCallback", scopes, { resolveNamedAliases: true })) return null;
+	const callback = unwrappedCallbackSource.arguments?.[0];
+	if (!callback || isNodeOfType(callback, "SpreadElement")) return null;
+	return resolveExactLocalFunction(stripParenExpression(callback), scopes);
+};
+const bindingReadsExactGlobalLocationSnapshot = (bindingIdentifier, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const symbol = scopes.symbolFor(bindingIdentifier);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	if ((symbol.kind === "function" ? scopes.scopeFor(symbol.declarationNode) : symbol.scope).symbols.some((candidateSymbol) => candidateSymbol.name === symbol.name && candidateSymbol.references.some((reference) => reference.flag !== "read"))) return false;
+	const resolvedFunction = resolveExactLocalOrReactCallbackFunction(bindingIdentifier, scopes);
+	const initializer = isFunctionLike$1(resolvedFunction) ? resolvedFunction.body : getDirectUnreassignedInitializer(symbol);
+	if (!initializer) return false;
+	const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+	nextVisitedSymbolIds.add(symbol.id);
+	if (containsGlobalLocationSnapshotRead(initializer, scopes)) return true;
+	let didFindAliasedLocationSnapshotRead = false;
+	walkAst(initializer, (child) => {
+		if (didFindAliasedLocationSnapshotRead) return false;
+		if (child !== initializer && isFunctionLike$1(child) && !executesDuringRender(findTransparentExpressionRoot(child), scopes)) return false;
+		if (!isNodeOfType(child, "Identifier")) return;
+		if (bindingReadsExactGlobalLocationSnapshot(child, scopes, nextVisitedSymbolIds)) {
+			didFindAliasedLocationSnapshotRead = true;
+			return false;
+		}
+	});
+	return didFindAliasedLocationSnapshotRead;
+};
+const hasRenderReachableLocationSnapshotRead = (componentBody, renderReachableExpressions, directRenderNames, scopes) => {
+	if (renderReachableExpressions.some((expression) => containsGlobalLocationSnapshotRead(expression, scopes))) return true;
+	for (const statement of componentBody.body ?? []) {
+		if (isNodeOfType(statement, "FunctionDeclaration") && statement.id) {
+			if (directRenderNames.has(statement.id.name) && bindingReadsExactGlobalLocationSnapshot(statement.id, scopes)) return true;
+			continue;
+		}
+		if (!isNodeOfType(statement, "VariableDeclaration")) continue;
+		for (const declarator of statement.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier") || !declarator.init) continue;
+			if (!directRenderNames.has(declarator.id.name)) continue;
+			if (bindingReadsExactGlobalLocationSnapshot(declarator.id, scopes)) return true;
+		}
+	}
+	return false;
+};
+const isGlobalHistoryLocationMutation = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const methodName = getStaticPropertyName(callee);
+	return Boolean(methodName && HISTORY_LOCATION_MUTATION_METHOD_NAMES.has(methodName) && isProvenGlobalNamespaceReference(callee.object, "history", scopes));
+};
+const getStaticLocationChangeEvent = (node) => {
+	if (!node) return null;
+	const eventNameNode = stripParenExpression(node);
+	if (!isNodeOfType(eventNameNode, "Literal") || typeof eventNameNode.value !== "string") return null;
+	return LOCATION_CHANGE_EVENT_NAMES.has(eventNameNode.value) ? eventNameNode.value : null;
+};
+const addToSetIndex = (index, key, value) => {
+	const indexedValues = index.get(key) ?? /* @__PURE__ */ new Set();
+	indexedValues.add(value);
+	index.set(key, indexedValues);
+};
+const getSynchronousInvocationExpression = (functionNode, scopes) => {
+	const functionExpressionRoot = findTransparentExpressionRoot(functionNode);
+	if (!executesDuringRender(functionExpressionRoot, scopes)) return null;
+	const parent = functionExpressionRoot.parent;
+	return isNodeOfType(parent, "CallExpression") || isNodeOfType(parent, "NewExpression") ? parent : null;
+};
+const getLocationListenerOperation = (callExpression, scopes) => {
+	if (!isNodeOfType(callExpression, "CallExpression")) return null;
+	const callee = stripParenExpression(callExpression.callee);
+	const methodName = isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : isNodeOfType(callee, "Identifier") ? callee.name : null;
+	if (methodName !== "addEventListener" && methodName !== "removeEventListener") return null;
+	if (!(isNodeOfType(callee, "MemberExpression") ? isProvenGlobalObjectReference(callee.object, scopes) : isNodeOfType(callee, "Identifier") && scopes.isGlobalReference(callee))) return null;
+	const eventName = getStaticLocationChangeEvent(callExpression.arguments?.[0]);
+	if (!eventName) return null;
+	const listenerExpression = callExpression.arguments?.[1];
+	if (!listenerExpression || isNodeOfType(listenerExpression, "SpreadElement")) return null;
+	const listenerFunction = resolveExactLocalOrReactCallbackFunction(listenerExpression, scopes);
+	if (!isFunctionLike$1(listenerFunction)) return null;
+	const captureArgument = callExpression.arguments?.[2];
+	const capture = isNodeOfType(captureArgument, "SpreadElement") ? null : resolveEventListenerCapture(captureArgument, {
+		allowComputedString: true,
+		allowIndeterminateEntries: true
+	});
+	return {
+		operation: methodName === "addEventListener" ? "add" : "remove",
+		registration: {
+			callExpression,
+			listenerFunction,
+			capture,
+			eventName
+		}
+	};
+};
+const buildLocationInvalidationIndex = (componentBody, componentFunction, context) => {
+	const index = {
+		componentFunction,
+		context,
+		effectCallbacks: /* @__PURE__ */ new Set(),
+		expressionsByOwner: /* @__PURE__ */ new Map(),
+		historyMutationsByOwner: /* @__PURE__ */ new Map(),
+		awaitExpressionsByOwner: /* @__PURE__ */ new Map(),
+		callSitesByFunction: /* @__PURE__ */ new Map(),
+		calledFunctionByExpression: /* @__PURE__ */ new Map(),
+		synchronousInvocationsByFunction: /* @__PURE__ */ new Map(),
+		synchronousCallbacksByExpression: /* @__PURE__ */ new Map(),
+		callsByCalleeSymbolId: /* @__PURE__ */ new Map(),
+		identifierCalls: /* @__PURE__ */ new Set(),
+		listenerRegistrations: [],
+		listenerRemovals: [],
+		mountedListenerFunctions: /* @__PURE__ */ new Set(),
+		mutationExecutionsByOwner: /* @__PURE__ */ new Map(),
+		synchronousMutationResultByFunction: /* @__PURE__ */ new Map()
+	};
+	walkAst(componentBody, (child) => {
+		if (isFunctionLike$1(child)) {
+			const invocationExpression = getSynchronousInvocationExpression(child, context.scopes);
+			if (invocationExpression) {
+				addToSetIndex(index.synchronousInvocationsByFunction, child, invocationExpression);
+				addToSetIndex(index.synchronousCallbacksByExpression, invocationExpression, child);
+			}
+			return;
+		}
+		const owner = context.cfg.enclosingFunction(child);
+		if (!owner) return;
+		if (isNodeOfType(child, "AwaitExpression")) {
+			addToSetIndex(index.awaitExpressionsByOwner, owner, child);
+			return;
+		}
+		if (!isNodeOfType(child, "CallExpression") && !isNodeOfType(child, "NewExpression")) return;
+		addToSetIndex(index.expressionsByOwner, owner, child);
+		if (isNodeOfType(child, "CallExpression")) {
+			if (isGlobalHistoryLocationMutation(child, context.scopes)) addToSetIndex(index.historyMutationsByOwner, owner, child);
+			if (isNodeOfType(stripParenExpression(child.callee), "Identifier")) index.identifierCalls.add(child);
+			const calledFunction = resolveExactLocalOrReactCallbackFunction(child.callee, context.scopes);
+			if (isFunctionLike$1(calledFunction)) {
+				addToSetIndex(index.callSitesByFunction, calledFunction, child);
+				index.calledFunctionByExpression.set(child, calledFunction);
+			}
+			if (context.cfg.enclosingFunction(child) === componentFunction && isReactApiCall(child, EFFECT_HOOK_NAMES$1, context.scopes, {
+				allowGlobalReactNamespace: true,
+				allowUnboundBareCalls: true,
+				resolveNamedAliases: true
+			})) {
+				const effectCallback = getEffectCallback(child, context.scopes);
+				if (isFunctionLike$1(effectCallback)) index.effectCallbacks.add(effectCallback);
+			}
+			const listenerOperation = getLocationListenerOperation(child, context.scopes);
+			if (listenerOperation?.operation === "add") index.listenerRegistrations.push(listenerOperation.registration);
+			else if (listenerOperation) index.listenerRemovals.push(listenerOperation.registration);
+		}
+	});
+	return index;
+};
+const isDescendantWithoutFunctionBoundary = (descendant, ancestor) => {
+	let current = descendant;
+	while (current && current !== ancestor) {
+		if (current !== descendant && isFunctionLike$1(current)) return false;
+		current = current.parent;
+	}
+	return current === ancestor;
+};
+const areInMutuallyExclusiveConditionalBranches = (firstNode, secondNode) => {
+	const firstBranches = /* @__PURE__ */ new Map();
+	let current = firstNode;
+	while (current?.parent) {
+		const parent = current.parent;
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === current || parent.alternate === current)) firstBranches.set(parent, current);
+		if (current !== firstNode && isFunctionLike$1(current)) break;
+		current = parent;
+	}
+	current = secondNode;
+	while (current?.parent) {
+		const parent = current.parent;
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === current || parent.alternate === current)) {
+			const firstBranch = firstBranches.get(parent);
+			if (firstBranch && firstBranch !== current) return true;
+		}
+		if (current !== secondNode && isFunctionLike$1(current)) break;
+		current = parent;
+	}
+	return false;
+};
+const collectStableBooleanGuardConstraints = (node, functionBoundary, scopes) => {
+	const constraintsBySymbolId = /* @__PURE__ */ new Map();
+	const recordConstraint = (test, requiredTestValue) => {
+		let expression = stripParenExpression(test);
+		let requiredValue = requiredTestValue;
+		while (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") {
+			requiredValue = !requiredValue;
+			expression = stripParenExpression(expression.argument);
+		}
+		if (!isNodeOfType(expression, "Identifier")) return;
+		const symbol = scopes.symbolFor(expression);
+		if (!symbol || symbol.references.some((reference) => reference.flag !== "read")) return;
+		const existingConstraint = constraintsBySymbolId.get(symbol.id);
+		constraintsBySymbolId.set(symbol.id, existingConstraint === void 0 || existingConstraint === requiredValue ? requiredValue : null);
+	};
+	let current = node;
+	while (current?.parent && current !== functionBoundary) {
+		const parent = current.parent;
+		if (isNodeOfType(parent, "IfStatement")) {
+			if (parent.consequent === current) recordConstraint(parent.test, true);
+			if (parent.alternate === current) recordConstraint(parent.test, false);
+		} else if (isNodeOfType(parent, "ConditionalExpression")) {
+			if (parent.consequent === current) recordConstraint(parent.test, true);
+			if (parent.alternate === current) recordConstraint(parent.test, false);
+		} else if (isNodeOfType(parent, "LogicalExpression") && parent.right === current) {
+			if (parent.operator === "&&") recordConstraint(parent.left, true);
+			if (parent.operator === "||") recordConstraint(parent.left, false);
+		}
+		if (current !== node && isFunctionLike$1(current)) break;
+		current = parent;
+	}
+	return constraintsBySymbolId;
+};
+const haveContradictoryStableBooleanGuards = (firstNode, secondNode, functionBoundary, scopes) => {
+	const firstConstraints = collectStableBooleanGuardConstraints(firstNode, functionBoundary, scopes);
+	const secondConstraints = collectStableBooleanGuardConstraints(secondNode, functionBoundary, scopes);
+	for (const requiredValue of firstConstraints.values()) if (requiredValue === null) return true;
+	for (const requiredValue of secondConstraints.values()) if (requiredValue === null) return true;
+	for (const [symbolId, firstRequiredValue] of firstConstraints) {
+		const secondRequiredValue = secondConstraints.get(symbolId);
+		if (firstRequiredValue !== null && secondRequiredValue !== void 0 && secondRequiredValue !== null && firstRequiredValue !== secondRequiredValue) return true;
+	}
+	return false;
+};
+const isInsideIntrinsicReactEventHandlerAttribute = (node, functionBoundary) => {
+	let current = node;
+	while (current && current !== functionBoundary) {
+		if (isEventHandlerAttribute(current) && isJsxAttributeOnIntrinsicHtmlElement(current)) return true;
+		current = current.parent;
+	}
+	return false;
+};
+const getTransparentExpressionBindingIdentifier = (expression) => {
+	const expressionRoot = findTransparentExpressionRoot(expression);
+	const parent = expressionRoot.parent;
+	if (isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) return parent.id;
+	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === expressionRoot && isNodeOfType(parent.left, "Identifier")) return parent.left;
+	return null;
+};
+const getIntrinsicReactEventHandlerBindingIdentifier = (functionNode, index) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
+	const functionExpressionRoot = findTransparentExpressionRoot(functionNode);
+	const directTransparentBindingIdentifier = getTransparentExpressionBindingIdentifier(functionExpressionRoot);
+	if (directTransparentBindingIdentifier) return directTransparentBindingIdentifier;
+	const callbackCall = functionExpressionRoot.parent;
+	if (!isNodeOfType(callbackCall, "CallExpression") || callbackCall.arguments?.[0] !== functionExpressionRoot || !isReactApiCall(callbackCall, "useCallback", index.context.scopes, { resolveNamedAliases: true })) return null;
+	return getTransparentExpressionBindingIdentifier(callbackCall);
+};
+const isExclusiveIntrinsicReactEventHandler = (functionNode, index) => {
+	const bindingIdentifier = getIntrinsicReactEventHandlerBindingIdentifier(functionNode, index);
+	if (!bindingIdentifier) return isInsideIntrinsicReactEventHandlerAttribute(functionNode, index.componentFunction);
+	const bindingSymbol = index.context.scopes.symbolFor(bindingIdentifier);
+	return Boolean(bindingSymbol && bindingSymbol.references.length > 0 && bindingSymbol.references.every((reference) => isInsideIntrinsicReactEventHandlerAttribute(reference.identifier, index.componentFunction)));
+};
+const canNodeReachNode = (sourceNode, targetNode, index) => {
+	const { context } = index;
+	if (!isNodeReachableWithinFunction(sourceNode, context)) return false;
+	if (!isNodeReachableWithinFunction(targetNode, context)) return false;
+	const sourceOwner = context.cfg.enclosingFunction(sourceNode);
+	const targetOwner = context.cfg.enclosingFunction(targetNode);
+	if (!sourceOwner || sourceOwner !== targetOwner) return false;
+	if (areInMutuallyExclusiveConditionalBranches(sourceNode, targetNode)) return false;
+	if (haveContradictoryStableBooleanGuards(sourceNode, targetNode, sourceOwner, context.scopes)) return false;
+	if (isDescendantWithoutFunctionBoundary(targetNode, sourceNode)) return false;
+	if (isDescendantWithoutFunctionBoundary(sourceNode, targetNode)) return true;
+	const functionCfg = context.cfg.cfgFor(sourceOwner);
+	const sourceBlock = functionCfg?.blockOf(sourceNode);
+	const targetBlock = functionCfg?.blockOf(targetNode);
+	if (!functionCfg || !sourceBlock || !targetBlock) return false;
+	if (sourceBlock === targetBlock) {
+		const sourceStart = getRangeStart(sourceNode);
+		const targetStart = getRangeStart(targetNode);
+		return sourceStart !== null && targetStart !== null && sourceStart < targetStart;
+	}
+	const visitedBlocks = new Set([sourceBlock]);
+	const pendingBlocks = sourceBlock.successors.filter((edge) => edge.kind !== "throw").map((edge) => edge.to);
+	while (pendingBlocks.length > 0) {
+		const block = pendingBlocks.pop();
+		if (!block || visitedBlocks.has(block)) continue;
+		if (block === targetBlock) return true;
+		visitedBlocks.add(block);
+		for (const edge of block.successors) if (edge.kind !== "throw") pendingBlocks.push(edge.to);
+	}
+	return false;
+};
+const getInlineIntrinsicHandlerJsxElement = (functionNode) => {
+	let currentNode = functionNode;
+	while (currentNode) {
+		if (isNodeOfType(currentNode, "JSXAttribute") && isEventHandlerAttribute(currentNode) && isJsxAttributeOnIntrinsicHtmlElement(currentNode)) {
+			const openingElement = currentNode.parent;
+			return isNodeOfType(openingElement?.parent, "JSXElement") ? openingElement.parent : null;
+		}
+		if (currentNode !== functionNode && isFunctionLike$1(currentNode)) return null;
+		currentNode = currentNode.parent;
+	}
+	return null;
+};
+const isProvenNonEscapingVoidRead = (identifier) => {
+	const expressionRoot = findTransparentExpressionRoot(identifier);
+	return isNodeOfType(expressionRoot.parent, "UnaryExpression") && expressionRoot.parent.operator === "void" && expressionRoot.parent.argument === expressionRoot;
+};
+const getDirectReadonlyValueAliasSymbol = (referenceIdentifier, sourceSymbol, index) => {
+	const referenceRoot = findTransparentExpressionRoot(referenceIdentifier);
+	const parent = referenceRoot.parent;
+	if (isNodeOfType(parent, "VariableDeclarator") && parent.init === referenceRoot && isNodeOfType(parent.id, "Identifier")) {
+		const aliasSymbol = index.context.scopes.symbolFor(parent.id);
+		const aliasInitializer = aliasSymbol ? getDirectConstInitializer(aliasSymbol) : null;
+		const unwrappedInitializer = aliasInitializer ? stripParenExpression(aliasInitializer) : null;
+		return aliasSymbol && isNodeOfType(unwrappedInitializer, "Identifier") && index.context.scopes.symbolFor(unwrappedInitializer) === sourceSymbol ? aliasSymbol : null;
+	}
+	if (!isNodeOfType(parent, "CallExpression") || parent.arguments?.[0] !== referenceRoot || !isReactApiCall(parent, "useCallback", index.context.scopes, { resolveNamedAliases: true })) return null;
+	const callbackResultRoot = findTransparentExpressionRoot(parent);
+	const resultParent = callbackResultRoot.parent;
+	if (!isNodeOfType(resultParent, "VariableDeclarator") || resultParent.init !== callbackResultRoot || !isNodeOfType(resultParent.id, "Identifier")) return null;
+	const callbackResultSymbol = index.context.scopes.symbolFor(resultParent.id);
+	return callbackResultSymbol && getDirectConstInitializer(callbackResultSymbol) === callbackResultRoot ? callbackResultSymbol : null;
+};
+const isKnownAggregateMutationReference = (referenceIdentifier, index) => {
+	const referenceRoot = findTransparentExpressionRoot(referenceIdentifier);
+	const parent = referenceRoot.parent;
+	if (isNodeOfType(parent, "MemberExpression") && parent.object === referenceRoot) {
+		const memberRoot = findTransparentExpressionRoot(parent);
+		const callExpression = memberRoot.parent;
+		const methodName = getStaticPropertyName(parent);
+		if (isNodeOfType(callExpression, "CallExpression") && callExpression.callee === memberRoot && methodName !== null && AGGREGATE_MUTATION_METHOD_NAMES.has(methodName)) return true;
+	}
+	if (!isNodeOfType(parent, "CallExpression") || parent.arguments?.[0] !== referenceRoot) return false;
+	const callee = stripParenExpression(parent.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const methodName = getStaticPropertyName(callee);
+	if (methodName === null) return false;
+	return OBJECT_AGGREGATE_MUTATION_METHOD_NAMES.has(methodName) && isProvenGlobalNamespaceReference(callee.object, "Object", index.context.scopes) || REFLECT_AGGREGATE_MUTATION_METHOD_NAMES.has(methodName) && isProvenGlobalNamespaceReference(callee.object, "Reflect", index.context.scopes);
+};
+const collectExactReadonlyValueEscapeAnchors = (symbol, index, valueFunctionNode, options = {}, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (visitedSymbolIds.has(symbol.id)) return null;
+	if (symbol.references.some((reference) => reference.flag !== "read" || isWithinAssignmentTarget(reference.identifier) || options.rejectKnownMutations && isKnownAggregateMutationReference(reference.identifier, index))) return null;
+	const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+	nextVisitedSymbolIds.add(symbol.id);
+	const escapeAnchors = [];
+	for (const reference of symbol.references) {
+		if (valueFunctionNode && index.context.cfg.enclosingFunction(reference.identifier) === valueFunctionNode || isProvenNonEscapingVoidRead(reference.identifier)) continue;
+		const aliasSymbol = getDirectReadonlyValueAliasSymbol(reference.identifier, symbol, index);
+		if (!aliasSymbol) {
+			escapeAnchors.push(reference.identifier);
+			continue;
+		}
+		const aliasEscapeAnchors = collectExactReadonlyValueEscapeAnchors(aliasSymbol, index, valueFunctionNode, options, nextVisitedSymbolIds);
+		if (!aliasEscapeAnchors) return null;
+		escapeAnchors.push(...aliasEscapeAnchors);
+	}
+	return escapeAnchors.length > 0 ? escapeAnchors : null;
+};
+const findReadonlyJsxAggregateRoot = (jsxElement) => {
+	let aggregateRoot = findTransparentExpressionRoot(jsxElement);
+	while (aggregateRoot.parent) {
+		const parent = aggregateRoot.parent;
+		if ((isNodeOfType(parent, "JSXElement") || isNodeOfType(parent, "JSXFragment")) && parent.children?.some((child) => child === aggregateRoot)) {
+			aggregateRoot = parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "ArrayExpression") && parent.elements?.some((element) => element === aggregateRoot)) {
+			aggregateRoot = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		if (isNodeOfType(parent, "Property") && parent.value === aggregateRoot && parent.kind === "init" && !parent.computed && isNodeOfType(parent.parent, "ObjectExpression")) {
+			aggregateRoot = findTransparentExpressionRoot(parent.parent);
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === aggregateRoot || parent.alternate === aggregateRoot)) {
+			aggregateRoot = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && (parent.right === aggregateRoot || parent.left === aggregateRoot && parent.operator !== "&&")) {
+			aggregateRoot = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		if (isNodeOfType(parent, "SequenceExpression") && getFinalSequenceExpressionValue(parent) === getFinalSequenceExpressionValue(aggregateRoot)) {
+			aggregateRoot = findTransparentExpressionRoot(parent);
+			continue;
+		}
+		break;
+	}
+	return aggregateRoot;
+};
+const getReadonlyJsxValueEscapeAnchors = (jsxElement, index) => {
+	const jsxValueRoot = findReadonlyJsxAggregateRoot(jsxElement);
+	const parent = jsxValueRoot.parent;
+	if (!isNodeOfType(parent, "VariableDeclarator") || parent.init !== jsxValueRoot) return [jsxValueRoot];
+	if (!isNodeOfType(parent.id, "Identifier")) return null;
+	const bindingSymbol = index.context.scopes.symbolFor(parent.id);
+	if (!bindingSymbol || getDirectConstInitializer(bindingSymbol) !== jsxValueRoot) return null;
+	return collectExactReadonlyValueEscapeAnchors(bindingSymbol, index, null, { rejectKnownMutations: true });
+};
+const getExclusiveIntrinsicReactEventHandlerAnchors = (functionNode, index) => {
+	if (!isExclusiveIntrinsicReactEventHandler(functionNode, index)) return null;
+	const bindingIdentifier = getIntrinsicReactEventHandlerBindingIdentifier(functionNode, index);
+	if (!bindingIdentifier) {
+		const jsxElement = getInlineIntrinsicHandlerJsxElement(functionNode);
+		return jsxElement ? getReadonlyJsxValueEscapeAnchors(jsxElement, index) : null;
+	}
+	return index.context.scopes.symbolFor(bindingIdentifier)?.references.map((reference) => reference.identifier) ?? null;
+};
+const getReadonlyFunctionEscapeAnchors = (functionNode, index) => {
+	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
+	if (!bindingIdentifier) return null;
+	const bindingSymbol = index.context.scopes.symbolFor(bindingIdentifier);
+	if (!bindingSymbol || resolveExactLocalFunction(bindingIdentifier, index.context.scopes) !== functionNode) return null;
+	return collectExactReadonlyValueEscapeAnchors(bindingSymbol, index, functionNode);
+};
+const isAliasInitializedBeforeExecution = (aliasDeclaration, executionNode, index, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
+	if (!isNodeReachableWithinFunction(aliasDeclaration, index.context)) return false;
+	const aliasOwner = index.context.cfg.enclosingFunction(aliasDeclaration);
+	const executionOwner = index.context.cfg.enclosingFunction(executionNode);
+	if (!aliasOwner || !executionOwner) return false;
+	if (aliasOwner === executionOwner) return canNodeReachNode(aliasDeclaration, executionNode, index);
+	if (visitedFunctionNodes.has(executionOwner)) return false;
+	const nextVisitedFunctionNodes = new Set(visitedFunctionNodes);
+	nextVisitedFunctionNodes.add(executionOwner);
+	if (aliasOwner === index.componentFunction && (index.effectCallbacks.has(executionOwner) || index.mountedListenerFunctions.has(executionOwner))) return doNodesCoverEveryPathFromFunctionEntry(index.componentFunction, [aliasDeclaration], index.context, { ignoreThrowEdges: true });
+	const invocations = new Set([...index.callSitesByFunction.get(executionOwner) ?? [], ...index.synchronousInvocationsByFunction.get(executionOwner) ?? []]);
+	if (invocations.size > 0) return [...invocations].every((invocation) => isAliasInitializedBeforeExecution(aliasDeclaration, invocation, index, nextVisitedFunctionNodes));
+	const deferredExecutionAnchors = getExclusiveIntrinsicReactEventHandlerAnchors(executionOwner, index);
+	if (deferredExecutionAnchors) return deferredExecutionAnchors.every((anchor) => isAliasInitializedBeforeExecution(aliasDeclaration, anchor, index, nextVisitedFunctionNodes));
+	const functionEscapeAnchors = getReadonlyFunctionEscapeAnchors(executionOwner, index);
+	return Boolean(functionEscapeAnchors?.every((anchor) => isAliasInitializedBeforeExecution(aliasDeclaration, anchor, index, nextVisitedFunctionNodes)));
+};
+const resolveExactReadonlyCalleeSymbolId = (callExpression, index) => {
+	if (!isNodeOfType(callExpression, "CallExpression")) return null;
+	const callee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(callee, "Identifier")) return null;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let symbol = index.context.scopes.symbolFor(callee);
+	while (symbol) {
+		if (visitedSymbolIds.has(symbol.id)) return null;
+		visitedSymbolIds.add(symbol.id);
+		const initializer = getDirectConstInitializer(symbol);
+		if (!initializer) return symbol.id;
+		if (symbol.references.some((reference) => reference.flag !== "read" || isWithinAssignmentTarget(reference.identifier)) || !isAliasInitializedBeforeExecution(symbol.declarationNode, callExpression, index)) return null;
+		const unwrappedInitializer = stripParenExpression(initializer);
+		if (!isNodeOfType(unwrappedInitializer, "Identifier")) return symbol.id;
+		const initializerSymbol = index.context.scopes.symbolFor(unwrappedInitializer);
+		if (!initializerSymbol || !isAliasInitializedBeforeExecution(initializerSymbol.declarationNode, symbol.declarationNode, index)) return null;
+		symbol = initializerSymbol;
+	}
+	return null;
+};
+const collectExactReadonlyCalleeCalls = (index) => {
+	for (const callExpression of index.identifierCalls) {
+		const calleeSymbolId = resolveExactReadonlyCalleeSymbolId(callExpression, index);
+		if (calleeSymbolId !== null) addToSetIndex(index.callsByCalleeSymbolId, calleeSymbolId, callExpression);
+	}
+};
+const canNodeReachNormalFunctionExit = (node, functionNode, index) => {
+	const functionCfg = index.context.cfg.cfgFor(functionNode);
+	const sourceBlock = functionCfg?.blockOf(node);
+	if (!functionCfg || !sourceBlock) return false;
+	const visitedBlocks = /* @__PURE__ */ new Set();
+	const pendingBlocks = [sourceBlock];
+	while (pendingBlocks.length > 0) {
+		const block = pendingBlocks.pop();
+		if (!block || visitedBlocks.has(block)) continue;
+		visitedBlocks.add(block);
+		for (const edge of block.successors) {
+			if (edge.kind === "throw") continue;
+			if (edge.to === functionCfg.exit) return true;
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return false;
+};
+const canExecuteBeforeAsyncSuspension = (node, functionNode, index) => {
+	if (!isFunctionLike$1(functionNode) || !functionNode.async) return isNodeReachableWithinFunction(node, index.context);
+	const functionCfg = index.context.cfg.cfgFor(functionNode);
+	const targetBlock = functionCfg?.blockOf(node);
+	if (!functionCfg || !targetBlock) return false;
+	const awaitsByBlock = /* @__PURE__ */ new Map();
+	for (const awaitExpression of index.awaitExpressionsByOwner.get(functionNode) ?? []) {
+		const awaitBlock = functionCfg.blockOf(awaitExpression);
+		if (!awaitBlock) continue;
+		const blockAwaits = awaitsByBlock.get(awaitBlock) ?? [];
+		blockAwaits.push(awaitExpression);
+		awaitsByBlock.set(awaitBlock, blockAwaits);
+	}
+	const visitedBlocks = /* @__PURE__ */ new Set();
+	const pendingBlocks = [functionCfg.entry];
+	const targetStart = getRangeStart(node);
+	while (pendingBlocks.length > 0) {
+		const block = pendingBlocks.pop();
+		if (!block || visitedBlocks.has(block)) continue;
+		visitedBlocks.add(block);
+		const blockAwaits = awaitsByBlock.get(block) ?? [];
+		if (block === targetBlock) return !blockAwaits.some((awaitExpression) => {
+			if (isNodeOfType(awaitExpression, "AwaitExpression") && isDescendantWithoutFunctionBoundary(node, awaitExpression.argument)) return false;
+			if (isDescendantWithoutFunctionBoundary(awaitExpression, node)) return true;
+			const awaitStart = getRangeStart(awaitExpression);
+			return awaitStart !== null && targetStart !== null && awaitStart < targetStart;
+		});
+		if (blockAwaits.length > 0) continue;
+		for (const edge of block.successors) if (edge.kind !== "throw") pendingBlocks.push(edge.to);
+	}
+	return false;
+};
+const canReactBatchMutationAfterExecution = (executionNode, mutationNode, owner, index) => (isExclusiveIntrinsicReactEventHandler(owner, index) || index.effectCallbacks.has(owner)) && canNodeReachNode(executionNode, mutationNode, index) && canExecuteBeforeAsyncSuspension(mutationNode, owner, index) && canNodeReachNormalFunctionExit(mutationNode, owner, index);
+const functionMaySynchronouslyMutateLocation = (functionNode, index, visitingFunctions, cycleAffectedFunctions) => {
+	const cachedResult = index.synchronousMutationResultByFunction.get(functionNode);
+	if (cachedResult !== void 0) return cachedResult;
+	if (!isFunctionLike$1(functionNode) || functionNode.generator) return false;
+	if (visitingFunctions.has(functionNode)) {
+		let didReachCycleEntry = false;
+		for (const visitingFunction of visitingFunctions) {
+			if (visitingFunction === functionNode) didReachCycleEntry = true;
+			if (didReachCycleEntry) cycleAffectedFunctions.add(visitingFunction);
+		}
+		return false;
+	}
+	visitingFunctions.add(functionNode);
+	const doesMutateSynchronously = [...collectLocationMutationExecutions(functionNode, index, visitingFunctions, cycleAffectedFunctions)].some((mutationExecution) => canExecuteBeforeAsyncSuspension(mutationExecution, functionNode, index) && canNodeReachNormalFunctionExit(mutationExecution, functionNode, index));
+	visitingFunctions.delete(functionNode);
+	if (doesMutateSynchronously || !cycleAffectedFunctions.has(functionNode)) index.synchronousMutationResultByFunction.set(functionNode, doesMutateSynchronously);
+	return doesMutateSynchronously;
+};
+const collectLocationMutationExecutions = (functionNode, index, visitingFunctions = /* @__PURE__ */ new Set(), cycleAffectedFunctions = /* @__PURE__ */ new Set()) => {
+	const cachedExecutions = index.mutationExecutionsByOwner.get(functionNode);
+	if (cachedExecutions) return cachedExecutions;
+	const mutationExecutions = new Set(index.historyMutationsByOwner.get(functionNode) ?? []);
+	for (const expression of index.expressionsByOwner.get(functionNode) ?? []) {
+		const calledFunction = index.calledFunctionByExpression.get(expression);
+		if (calledFunction && functionMaySynchronouslyMutateLocation(calledFunction, index, visitingFunctions, cycleAffectedFunctions)) mutationExecutions.add(expression);
+		for (const callbackFunction of index.synchronousCallbacksByExpression.get(expression) ?? []) if (functionMaySynchronouslyMutateLocation(callbackFunction, index, visitingFunctions, cycleAffectedFunctions)) mutationExecutions.add(expression);
+	}
+	if (!cycleAffectedFunctions.has(functionNode)) index.mutationExecutionsByOwner.set(functionNode, mutationExecutions);
+	return mutationExecutions;
+};
+const isDefinitelyMatchingLocationListenerRemoval = (registration, removal) => registration.eventName === removal.eventName && registration.listenerFunction === removal.listenerFunction && registration.capture !== null && removal.capture !== null && registration.capture === removal.capture;
+const functionMustSynchronouslyRemoveLocationListener = (functionNode, registration, index, visitingFunctions) => {
+	if (!isFunctionLike$1(functionNode) || functionNode.generator) return false;
+	if (visitingFunctions.has(functionNode)) return false;
+	const nextVisitingFunctions = new Set(visitingFunctions);
+	nextVisitingFunctions.add(functionNode);
+	const removalExecutions = [];
+	for (const removal of index.listenerRemovals) {
+		if (!isDefinitelyMatchingLocationListenerRemoval(registration, removal)) continue;
+		if (index.context.cfg.enclosingFunction(removal.callExpression) !== functionNode) continue;
+		if (canExecuteBeforeAsyncSuspension(removal.callExpression, functionNode, index)) removalExecutions.push(removal.callExpression);
+	}
+	for (const expression of index.expressionsByOwner.get(functionNode) ?? []) {
+		const calledFunction = index.calledFunctionByExpression.get(expression);
+		if (calledFunction && canExecuteBeforeAsyncSuspension(expression, functionNode, index) && functionMustSynchronouslyRemoveLocationListener(calledFunction, registration, index, nextVisitingFunctions)) removalExecutions.push(expression);
+	}
+	return doNodesCoverEveryPathFromFunctionEntry(functionNode, removalExecutions, index.context);
+};
+const collectSynchronousLocationListenerRemovalExecutions = (functionNode, registration, index) => {
+	const removalExecutions = /* @__PURE__ */ new Set();
+	for (const removal of index.listenerRemovals) if (isDefinitelyMatchingLocationListenerRemoval(registration, removal) && index.context.cfg.enclosingFunction(removal.callExpression) === functionNode && canExecuteBeforeAsyncSuspension(removal.callExpression, functionNode, index)) removalExecutions.add(removal.callExpression);
+	for (const expression of index.expressionsByOwner.get(functionNode) ?? []) {
+		const calledFunction = index.calledFunctionByExpression.get(expression);
+		if (calledFunction && canExecuteBeforeAsyncSuspension(expression, functionNode, index) && functionMustSynchronouslyRemoveLocationListener(calledFunction, registration, index, /* @__PURE__ */ new Set())) removalExecutions.add(expression);
+	}
+	return removalExecutions;
+};
+const collectImpliedExpressionExecutionBoundaries = (node, owner) => {
+	const expressionBoundaries = [];
+	let currentChild = node;
+	let currentParent = currentChild.parent ?? null;
+	while (currentParent && currentParent !== owner) {
+		if (isNodeOfType(currentParent, "ConditionalExpression") && currentParent.test === currentChild) {
+			const staticTestValue = readStaticBoolean(getFinalSequenceExpressionValue(currentParent.test));
+			if (staticTestValue !== null) expressionBoundaries.push(staticTestValue ? currentParent.consequent : currentParent.alternate);
+		}
+		if (isNodeOfType(currentParent, "LogicalExpression") && currentParent.left === currentChild) {
+			const staticLeftValue = readStaticBoolean(getFinalSequenceExpressionValue(currentParent.left));
+			if (currentParent.operator === "&&" && staticLeftValue === true || currentParent.operator === "||" && staticLeftValue === false) expressionBoundaries.push(currentParent.right);
+		}
+		if (isNodeOfType(currentParent, "ConditionalExpression") && (currentParent.consequent === currentChild || currentParent.alternate === currentChild) || isNodeOfType(currentParent, "LogicalExpression") && currentParent.right === currentChild || isNodeOfType(currentParent, "AssignmentPattern") && currentParent.right === currentChild) expressionBoundaries.push(currentChild);
+		currentChild = currentParent;
+		currentParent = currentChild.parent ?? null;
+	}
+	return expressionBoundaries;
+};
+const canExecutionReachFunctionExitWithoutListenerRemoval = (executionNode, registration, index) => {
+	if (!isNodeReachableWithinFunction(executionNode, index.context)) return false;
+	const owner = index.context.cfg.enclosingFunction(executionNode);
+	if (!owner) return false;
+	const functionCfg = index.context.cfg.cfgFor(owner);
+	const sourceBlock = functionCfg?.blockOf(executionNode);
+	if (!functionCfg || !sourceBlock) return false;
+	const expressionBoundaries = collectImpliedExpressionExecutionBoundaries(executionNode, owner);
+	const matchingRemovalsByBlock = /* @__PURE__ */ new Map();
+	for (const removalExecution of collectSynchronousLocationListenerRemovalExecutions(owner, registration, index)) {
+		const removalBlock = functionCfg.blockOf(removalExecution);
+		if (!removalBlock) continue;
+		const blockRemovals = matchingRemovalsByBlock.get(removalBlock) ?? [];
+		blockRemovals.push(removalExecution);
+		matchingRemovalsByBlock.set(removalBlock, blockRemovals);
+	}
+	const sourceStart = getRangeStart(executionNode);
+	const hasRemovalAfterExecution = (block) => {
+		const removals = (matchingRemovalsByBlock.get(block) ?? []).filter((removal) => {
+			if (block !== sourceBlock) return true;
+			const removalStart = getRangeStart(removal);
+			return sourceStart !== null && removalStart !== null && sourceStart < removalStart;
+		});
+		if (collectExpressionPathCoverageNodes(owner, removals, index.context).size > 0) return true;
+		if (block !== sourceBlock) return false;
+		return expressionBoundaries.some((expressionBoundary) => collectExpressionPathCoverageNodes(owner, removals, index.context, expressionBoundary).size > 0);
+	};
+	const visitedBlocks = /* @__PURE__ */ new Set();
+	const pendingBlocks = [sourceBlock];
+	while (pendingBlocks.length > 0) {
+		const block = pendingBlocks.pop();
+		if (!block || visitedBlocks.has(block)) continue;
+		visitedBlocks.add(block);
+		if (hasRemovalAfterExecution(block)) continue;
+		for (const edge of block.successors) {
+			if (edge.kind === "throw") continue;
+			if (edge.to === functionCfg.exit) return true;
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return false;
+};
+const isListenerActiveAtMountedExit = (executionNode, registration, index, visitedExecutions = /* @__PURE__ */ new Set()) => {
+	if (visitedExecutions.has(executionNode)) return false;
+	if (!canExecutionReachFunctionExitWithoutListenerRemoval(executionNode, registration, index)) return false;
+	const owner = index.context.cfg.enclosingFunction(executionNode);
+	if (!owner) return false;
+	if (owner === index.componentFunction || index.effectCallbacks.has(owner)) return true;
+	const nextVisitedExecutions = new Set(visitedExecutions);
+	nextVisitedExecutions.add(executionNode);
+	for (const callSite of index.callSitesByFunction.get(owner) ?? []) if (isListenerActiveAtMountedExit(callSite, registration, index, nextVisitedExecutions)) return true;
+	for (const invocation of index.synchronousInvocationsByFunction.get(owner) ?? []) if (isListenerActiveAtMountedExit(invocation, registration, index, nextVisitedExecutions)) return true;
+	return false;
+};
+const collectMountedListenerFunctions = (index) => {
+	for (const registration of index.listenerRegistrations) if (isListenerActiveAtMountedExit(registration.callExpression, registration, index)) index.mountedListenerFunctions.add(registration.listenerFunction);
+};
+const setterArgumentMutatesLocation = (setterCall, index) => {
+	if (!isNodeOfType(setterCall, "CallExpression")) return false;
+	return (setterCall.arguments ?? []).some((argument) => {
+		if (isNodeOfType(argument, "SpreadElement")) return false;
+		const updaterFunction = resolveExactLocalFunction(argument, index.context.scopes);
+		return Boolean(isFunctionLike$1(updaterFunction) && functionMaySynchronouslyMutateLocation(updaterFunction, index, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()));
+	});
+};
+const executionAnchorInvalidatesLocationSnapshot = (executionAnchor, index, visitedExecutions = /* @__PURE__ */ new Set()) => {
+	if (visitedExecutions.has(executionAnchor)) return false;
+	if (!isNodeReachableWithinFunction(executionAnchor, index.context)) return false;
+	const owner = index.context.cfg.enclosingFunction(executionAnchor);
+	if (!owner) return false;
+	if (index.mountedListenerFunctions.has(owner)) return true;
+	if (setterArgumentMutatesLocation(executionAnchor, index) || [...collectLocationMutationExecutions(owner, index)].some((mutationExecution) => canNodeReachNode(mutationExecution, executionAnchor, index) || canReactBatchMutationAfterExecution(executionAnchor, mutationExecution, owner, index))) return true;
+	const nextVisitedExecutions = new Set(visitedExecutions);
+	nextVisitedExecutions.add(executionAnchor);
+	for (const callSite of index.callSitesByFunction.get(owner) ?? []) if (executionAnchorInvalidatesLocationSnapshot(callSite, index, nextVisitedExecutions)) return true;
+	for (const invocation of index.synchronousInvocationsByFunction.get(owner) ?? []) if (executionAnchorInvalidatesLocationSnapshot(invocation, index, nextVisitedExecutions)) return true;
+	return false;
+};
+const setterInvalidatesGlobalLocationSnapshot = (setterBindingIdentifier, index) => {
+	const setterSymbol = index.context.scopes.symbolFor(setterBindingIdentifier);
+	if (!setterSymbol) return false;
+	return [...index.callsByCalleeSymbolId.get(setterSymbol.id) ?? []].some((setterCall) => executionAnchorInvalidatesLocationSnapshot(setterCall, index));
+};
+const createExternalLocationInvalidationChecker = ({ componentBody, componentFunction, context, directRenderNames, renderReachableExpressions }) => {
+	if (!hasRenderReachableLocationSnapshotRead(componentBody, renderReachableExpressions, directRenderNames, context.scopes)) return () => false;
+	const locationInvalidationIndex = buildLocationInvalidationIndex(componentBody, componentFunction, context);
+	collectMountedListenerFunctions(locationInvalidationIndex);
+	collectExactReadonlyCalleeCalls(locationInvalidationIndex);
+	return (setterBindingIdentifier) => setterInvalidatesGlobalLocationSnapshot(setterBindingIdentifier, locationInvalidationIndex);
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/rerender-state-only-in-handlers.ts
 const isInsideConditionTest = (identifier, stopAt) => {
 	let current = identifier;
@@ -60256,7 +61997,8 @@ const rerenderStateOnlyInHandlers = defineRule({
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
 			const bindings = collectUseStateBindings(componentBody, context.scopes);
 			if (bindings.length === 0) return;
-			if (collectRenderReachableExpressions(componentBody).length === 0) return;
+			const renderReachableExpressions = collectRenderReachableExpressions(componentBody);
+			if (renderReachableExpressions.length === 0) return;
 			const eventHandlerReferenceNames = collectFunctionLikeLocalNames(componentBody, context.scopes);
 			const dependencyGraph = buildLocalDependencyGraph(componentBody, eventHandlerReferenceNames);
 			const directRenderNames = collectRenderReachableNames(componentBody, context.scopes, eventHandlerReferenceNames);
@@ -60270,12 +62012,22 @@ const rerenderStateOnlyInHandlers = defineRule({
 			for (const effectInfo of effectInfos) for (const dependencyName of effectInfo.dependencyNames) if (!selfEchoValueNames.has(dependencyName)) effectConsumedNames.add(dependencyName);
 			for (const hookArgumentName of collectCustomHookArgumentNames(componentBody, context.scopes)) effectConsumedNames.add(hookArgumentName);
 			for (const reachableName of expandTransitiveDependencies(effectConsumedNames, dependencyGraph)) renderReachableNames.add(reachableName);
+			const componentFunction = context.cfg.enclosingFunction(componentBody);
+			const doesSetterInvalidateExternalLocation = isFunctionLike$1(componentFunction) ? createExternalLocationInvalidationChecker({
+				componentBody,
+				componentFunction,
+				context,
+				directRenderNames,
+				renderReachableExpressions
+			}) : () => false;
 			const calledSetterNames = /* @__PURE__ */ new Set();
 			walkAst(componentBody, (child) => {
 				if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && setterNames.has(child.callee.name)) calledSetterNames.add(child.callee.name);
 			});
 			for (const binding of bindings) {
 				if (renderReachableNames.has(binding.valueName)) continue;
+				const setterBindingIdentifier = isNodeOfType(binding.declarator.id, "ArrayPattern") ? binding.declarator.id.elements?.[1] : null;
+				if (setterBindingIdentifier && doesSetterInvalidateExternalLocation(setterBindingIdentifier)) continue;
 				if (binding.valueName === "_" || binding.valueName.startsWith("_")) continue;
 				const setterSuffix = binding.setterName.slice(3);
 				if (/^(TriggerRender|ForceUpdate|Rerender|ForceRender|Tick|Bump|BumpVersion|InvalidateRender|Refresh|Repaint)$/i.test(setterSuffix)) continue;
@@ -60828,6 +62580,7 @@ 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) {
@@ -63181,6 +64934,66 @@ 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([
@@ -66281,6 +68094,12 @@ 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.`;
@@ -66317,16 +68136,10 @@ 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;
-		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);
-		}
+		for (const role of roleCandidates) if (!VALID_ARIA_ROLES.has(role)) return;
 		const isImplicit = !roleAttribute;
 		for (const { attribute, propName } of ariaAttributes) {
-			if (supportedSets.some((supported) => supported.has(propName))) continue;
+			if (roleCandidates.some((role) => isAriaPropertySupportedByRole(role, propName))) continue;
 			context.report({
 				node: attribute,
 				message: isImplicit ? buildMessageImplicit(roleCandidates[0], propName, elementType) : buildMessageDefault(roleCandidates, propName)
@@ -71390,18 +73203,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...jsxNoScriptUrl.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/jsx-no-target-blank",
-		id: "jsx-no-target-blank",
-		source: "react-doctor",
-		originallyExternal: true,
-		rule: {
-			...jsxNoTargetBlank,
-			framework: "global",
-			category: "Security",
-			requires: [...new Set(["react", ...jsxNoTargetBlank.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/jsx-no-undef",
 		id: "jsx-no-undef",
@@ -75108,7 +76909,7 @@ const EXTERNAL_RULES = [
 	{
 		key: "react-hooks-js/set-state-in-effect",
 		source: "react-compiler",
-		severity: "error"
+		severity: "warn"
 	},
 	{
 		key: "react-hooks-js/globals",